[Summary view] [Print] [Text view]

   1  /*! jQuery UI - v1.11.4 - 2015-03-11
   2  * http://jqueryui.com
   3  * Includes: core.js, widget.js, mouse.js, position.js, accordion.js, autocomplete.js, button.js, datepicker.js, dialog.js, draggable.js, droppable.js, effect.js, effect-blind.js, effect-bounce.js, effect-clip.js, effect-drop.js, effect-explode.js, effect-fade.js, effect-fold.js, effect-highlight.js, effect-puff.js, effect-pulsate.js, effect-scale.js, effect-shake.js, effect-size.js, effect-slide.js, effect-transfer.js, menu.js, progressbar.js, resizable.js, selectable.js, selectmenu.js, slider.js, sortable.js, spinner.js, tabs.js, tooltip.js
   4  * Copyright 2015 jQuery Foundation and other contributors; Licensed MIT */
   5  
   6  (function( factory ) {
   7      if ( typeof define === "function" && define.amd ) {
   8  
   9          // AMD. Register as an anonymous module.
  10          define([ "jquery" ], factory );
  11      } else {
  12  
  13          // Browser globals
  14          factory( jQuery );
  15      }
  16  }(function( $ ) {
  17  /*!
  18   * jQuery UI Core 1.11.4
  19   * http://jqueryui.com
  20   *
  21   * Copyright jQuery Foundation and other contributors
  22   * Released under the MIT license.
  23   * http://jquery.org/license
  24   *
  25   * http://api.jqueryui.com/category/ui-core/
  26   */
  27  
  28  
  29  // $.ui might exist from components with no dependencies, e.g., $.ui.position
  30  $.ui = $.ui || {};
  31  
  32  $.extend( $.ui, {
  33      version: "1.11.4",
  34  
  35      keyCode: {
  36          BACKSPACE: 8,
  37          COMMA: 188,
  38          DELETE: 46,
  39          DOWN: 40,
  40          END: 35,
  41          ENTER: 13,
  42          ESCAPE: 27,
  43          HOME: 36,
  44          LEFT: 37,
  45          PAGE_DOWN: 34,
  46          PAGE_UP: 33,
  47          PERIOD: 190,
  48          RIGHT: 39,
  49          SPACE: 32,
  50          TAB: 9,
  51          UP: 38
  52      }
  53  });
  54  
  55  // plugins
  56  $.fn.extend({
  57      scrollParent: function( includeHidden ) {
  58          var position = this.css( "position" ),
  59              excludeStaticParent = position === "absolute",
  60              overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
  61              scrollParent = this.parents().filter( function() {
  62                  var parent = $( this );
  63                  if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
  64                      return false;
  65                  }
  66                  return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) + parent.css( "overflow-x" ) );
  67              }).eq( 0 );
  68  
  69          return position === "fixed" || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent;
  70      },
  71  
  72      uniqueId: (function() {
  73          var uuid = 0;
  74  
  75          return function() {
  76              return this.each(function() {
  77                  if ( !this.id ) {
  78                      this.id = "ui-id-" + ( ++uuid );
  79                  }
  80              });
  81          };
  82      })(),
  83  
  84      removeUniqueId: function() {
  85          return this.each(function() {
  86              if ( /^ui-id-\d+$/.test( this.id ) ) {
  87                  $( this ).removeAttr( "id" );
  88              }
  89          });
  90      }
  91  });
  92  
  93  // selectors
  94  function focusable( element, isTabIndexNotNaN ) {
  95      var map, mapName, img,
  96          nodeName = element.nodeName.toLowerCase();
  97      if ( "area" === nodeName ) {
  98          map = element.parentNode;
  99          mapName = map.name;
 100          if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
 101              return false;
 102          }
 103          img = $( "img[usemap='#" + mapName + "']" )[ 0 ];
 104          return !!img && visible( img );
 105      }
 106      return ( /^(input|select|textarea|button|object)$/.test( nodeName ) ?
 107          !element.disabled :
 108          "a" === nodeName ?
 109              element.href || isTabIndexNotNaN :
 110              isTabIndexNotNaN) &&
 111          // the element and all of its ancestors must be visible
 112          visible( element );
 113  }
 114  
 115  function visible( element ) {
 116      return $.expr.filters.visible( element ) &&
 117          !$( element ).parents().addBack().filter(function() {
 118              return $.css( this, "visibility" ) === "hidden";
 119          }).length;
 120  }
 121  
 122  $.extend( $.expr[ ":" ], {
 123      data: $.expr.createPseudo ?
 124          $.expr.createPseudo(function( dataName ) {
 125              return function( elem ) {
 126                  return !!$.data( elem, dataName );
 127              };
 128          }) :
 129          // support: jQuery <1.8
 130          function( elem, i, match ) {
 131              return !!$.data( elem, match[ 3 ] );
 132          },
 133  
 134      focusable: function( element ) {
 135          return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
 136      },
 137  
 138      tabbable: function( element ) {
 139          var tabIndex = $.attr( element, "tabindex" ),
 140              isTabIndexNaN = isNaN( tabIndex );
 141          return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
 142      }
 143  });
 144  
 145  // support: jQuery <1.8
 146  if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
 147      $.each( [ "Width", "Height" ], function( i, name ) {
 148          var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
 149              type = name.toLowerCase(),
 150              orig = {
 151                  innerWidth: $.fn.innerWidth,
 152                  innerHeight: $.fn.innerHeight,
 153                  outerWidth: $.fn.outerWidth,
 154                  outerHeight: $.fn.outerHeight
 155              };
 156  
 157  		function reduce( elem, size, border, margin ) {
 158              $.each( side, function() {
 159                  size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
 160                  if ( border ) {
 161                      size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
 162                  }
 163                  if ( margin ) {
 164                      size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
 165                  }
 166              });
 167              return size;
 168          }
 169  
 170          $.fn[ "inner" + name ] = function( size ) {
 171              if ( size === undefined ) {
 172                  return orig[ "inner" + name ].call( this );
 173              }
 174  
 175              return this.each(function() {
 176                  $( this ).css( type, reduce( this, size ) + "px" );
 177              });
 178          };
 179  
 180          $.fn[ "outer" + name] = function( size, margin ) {
 181              if ( typeof size !== "number" ) {
 182                  return orig[ "outer" + name ].call( this, size );
 183              }
 184  
 185              return this.each(function() {
 186                  $( this).css( type, reduce( this, size, true, margin ) + "px" );
 187              });
 188          };
 189      });
 190  }
 191  
 192  // support: jQuery <1.8
 193  if ( !$.fn.addBack ) {
 194      $.fn.addBack = function( selector ) {
 195          return this.add( selector == null ?
 196              this.prevObject : this.prevObject.filter( selector )
 197          );
 198      };
 199  }
 200  
 201  // support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
 202  if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
 203      $.fn.removeData = (function( removeData ) {
 204          return function( key ) {
 205              if ( arguments.length ) {
 206                  return removeData.call( this, $.camelCase( key ) );
 207              } else {
 208                  return removeData.call( this );
 209              }
 210          };
 211      })( $.fn.removeData );
 212  }
 213  
 214  // deprecated
 215  $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
 216  
 217  $.fn.extend({
 218      focus: (function( orig ) {
 219          return function( delay, fn ) {
 220              return typeof delay === "number" ?
 221                  this.each(function() {
 222                      var elem = this;
 223                      setTimeout(function() {
 224                          $( elem ).focus();
 225                          if ( fn ) {
 226                              fn.call( elem );
 227                          }
 228                      }, delay );
 229                  }) :
 230                  orig.apply( this, arguments );
 231          };
 232      })( $.fn.focus ),
 233  
 234      disableSelection: (function() {
 235          var eventType = "onselectstart" in document.createElement( "div" ) ?
 236              "selectstart" :
 237              "mousedown";
 238  
 239          return function() {
 240              return this.bind( eventType + ".ui-disableSelection", function( event ) {
 241                  event.preventDefault();
 242              });
 243          };
 244      })(),
 245  
 246      enableSelection: function() {
 247          return this.unbind( ".ui-disableSelection" );
 248      },
 249  
 250      zIndex: function( zIndex ) {
 251          if ( zIndex !== undefined ) {
 252              return this.css( "zIndex", zIndex );
 253          }
 254  
 255          if ( this.length ) {
 256              var elem = $( this[ 0 ] ), position, value;
 257              while ( elem.length && elem[ 0 ] !== document ) {
 258                  // Ignore z-index if position is set to a value where z-index is ignored by the browser
 259                  // This makes behavior of this function consistent across browsers
 260                  // WebKit always returns auto if the element is positioned
 261                  position = elem.css( "position" );
 262                  if ( position === "absolute" || position === "relative" || position === "fixed" ) {
 263                      // IE returns 0 when zIndex is not specified
 264                      // other browsers return a string
 265                      // we ignore the case of nested elements with an explicit value of 0
 266                      // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
 267                      value = parseInt( elem.css( "zIndex" ), 10 );
 268                      if ( !isNaN( value ) && value !== 0 ) {
 269                          return value;
 270                      }
 271                  }
 272                  elem = elem.parent();
 273              }
 274          }
 275  
 276          return 0;
 277      }
 278  });
 279  
 280  // $.ui.plugin is deprecated. Use $.widget() extensions instead.
 281  $.ui.plugin = {
 282      add: function( module, option, set ) {
 283          var i,
 284              proto = $.ui[ module ].prototype;
 285          for ( i in set ) {
 286              proto.plugins[ i ] = proto.plugins[ i ] || [];
 287              proto.plugins[ i ].push( [ option, set[ i ] ] );
 288          }
 289      },
 290      call: function( instance, name, args, allowDisconnected ) {
 291          var i,
 292              set = instance.plugins[ name ];
 293  
 294          if ( !set ) {
 295              return;
 296          }
 297  
 298          if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
 299              return;
 300          }
 301  
 302          for ( i = 0; i < set.length; i++ ) {
 303              if ( instance.options[ set[ i ][ 0 ] ] ) {
 304                  set[ i ][ 1 ].apply( instance.element, args );
 305              }
 306          }
 307      }
 308  };
 309  
 310  
 311  /*!
 312   * jQuery UI Widget 1.11.4
 313   * http://jqueryui.com
 314   *
 315   * Copyright jQuery Foundation and other contributors
 316   * Released under the MIT license.
 317   * http://jquery.org/license
 318   *
 319   * http://api.jqueryui.com/jQuery.widget/
 320   */
 321  
 322  
 323  var widget_uuid = 0,
 324      widget_slice = Array.prototype.slice;
 325  
 326  $.cleanData = (function( orig ) {
 327      return function( elems ) {
 328          var events, elem, i;
 329          for ( i = 0; (elem = elems[i]) != null; i++ ) {
 330              try {
 331  
 332                  // Only trigger remove when necessary to save time
 333                  events = $._data( elem, "events" );
 334                  if ( events && events.remove ) {
 335                      $( elem ).triggerHandler( "remove" );
 336                  }
 337  
 338              // http://bugs.jquery.com/ticket/8235
 339              } catch ( e ) {}
 340          }
 341          orig( elems );
 342      };
 343  })( $.cleanData );
 344  
 345  $.widget = function( name, base, prototype ) {
 346      var fullName, existingConstructor, constructor, basePrototype,
 347          // proxiedPrototype allows the provided prototype to remain unmodified
 348          // so that it can be used as a mixin for multiple widgets (#8876)
 349          proxiedPrototype = {},
 350          namespace = name.split( "." )[ 0 ];
 351  
 352      name = name.split( "." )[ 1 ];
 353      fullName = namespace + "-" + name;
 354  
 355      if ( !prototype ) {
 356          prototype = base;
 357          base = $.Widget;
 358      }
 359  
 360      // create selector for plugin
 361      $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
 362          return !!$.data( elem, fullName );
 363      };
 364  
 365      $[ namespace ] = $[ namespace ] || {};
 366      existingConstructor = $[ namespace ][ name ];
 367      constructor = $[ namespace ][ name ] = function( options, element ) {
 368          // allow instantiation without "new" keyword
 369          if ( !this._createWidget ) {
 370              return new constructor( options, element );
 371          }
 372  
 373          // allow instantiation without initializing for simple inheritance
 374          // must use "new" keyword (the code above always passes args)
 375          if ( arguments.length ) {
 376              this._createWidget( options, element );
 377          }
 378      };
 379      // extend with the existing constructor to carry over any static properties
 380      $.extend( constructor, existingConstructor, {
 381          version: prototype.version,
 382          // copy the object used to create the prototype in case we need to
 383          // redefine the widget later
 384          _proto: $.extend( {}, prototype ),
 385          // track widgets that inherit from this widget in case this widget is
 386          // redefined after a widget inherits from it
 387          _childConstructors: []
 388      });
 389  
 390      basePrototype = new base();
 391      // we need to make the options hash a property directly on the new instance
 392      // otherwise we'll modify the options hash on the prototype that we're
 393      // inheriting from
 394      basePrototype.options = $.widget.extend( {}, basePrototype.options );
 395      $.each( prototype, function( prop, value ) {
 396          if ( !$.isFunction( value ) ) {
 397              proxiedPrototype[ prop ] = value;
 398              return;
 399          }
 400          proxiedPrototype[ prop ] = (function() {
 401              var _super = function() {
 402                      return base.prototype[ prop ].apply( this, arguments );
 403                  },
 404                  _superApply = function( args ) {
 405                      return base.prototype[ prop ].apply( this, args );
 406                  };
 407              return function() {
 408                  var __super = this._super,
 409                      __superApply = this._superApply,
 410                      returnValue;
 411  
 412                  this._super = _super;
 413                  this._superApply = _superApply;
 414  
 415                  returnValue = value.apply( this, arguments );
 416  
 417                  this._super = __super;
 418                  this._superApply = __superApply;
 419  
 420                  return returnValue;
 421              };
 422          })();
 423      });
 424      constructor.prototype = $.widget.extend( basePrototype, {
 425          // TODO: remove support for widgetEventPrefix
 426          // always use the name + a colon as the prefix, e.g., draggable:start
 427          // don't prefix for widgets that aren't DOM-based
 428          widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
 429      }, proxiedPrototype, {
 430          constructor: constructor,
 431          namespace: namespace,
 432          widgetName: name,
 433          widgetFullName: fullName
 434      });
 435  
 436      // If this widget is being redefined then we need to find all widgets that
 437      // are inheriting from it and redefine all of them so that they inherit from
 438      // the new version of this widget. We're essentially trying to replace one
 439      // level in the prototype chain.
 440      if ( existingConstructor ) {
 441          $.each( existingConstructor._childConstructors, function( i, child ) {
 442              var childPrototype = child.prototype;
 443  
 444              // redefine the child widget using the same prototype that was
 445              // originally used, but inherit from the new version of the base
 446              $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
 447          });
 448          // remove the list of existing child constructors from the old constructor
 449          // so the old child constructors can be garbage collected
 450          delete existingConstructor._childConstructors;
 451      } else {
 452          base._childConstructors.push( constructor );
 453      }
 454  
 455      $.widget.bridge( name, constructor );
 456  
 457      return constructor;
 458  };
 459  
 460  $.widget.extend = function( target ) {
 461      var input = widget_slice.call( arguments, 1 ),
 462          inputIndex = 0,
 463          inputLength = input.length,
 464          key,
 465          value;
 466      for ( ; inputIndex < inputLength; inputIndex++ ) {
 467          for ( key in input[ inputIndex ] ) {
 468              value = input[ inputIndex ][ key ];
 469              if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
 470                  // Clone objects
 471                  if ( $.isPlainObject( value ) ) {
 472                      target[ key ] = $.isPlainObject( target[ key ] ) ?
 473                          $.widget.extend( {}, target[ key ], value ) :
 474                          // Don't extend strings, arrays, etc. with objects
 475                          $.widget.extend( {}, value );
 476                  // Copy everything else by reference
 477                  } else {
 478                      target[ key ] = value;
 479                  }
 480              }
 481          }
 482      }
 483      return target;
 484  };
 485  
 486  $.widget.bridge = function( name, object ) {
 487      var fullName = object.prototype.widgetFullName || name;
 488      $.fn[ name ] = function( options ) {
 489          var isMethodCall = typeof options === "string",
 490              args = widget_slice.call( arguments, 1 ),
 491              returnValue = this;
 492  
 493          if ( isMethodCall ) {
 494              this.each(function() {
 495                  var methodValue,
 496                      instance = $.data( this, fullName );
 497                  if ( options === "instance" ) {
 498                      returnValue = instance;
 499                      return false;
 500                  }
 501                  if ( !instance ) {
 502                      return $.error( "cannot call methods on " + name + " prior to initialization; " +
 503                          "attempted to call method '" + options + "'" );
 504                  }
 505                  if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
 506                      return $.error( "no such method '" + options + "' for " + name + " widget instance" );
 507                  }
 508                  methodValue = instance[ options ].apply( instance, args );
 509                  if ( methodValue !== instance && methodValue !== undefined ) {
 510                      returnValue = methodValue && methodValue.jquery ?
 511                          returnValue.pushStack( methodValue.get() ) :
 512                          methodValue;
 513                      return false;
 514                  }
 515              });
 516          } else {
 517  
 518              // Allow multiple hashes to be passed on init
 519              if ( args.length ) {
 520                  options = $.widget.extend.apply( null, [ options ].concat(args) );
 521              }
 522  
 523              this.each(function() {
 524                  var instance = $.data( this, fullName );
 525                  if ( instance ) {
 526                      instance.option( options || {} );
 527                      if ( instance._init ) {
 528                          instance._init();
 529                      }
 530                  } else {
 531                      $.data( this, fullName, new object( options, this ) );
 532                  }
 533              });
 534          }
 535  
 536          return returnValue;
 537      };
 538  };
 539  
 540  $.Widget = function( /* options, element */ ) {};
 541  $.Widget._childConstructors = [];
 542  
 543  $.Widget.prototype = {
 544      widgetName: "widget",
 545      widgetEventPrefix: "",
 546      defaultElement: "<div>",
 547      options: {
 548          disabled: false,
 549  
 550          // callbacks
 551          create: null
 552      },
 553      _createWidget: function( options, element ) {
 554          element = $( element || this.defaultElement || this )[ 0 ];
 555          this.element = $( element );
 556          this.uuid = widget_uuid++;
 557          this.eventNamespace = "." + this.widgetName + this.uuid;
 558  
 559          this.bindings = $();
 560          this.hoverable = $();
 561          this.focusable = $();
 562  
 563          if ( element !== this ) {
 564              $.data( element, this.widgetFullName, this );
 565              this._on( true, this.element, {
 566                  remove: function( event ) {
 567                      if ( event.target === element ) {
 568                          this.destroy();
 569                      }
 570                  }
 571              });
 572              this.document = $( element.style ?
 573                  // element within the document
 574                  element.ownerDocument :
 575                  // element is window or document
 576                  element.document || element );
 577              this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
 578          }
 579  
 580          this.options = $.widget.extend( {},
 581              this.options,
 582              this._getCreateOptions(),
 583              options );
 584  
 585          this._create();
 586          this._trigger( "create", null, this._getCreateEventData() );
 587          this._init();
 588      },
 589      _getCreateOptions: $.noop,
 590      _getCreateEventData: $.noop,
 591      _create: $.noop,
 592      _init: $.noop,
 593  
 594      destroy: function() {
 595          this._destroy();
 596          // we can probably remove the unbind calls in 2.0
 597          // all event bindings should go through this._on()
 598          this.element
 599              .unbind( this.eventNamespace )
 600              .removeData( this.widgetFullName )
 601              // support: jquery <1.6.3
 602              // http://bugs.jquery.com/ticket/9413
 603              .removeData( $.camelCase( this.widgetFullName ) );
 604          this.widget()
 605              .unbind( this.eventNamespace )
 606              .removeAttr( "aria-disabled" )
 607              .removeClass(
 608                  this.widgetFullName + "-disabled " +
 609                  "ui-state-disabled" );
 610  
 611          // clean up events and states
 612          this.bindings.unbind( this.eventNamespace );
 613          this.hoverable.removeClass( "ui-state-hover" );
 614          this.focusable.removeClass( "ui-state-focus" );
 615      },
 616      _destroy: $.noop,
 617  
 618      widget: function() {
 619          return this.element;
 620      },
 621  
 622      option: function( key, value ) {
 623          var options = key,
 624              parts,
 625              curOption,
 626              i;
 627  
 628          if ( arguments.length === 0 ) {
 629              // don't return a reference to the internal hash
 630              return $.widget.extend( {}, this.options );
 631          }
 632  
 633          if ( typeof key === "string" ) {
 634              // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
 635              options = {};
 636              parts = key.split( "." );
 637              key = parts.shift();
 638              if ( parts.length ) {
 639                  curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
 640                  for ( i = 0; i < parts.length - 1; i++ ) {
 641                      curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
 642                      curOption = curOption[ parts[ i ] ];
 643                  }
 644                  key = parts.pop();
 645                  if ( arguments.length === 1 ) {
 646                      return curOption[ key ] === undefined ? null : curOption[ key ];
 647                  }
 648                  curOption[ key ] = value;
 649              } else {
 650                  if ( arguments.length === 1 ) {
 651                      return this.options[ key ] === undefined ? null : this.options[ key ];
 652                  }
 653                  options[ key ] = value;
 654              }
 655          }
 656  
 657          this._setOptions( options );
 658  
 659          return this;
 660      },
 661      _setOptions: function( options ) {
 662          var key;
 663  
 664          for ( key in options ) {
 665              this._setOption( key, options[ key ] );
 666          }
 667  
 668          return this;
 669      },
 670      _setOption: function( key, value ) {
 671          this.options[ key ] = value;
 672  
 673          if ( key === "disabled" ) {
 674              this.widget()
 675                  .toggleClass( this.widgetFullName + "-disabled", !!value );
 676  
 677              // If the widget is becoming disabled, then nothing is interactive
 678              if ( value ) {
 679                  this.hoverable.removeClass( "ui-state-hover" );
 680                  this.focusable.removeClass( "ui-state-focus" );
 681              }
 682          }
 683  
 684          return this;
 685      },
 686  
 687      enable: function() {
 688          return this._setOptions({ disabled: false });
 689      },
 690      disable: function() {
 691          return this._setOptions({ disabled: true });
 692      },
 693  
 694      _on: function( suppressDisabledCheck, element, handlers ) {
 695          var delegateElement,
 696              instance = this;
 697  
 698          // no suppressDisabledCheck flag, shuffle arguments
 699          if ( typeof suppressDisabledCheck !== "boolean" ) {
 700              handlers = element;
 701              element = suppressDisabledCheck;
 702              suppressDisabledCheck = false;
 703          }
 704  
 705          // no element argument, shuffle and use this.element
 706          if ( !handlers ) {
 707              handlers = element;
 708              element = this.element;
 709              delegateElement = this.widget();
 710          } else {
 711              element = delegateElement = $( element );
 712              this.bindings = this.bindings.add( element );
 713          }
 714  
 715          $.each( handlers, function( event, handler ) {
 716  			function handlerProxy() {
 717                  // allow widgets to customize the disabled handling
 718                  // - disabled as an array instead of boolean
 719                  // - disabled class as method for disabling individual parts
 720                  if ( !suppressDisabledCheck &&
 721                          ( instance.options.disabled === true ||
 722                              $( this ).hasClass( "ui-state-disabled" ) ) ) {
 723                      return;
 724                  }
 725                  return ( typeof handler === "string" ? instance[ handler ] : handler )
 726                      .apply( instance, arguments );
 727              }
 728  
 729              // copy the guid so direct unbinding works
 730              if ( typeof handler !== "string" ) {
 731                  handlerProxy.guid = handler.guid =
 732                      handler.guid || handlerProxy.guid || $.guid++;
 733              }
 734  
 735              var match = event.match( /^([\w:-]*)\s*(.*)$/ ),
 736                  eventName = match[1] + instance.eventNamespace,
 737                  selector = match[2];
 738              if ( selector ) {
 739                  delegateElement.delegate( selector, eventName, handlerProxy );
 740              } else {
 741                  element.bind( eventName, handlerProxy );
 742              }
 743          });
 744      },
 745  
 746      _off: function( element, eventName ) {
 747          eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) +
 748              this.eventNamespace;
 749          element.unbind( eventName ).undelegate( eventName );
 750  
 751          // Clear the stack to avoid memory leaks (#10056)
 752          this.bindings = $( this.bindings.not( element ).get() );
 753          this.focusable = $( this.focusable.not( element ).get() );
 754          this.hoverable = $( this.hoverable.not( element ).get() );
 755      },
 756  
 757      _delay: function( handler, delay ) {
 758  		function handlerProxy() {
 759              return ( typeof handler === "string" ? instance[ handler ] : handler )
 760                  .apply( instance, arguments );
 761          }
 762          var instance = this;
 763          return setTimeout( handlerProxy, delay || 0 );
 764      },
 765  
 766      _hoverable: function( element ) {
 767          this.hoverable = this.hoverable.add( element );
 768          this._on( element, {
 769              mouseenter: function( event ) {
 770                  $( event.currentTarget ).addClass( "ui-state-hover" );
 771              },
 772              mouseleave: function( event ) {
 773                  $( event.currentTarget ).removeClass( "ui-state-hover" );
 774              }
 775          });
 776      },
 777  
 778      _focusable: function( element ) {
 779          this.focusable = this.focusable.add( element );
 780          this._on( element, {
 781              focusin: function( event ) {
 782                  $( event.currentTarget ).addClass( "ui-state-focus" );
 783              },
 784              focusout: function( event ) {
 785                  $( event.currentTarget ).removeClass( "ui-state-focus" );
 786              }
 787          });
 788      },
 789  
 790      _trigger: function( type, event, data ) {
 791          var prop, orig,
 792              callback = this.options[ type ];
 793  
 794          data = data || {};
 795          event = $.Event( event );
 796          event.type = ( type === this.widgetEventPrefix ?
 797              type :
 798              this.widgetEventPrefix + type ).toLowerCase();
 799          // the original event may come from any element
 800          // so we need to reset the target on the new event
 801          event.target = this.element[ 0 ];
 802  
 803          // copy original event properties over to the new event
 804          orig = event.originalEvent;
 805          if ( orig ) {
 806              for ( prop in orig ) {
 807                  if ( !( prop in event ) ) {
 808                      event[ prop ] = orig[ prop ];
 809                  }
 810              }
 811          }
 812  
 813          this.element.trigger( event, data );
 814          return !( $.isFunction( callback ) &&
 815              callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
 816              event.isDefaultPrevented() );
 817      }
 818  };
 819  
 820  $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
 821      $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
 822          if ( typeof options === "string" ) {
 823              options = { effect: options };
 824          }
 825          var hasOptions,
 826              effectName = !options ?
 827                  method :
 828                  options === true || typeof options === "number" ?
 829                      defaultEffect :
 830                      options.effect || defaultEffect;
 831          options = options || {};
 832          if ( typeof options === "number" ) {
 833              options = { duration: options };
 834          }
 835          hasOptions = !$.isEmptyObject( options );
 836          options.complete = callback;
 837          if ( options.delay ) {
 838              element.delay( options.delay );
 839          }
 840          if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
 841              element[ method ]( options );
 842          } else if ( effectName !== method && element[ effectName ] ) {
 843              element[ effectName ]( options.duration, options.easing, callback );
 844          } else {
 845              element.queue(function( next ) {
 846                  $( this )[ method ]();
 847                  if ( callback ) {
 848                      callback.call( element[ 0 ] );
 849                  }
 850                  next();
 851              });
 852          }
 853      };
 854  });
 855  
 856  var widget = $.widget;
 857  
 858  
 859  /*!
 860   * jQuery UI Mouse 1.11.4
 861   * http://jqueryui.com
 862   *
 863   * Copyright jQuery Foundation and other contributors
 864   * Released under the MIT license.
 865   * http://jquery.org/license
 866   *
 867   * http://api.jqueryui.com/mouse/
 868   */
 869  
 870  
 871  var mouseHandled = false;
 872  $( document ).mouseup( function() {
 873      mouseHandled = false;
 874  });
 875  
 876  var mouse = $.widget("ui.mouse", {
 877      version: "1.11.4",
 878      options: {
 879          cancel: "input,textarea,button,select,option",
 880          distance: 1,
 881          delay: 0
 882      },
 883      _mouseInit: function() {
 884          var that = this;
 885  
 886          this.element
 887              .bind("mousedown." + this.widgetName, function(event) {
 888                  return that._mouseDown(event);
 889              })
 890              .bind("click." + this.widgetName, function(event) {
 891                  if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
 892                      $.removeData(event.target, that.widgetName + ".preventClickEvent");
 893                      event.stopImmediatePropagation();
 894                      return false;
 895                  }
 896              });
 897  
 898          this.started = false;
 899      },
 900  
 901      // TODO: make sure destroying one instance of mouse doesn't mess with
 902      // other instances of mouse
 903      _mouseDestroy: function() {
 904          this.element.unbind("." + this.widgetName);
 905          if ( this._mouseMoveDelegate ) {
 906              this.document
 907                  .unbind("mousemove." + this.widgetName, this._mouseMoveDelegate)
 908                  .unbind("mouseup." + this.widgetName, this._mouseUpDelegate);
 909          }
 910      },
 911  
 912      _mouseDown: function(event) {
 913          // don't let more than one widget handle mouseStart
 914          if ( mouseHandled ) {
 915              return;
 916          }
 917  
 918          this._mouseMoved = false;
 919  
 920          // we may have missed mouseup (out of window)
 921          (this._mouseStarted && this._mouseUp(event));
 922  
 923          this._mouseDownEvent = event;
 924  
 925          var that = this,
 926              btnIsLeft = (event.which === 1),
 927              // event.target.nodeName works around a bug in IE 8 with
 928              // disabled inputs (#7620)
 929              elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
 930          if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
 931              return true;
 932          }
 933  
 934          this.mouseDelayMet = !this.options.delay;
 935          if (!this.mouseDelayMet) {
 936              this._mouseDelayTimer = setTimeout(function() {
 937                  that.mouseDelayMet = true;
 938              }, this.options.delay);
 939          }
 940  
 941          if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
 942              this._mouseStarted = (this._mouseStart(event) !== false);
 943              if (!this._mouseStarted) {
 944                  event.preventDefault();
 945                  return true;
 946              }
 947          }
 948  
 949          // Click event may never have fired (Gecko & Opera)
 950          if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
 951              $.removeData(event.target, this.widgetName + ".preventClickEvent");
 952          }
 953  
 954          // these delegates are required to keep context
 955          this._mouseMoveDelegate = function(event) {
 956              return that._mouseMove(event);
 957          };
 958          this._mouseUpDelegate = function(event) {
 959              return that._mouseUp(event);
 960          };
 961  
 962          this.document
 963              .bind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
 964              .bind( "mouseup." + this.widgetName, this._mouseUpDelegate );
 965  
 966          event.preventDefault();
 967  
 968          mouseHandled = true;
 969          return true;
 970      },
 971  
 972      _mouseMove: function(event) {
 973          // Only check for mouseups outside the document if you've moved inside the document
 974          // at least once. This prevents the firing of mouseup in the case of IE<9, which will
 975          // fire a mousemove event if content is placed under the cursor. See #7778
 976          // Support: IE <9
 977          if ( this._mouseMoved ) {
 978              // IE mouseup check - mouseup happened when mouse was out of window
 979              if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
 980                  return this._mouseUp(event);
 981  
 982              // Iframe mouseup check - mouseup occurred in another document
 983              } else if ( !event.which ) {
 984                  return this._mouseUp( event );
 985              }
 986          }
 987  
 988          if ( event.which || event.button ) {
 989              this._mouseMoved = true;
 990          }
 991  
 992          if (this._mouseStarted) {
 993              this._mouseDrag(event);
 994              return event.preventDefault();
 995          }
 996  
 997          if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
 998              this._mouseStarted =
 999                  (this._mouseStart(this._mouseDownEvent, event) !== false);
1000              (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
1001          }
1002  
1003          return !this._mouseStarted;
1004      },
1005  
1006      _mouseUp: function(event) {
1007          this.document
1008              .unbind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
1009              .unbind( "mouseup." + this.widgetName, this._mouseUpDelegate );
1010  
1011          if (this._mouseStarted) {
1012              this._mouseStarted = false;
1013  
1014              if (event.target === this._mouseDownEvent.target) {
1015                  $.data(event.target, this.widgetName + ".preventClickEvent", true);
1016              }
1017  
1018              this._mouseStop(event);
1019          }
1020  
1021          mouseHandled = false;
1022          return false;
1023      },
1024  
1025      _mouseDistanceMet: function(event) {
1026          return (Math.max(
1027                  Math.abs(this._mouseDownEvent.pageX - event.pageX),
1028                  Math.abs(this._mouseDownEvent.pageY - event.pageY)
1029              ) >= this.options.distance
1030          );
1031      },
1032  
1033      _mouseDelayMet: function(/* event */) {
1034          return this.mouseDelayMet;
1035      },
1036  
1037      // These are placeholder methods, to be overriden by extending plugin
1038      _mouseStart: function(/* event */) {},
1039      _mouseDrag: function(/* event */) {},
1040      _mouseStop: function(/* event */) {},
1041      _mouseCapture: function(/* event */) { return true; }
1042  });
1043  
1044  
1045  /*!
1046   * jQuery UI Position 1.11.4
1047   * http://jqueryui.com
1048   *
1049   * Copyright jQuery Foundation and other contributors
1050   * Released under the MIT license.
1051   * http://jquery.org/license
1052   *
1053   * http://api.jqueryui.com/position/
1054   */
1055  
1056  (function() {
1057  
1058  $.ui = $.ui || {};
1059  
1060  var cachedScrollbarWidth, supportsOffsetFractions,
1061      max = Math.max,
1062      abs = Math.abs,
1063      round = Math.round,
1064      rhorizontal = /left|center|right/,
1065      rvertical = /top|center|bottom/,
1066      roffset = /[\+\-]\d+(\.[\d]+)?%?/,
1067      rposition = /^\w+/,
1068      rpercent = /%$/,
1069      _position = $.fn.position;
1070  
1071  function getOffsets( offsets, width, height ) {
1072      return [
1073          parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
1074          parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
1075      ];
1076  }
1077  
1078  function parseCss( element, property ) {
1079      return parseInt( $.css( element, property ), 10 ) || 0;
1080  }
1081  
1082  function getDimensions( elem ) {
1083      var raw = elem[0];
1084      if ( raw.nodeType === 9 ) {
1085          return {
1086              width: elem.width(),
1087              height: elem.height(),
1088              offset: { top: 0, left: 0 }
1089          };
1090      }
1091      if ( $.isWindow( raw ) ) {
1092          return {
1093              width: elem.width(),
1094              height: elem.height(),
1095              offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
1096          };
1097      }
1098      if ( raw.preventDefault ) {
1099          return {
1100              width: 0,
1101              height: 0,
1102              offset: { top: raw.pageY, left: raw.pageX }
1103          };
1104      }
1105      return {
1106          width: elem.outerWidth(),
1107          height: elem.outerHeight(),
1108          offset: elem.offset()
1109      };
1110  }
1111  
1112  $.position = {
1113      scrollbarWidth: function() {
1114          if ( cachedScrollbarWidth !== undefined ) {
1115              return cachedScrollbarWidth;
1116          }
1117          var w1, w2,
1118              div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
1119              innerDiv = div.children()[0];
1120  
1121          $( "body" ).append( div );
1122          w1 = innerDiv.offsetWidth;
1123          div.css( "overflow", "scroll" );
1124  
1125          w2 = innerDiv.offsetWidth;
1126  
1127          if ( w1 === w2 ) {
1128              w2 = div[0].clientWidth;
1129          }
1130  
1131          div.remove();
1132  
1133          return (cachedScrollbarWidth = w1 - w2);
1134      },
1135      getScrollInfo: function( within ) {
1136          var overflowX = within.isWindow || within.isDocument ? "" :
1137                  within.element.css( "overflow-x" ),
1138              overflowY = within.isWindow || within.isDocument ? "" :
1139                  within.element.css( "overflow-y" ),
1140              hasOverflowX = overflowX === "scroll" ||
1141                  ( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
1142              hasOverflowY = overflowY === "scroll" ||
1143                  ( overflowY === "auto" && within.height < within.element[0].scrollHeight );
1144          return {
1145              width: hasOverflowY ? $.position.scrollbarWidth() : 0,
1146              height: hasOverflowX ? $.position.scrollbarWidth() : 0
1147          };
1148      },
1149      getWithinInfo: function( element ) {
1150          var withinElement = $( element || window ),
1151              isWindow = $.isWindow( withinElement[0] ),
1152              isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
1153          return {
1154              element: withinElement,
1155              isWindow: isWindow,
1156              isDocument: isDocument,
1157              offset: withinElement.offset() || { left: 0, top: 0 },
1158              scrollLeft: withinElement.scrollLeft(),
1159              scrollTop: withinElement.scrollTop(),
1160  
1161              // support: jQuery 1.6.x
1162              // jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows
1163              width: isWindow || isDocument ? withinElement.width() : withinElement.outerWidth(),
1164              height: isWindow || isDocument ? withinElement.height() : withinElement.outerHeight()
1165          };
1166      }
1167  };
1168  
1169  $.fn.position = function( options ) {
1170      if ( !options || !options.of ) {
1171          return _position.apply( this, arguments );
1172      }
1173  
1174      // make a copy, we don't want to modify arguments
1175      options = $.extend( {}, options );
1176  
1177      var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
1178          target = $( options.of ),
1179          within = $.position.getWithinInfo( options.within ),
1180          scrollInfo = $.position.getScrollInfo( within ),
1181          collision = ( options.collision || "flip" ).split( " " ),
1182          offsets = {};
1183  
1184      dimensions = getDimensions( target );
1185      if ( target[0].preventDefault ) {
1186          // force left top to allow flipping
1187          options.at = "left top";
1188      }
1189      targetWidth = dimensions.width;
1190      targetHeight = dimensions.height;
1191      targetOffset = dimensions.offset;
1192      // clone to reuse original targetOffset later
1193      basePosition = $.extend( {}, targetOffset );
1194  
1195      // force my and at to have valid horizontal and vertical positions
1196      // if a value is missing or invalid, it will be converted to center
1197      $.each( [ "my", "at" ], function() {
1198          var pos = ( options[ this ] || "" ).split( " " ),
1199              horizontalOffset,
1200              verticalOffset;
1201  
1202          if ( pos.length === 1) {
1203              pos = rhorizontal.test( pos[ 0 ] ) ?
1204                  pos.concat( [ "center" ] ) :
1205                  rvertical.test( pos[ 0 ] ) ?
1206                      [ "center" ].concat( pos ) :
1207                      [ "center", "center" ];
1208          }
1209          pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
1210          pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
1211  
1212          // calculate offsets
1213          horizontalOffset = roffset.exec( pos[ 0 ] );
1214          verticalOffset = roffset.exec( pos[ 1 ] );
1215          offsets[ this ] = [
1216              horizontalOffset ? horizontalOffset[ 0 ] : 0,
1217              verticalOffset ? verticalOffset[ 0 ] : 0
1218          ];
1219  
1220          // reduce to just the positions without the offsets
1221          options[ this ] = [
1222              rposition.exec( pos[ 0 ] )[ 0 ],
1223              rposition.exec( pos[ 1 ] )[ 0 ]
1224          ];
1225      });
1226  
1227      // normalize collision option
1228      if ( collision.length === 1 ) {
1229          collision[ 1 ] = collision[ 0 ];
1230      }
1231  
1232      if ( options.at[ 0 ] === "right" ) {
1233          basePosition.left += targetWidth;
1234      } else if ( options.at[ 0 ] === "center" ) {
1235          basePosition.left += targetWidth / 2;
1236      }
1237  
1238      if ( options.at[ 1 ] === "bottom" ) {
1239          basePosition.top += targetHeight;
1240      } else if ( options.at[ 1 ] === "center" ) {
1241          basePosition.top += targetHeight / 2;
1242      }
1243  
1244      atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
1245      basePosition.left += atOffset[ 0 ];
1246      basePosition.top += atOffset[ 1 ];
1247  
1248      return this.each(function() {
1249          var collisionPosition, using,
1250              elem = $( this ),
1251              elemWidth = elem.outerWidth(),
1252              elemHeight = elem.outerHeight(),
1253              marginLeft = parseCss( this, "marginLeft" ),
1254              marginTop = parseCss( this, "marginTop" ),
1255              collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
1256              collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
1257              position = $.extend( {}, basePosition ),
1258              myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
1259  
1260          if ( options.my[ 0 ] === "right" ) {
1261              position.left -= elemWidth;
1262          } else if ( options.my[ 0 ] === "center" ) {
1263              position.left -= elemWidth / 2;
1264          }
1265  
1266          if ( options.my[ 1 ] === "bottom" ) {
1267              position.top -= elemHeight;
1268          } else if ( options.my[ 1 ] === "center" ) {
1269              position.top -= elemHeight / 2;
1270          }
1271  
1272          position.left += myOffset[ 0 ];
1273          position.top += myOffset[ 1 ];
1274  
1275          // if the browser doesn't support fractions, then round for consistent results
1276          if ( !supportsOffsetFractions ) {
1277              position.left = round( position.left );
1278              position.top = round( position.top );
1279          }
1280  
1281          collisionPosition = {
1282              marginLeft: marginLeft,
1283              marginTop: marginTop
1284          };
1285  
1286          $.each( [ "left", "top" ], function( i, dir ) {
1287              if ( $.ui.position[ collision[ i ] ] ) {
1288                  $.ui.position[ collision[ i ] ][ dir ]( position, {
1289                      targetWidth: targetWidth,
1290                      targetHeight: targetHeight,
1291                      elemWidth: elemWidth,
1292                      elemHeight: elemHeight,
1293                      collisionPosition: collisionPosition,
1294                      collisionWidth: collisionWidth,
1295                      collisionHeight: collisionHeight,
1296                      offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1297                      my: options.my,
1298                      at: options.at,
1299                      within: within,
1300                      elem: elem
1301                  });
1302              }
1303          });
1304  
1305          if ( options.using ) {
1306              // adds feedback as second argument to using callback, if present
1307              using = function( props ) {
1308                  var left = targetOffset.left - position.left,
1309                      right = left + targetWidth - elemWidth,
1310                      top = targetOffset.top - position.top,
1311                      bottom = top + targetHeight - elemHeight,
1312                      feedback = {
1313                          target: {
1314                              element: target,
1315                              left: targetOffset.left,
1316                              top: targetOffset.top,
1317                              width: targetWidth,
1318                              height: targetHeight
1319                          },
1320                          element: {
1321                              element: elem,
1322                              left: position.left,
1323                              top: position.top,
1324                              width: elemWidth,
1325                              height: elemHeight
1326                          },
1327                          horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1328                          vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1329                      };
1330                  if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1331                      feedback.horizontal = "center";
1332                  }
1333                  if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1334                      feedback.vertical = "middle";
1335                  }
1336                  if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1337                      feedback.important = "horizontal";
1338                  } else {
1339                      feedback.important = "vertical";
1340                  }
1341                  options.using.call( this, props, feedback );
1342              };
1343          }
1344  
1345          elem.offset( $.extend( position, { using: using } ) );
1346      });
1347  };
1348  
1349  $.ui.position = {
1350      fit: {
1351          left: function( position, data ) {
1352              var within = data.within,
1353                  withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1354                  outerWidth = within.width,
1355                  collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1356                  overLeft = withinOffset - collisionPosLeft,
1357                  overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1358                  newOverRight;
1359  
1360              // element is wider than within
1361              if ( data.collisionWidth > outerWidth ) {
1362                  // element is initially over the left side of within
1363                  if ( overLeft > 0 && overRight <= 0 ) {
1364                      newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
1365                      position.left += overLeft - newOverRight;
1366                  // element is initially over right side of within
1367                  } else if ( overRight > 0 && overLeft <= 0 ) {
1368                      position.left = withinOffset;
1369                  // element is initially over both left and right sides of within
1370                  } else {
1371                      if ( overLeft > overRight ) {
1372                          position.left = withinOffset + outerWidth - data.collisionWidth;
1373                      } else {
1374                          position.left = withinOffset;
1375                      }
1376                  }
1377              // too far left -> align with left edge
1378              } else if ( overLeft > 0 ) {
1379                  position.left += overLeft;
1380              // too far right -> align with right edge
1381              } else if ( overRight > 0 ) {
1382                  position.left -= overRight;
1383              // adjust based on position and margin
1384              } else {
1385                  position.left = max( position.left - collisionPosLeft, position.left );
1386              }
1387          },
1388          top: function( position, data ) {
1389              var within = data.within,
1390                  withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1391                  outerHeight = data.within.height,
1392                  collisionPosTop = position.top - data.collisionPosition.marginTop,
1393                  overTop = withinOffset - collisionPosTop,
1394                  overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1395                  newOverBottom;
1396  
1397              // element is taller than within
1398              if ( data.collisionHeight > outerHeight ) {
1399                  // element is initially over the top of within
1400                  if ( overTop > 0 && overBottom <= 0 ) {
1401                      newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
1402                      position.top += overTop - newOverBottom;
1403                  // element is initially over bottom of within
1404                  } else if ( overBottom > 0 && overTop <= 0 ) {
1405                      position.top = withinOffset;
1406                  // element is initially over both top and bottom of within
1407                  } else {
1408                      if ( overTop > overBottom ) {
1409                          position.top = withinOffset + outerHeight - data.collisionHeight;
1410                      } else {
1411                          position.top = withinOffset;
1412                      }
1413                  }
1414              // too far up -> align with top
1415              } else if ( overTop > 0 ) {
1416                  position.top += overTop;
1417              // too far down -> align with bottom edge
1418              } else if ( overBottom > 0 ) {
1419                  position.top -= overBottom;
1420              // adjust based on position and margin
1421              } else {
1422                  position.top = max( position.top - collisionPosTop, position.top );
1423              }
1424          }
1425      },
1426      flip: {
1427          left: function( position, data ) {
1428              var within = data.within,
1429                  withinOffset = within.offset.left + within.scrollLeft,
1430                  outerWidth = within.width,
1431                  offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1432                  collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1433                  overLeft = collisionPosLeft - offsetLeft,
1434                  overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1435                  myOffset = data.my[ 0 ] === "left" ?
1436                      -data.elemWidth :
1437                      data.my[ 0 ] === "right" ?
1438                          data.elemWidth :
1439                          0,
1440                  atOffset = data.at[ 0 ] === "left" ?
1441                      data.targetWidth :
1442                      data.at[ 0 ] === "right" ?
1443                          -data.targetWidth :
1444                          0,
1445                  offset = -2 * data.offset[ 0 ],
1446                  newOverRight,
1447                  newOverLeft;
1448  
1449              if ( overLeft < 0 ) {
1450                  newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
1451                  if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1452                      position.left += myOffset + atOffset + offset;
1453                  }
1454              } else if ( overRight > 0 ) {
1455                  newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
1456                  if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1457                      position.left += myOffset + atOffset + offset;
1458                  }
1459              }
1460          },
1461          top: function( position, data ) {
1462              var within = data.within,
1463                  withinOffset = within.offset.top + within.scrollTop,
1464                  outerHeight = within.height,
1465                  offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1466                  collisionPosTop = position.top - data.collisionPosition.marginTop,
1467                  overTop = collisionPosTop - offsetTop,
1468                  overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1469                  top = data.my[ 1 ] === "top",
1470                  myOffset = top ?
1471                      -data.elemHeight :
1472                      data.my[ 1 ] === "bottom" ?
1473                          data.elemHeight :
1474                          0,
1475                  atOffset = data.at[ 1 ] === "top" ?
1476                      data.targetHeight :
1477                      data.at[ 1 ] === "bottom" ?
1478                          -data.targetHeight :
1479                          0,
1480                  offset = -2 * data.offset[ 1 ],
1481                  newOverTop,
1482                  newOverBottom;
1483              if ( overTop < 0 ) {
1484                  newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
1485                  if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
1486                      position.top += myOffset + atOffset + offset;
1487                  }
1488              } else if ( overBottom > 0 ) {
1489                  newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
1490                  if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
1491                      position.top += myOffset + atOffset + offset;
1492                  }
1493              }
1494          }
1495      },
1496      flipfit: {
1497          left: function() {
1498              $.ui.position.flip.left.apply( this, arguments );
1499              $.ui.position.fit.left.apply( this, arguments );
1500          },
1501          top: function() {
1502              $.ui.position.flip.top.apply( this, arguments );
1503              $.ui.position.fit.top.apply( this, arguments );
1504          }
1505      }
1506  };
1507  
1508  // fraction support test
1509  (function() {
1510      var testElement, testElementParent, testElementStyle, offsetLeft, i,
1511          body = document.getElementsByTagName( "body" )[ 0 ],
1512          div = document.createElement( "div" );
1513  
1514      //Create a "fake body" for testing based on method used in jQuery.support
1515      testElement = document.createElement( body ? "div" : "body" );
1516      testElementStyle = {
1517          visibility: "hidden",
1518          width: 0,
1519          height: 0,
1520          border: 0,
1521          margin: 0,
1522          background: "none"
1523      };
1524      if ( body ) {
1525          $.extend( testElementStyle, {
1526              position: "absolute",
1527              left: "-1000px",
1528              top: "-1000px"
1529          });
1530      }
1531      for ( i in testElementStyle ) {
1532          testElement.style[ i ] = testElementStyle[ i ];
1533      }
1534      testElement.appendChild( div );
1535      testElementParent = body || document.documentElement;
1536      testElementParent.insertBefore( testElement, testElementParent.firstChild );
1537  
1538      div.style.cssText = "position: absolute; left: 10.7432222px;";
1539  
1540      offsetLeft = $( div ).offset().left;
1541      supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11;
1542  
1543      testElement.innerHTML = "";
1544      testElementParent.removeChild( testElement );
1545  })();
1546  
1547  })();
1548  
1549  var position = $.ui.position;
1550  
1551  
1552  /*!
1553   * jQuery UI Accordion 1.11.4
1554   * http://jqueryui.com
1555   *
1556   * Copyright jQuery Foundation and other contributors
1557   * Released under the MIT license.
1558   * http://jquery.org/license
1559   *
1560   * http://api.jqueryui.com/accordion/
1561   */
1562  
1563  
1564  var accordion = $.widget( "ui.accordion", {
1565      version: "1.11.4",
1566      options: {
1567          active: 0,
1568          animate: {},
1569          collapsible: false,
1570          event: "click",
1571          header: "> li > :first-child,> :not(li):even",
1572          heightStyle: "auto",
1573          icons: {
1574              activeHeader: "ui-icon-triangle-1-s",
1575              header: "ui-icon-triangle-1-e"
1576          },
1577  
1578          // callbacks
1579          activate: null,
1580          beforeActivate: null
1581      },
1582  
1583      hideProps: {
1584          borderTopWidth: "hide",
1585          borderBottomWidth: "hide",
1586          paddingTop: "hide",
1587          paddingBottom: "hide",
1588          height: "hide"
1589      },
1590  
1591      showProps: {
1592          borderTopWidth: "show",
1593          borderBottomWidth: "show",
1594          paddingTop: "show",
1595          paddingBottom: "show",
1596          height: "show"
1597      },
1598  
1599      _create: function() {
1600          var options = this.options;
1601          this.prevShow = this.prevHide = $();
1602          this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
1603              // ARIA
1604              .attr( "role", "tablist" );
1605  
1606          // don't allow collapsible: false and active: false / null
1607          if ( !options.collapsible && (options.active === false || options.active == null) ) {
1608              options.active = 0;
1609          }
1610  
1611          this._processPanels();
1612          // handle negative values
1613          if ( options.active < 0 ) {
1614              options.active += this.headers.length;
1615          }
1616          this._refresh();
1617      },
1618  
1619      _getCreateEventData: function() {
1620          return {
1621              header: this.active,
1622              panel: !this.active.length ? $() : this.active.next()
1623          };
1624      },
1625  
1626      _createIcons: function() {
1627          var icons = this.options.icons;
1628          if ( icons ) {
1629              $( "<span>" )
1630                  .addClass( "ui-accordion-header-icon ui-icon " + icons.header )
1631                  .prependTo( this.headers );
1632              this.active.children( ".ui-accordion-header-icon" )
1633                  .removeClass( icons.header )
1634                  .addClass( icons.activeHeader );
1635              this.headers.addClass( "ui-accordion-icons" );
1636          }
1637      },
1638  
1639      _destroyIcons: function() {
1640          this.headers
1641              .removeClass( "ui-accordion-icons" )
1642              .children( ".ui-accordion-header-icon" )
1643                  .remove();
1644      },
1645  
1646      _destroy: function() {
1647          var contents;
1648  
1649          // clean up main element
1650          this.element
1651              .removeClass( "ui-accordion ui-widget ui-helper-reset" )
1652              .removeAttr( "role" );
1653  
1654          // clean up headers
1655          this.headers
1656              .removeClass( "ui-accordion-header ui-accordion-header-active ui-state-default " +
1657                  "ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
1658              .removeAttr( "role" )
1659              .removeAttr( "aria-expanded" )
1660              .removeAttr( "aria-selected" )
1661              .removeAttr( "aria-controls" )
1662              .removeAttr( "tabIndex" )
1663              .removeUniqueId();
1664  
1665          this._destroyIcons();
1666  
1667          // clean up content panels
1668          contents = this.headers.next()
1669              .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom " +
1670                  "ui-accordion-content ui-accordion-content-active ui-state-disabled" )
1671              .css( "display", "" )
1672              .removeAttr( "role" )
1673              .removeAttr( "aria-hidden" )
1674              .removeAttr( "aria-labelledby" )
1675              .removeUniqueId();
1676  
1677          if ( this.options.heightStyle !== "content" ) {
1678              contents.css( "height", "" );
1679          }
1680      },
1681  
1682      _setOption: function( key, value ) {
1683          if ( key === "active" ) {
1684              // _activate() will handle invalid values and update this.options
1685              this._activate( value );
1686              return;
1687          }
1688  
1689          if ( key === "event" ) {
1690              if ( this.options.event ) {
1691                  this._off( this.headers, this.options.event );
1692              }
1693              this._setupEvents( value );
1694          }
1695  
1696          this._super( key, value );
1697  
1698          // setting collapsible: false while collapsed; open first panel
1699          if ( key === "collapsible" && !value && this.options.active === false ) {
1700              this._activate( 0 );
1701          }
1702  
1703          if ( key === "icons" ) {
1704              this._destroyIcons();
1705              if ( value ) {
1706                  this._createIcons();
1707              }
1708          }
1709  
1710          // #5332 - opacity doesn't cascade to positioned elements in IE
1711          // so we need to add the disabled class to the headers and panels
1712          if ( key === "disabled" ) {
1713              this.element
1714                  .toggleClass( "ui-state-disabled", !!value )
1715                  .attr( "aria-disabled", value );
1716              this.headers.add( this.headers.next() )
1717                  .toggleClass( "ui-state-disabled", !!value );
1718          }
1719      },
1720  
1721      _keydown: function( event ) {
1722          if ( event.altKey || event.ctrlKey ) {
1723              return;
1724          }
1725  
1726          var keyCode = $.ui.keyCode,
1727              length = this.headers.length,
1728              currentIndex = this.headers.index( event.target ),
1729              toFocus = false;
1730  
1731          switch ( event.keyCode ) {
1732              case keyCode.RIGHT:
1733              case keyCode.DOWN:
1734                  toFocus = this.headers[ ( currentIndex + 1 ) % length ];
1735                  break;
1736              case keyCode.LEFT:
1737              case keyCode.UP:
1738                  toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
1739                  break;
1740              case keyCode.SPACE:
1741              case keyCode.ENTER:
1742                  this._eventHandler( event );
1743                  break;
1744              case keyCode.HOME:
1745                  toFocus = this.headers[ 0 ];
1746                  break;
1747              case keyCode.END:
1748                  toFocus = this.headers[ length - 1 ];
1749                  break;
1750          }
1751  
1752          if ( toFocus ) {
1753              $( event.target ).attr( "tabIndex", -1 );
1754              $( toFocus ).attr( "tabIndex", 0 );
1755              toFocus.focus();
1756              event.preventDefault();
1757          }
1758      },
1759  
1760      _panelKeyDown: function( event ) {
1761          if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
1762              $( event.currentTarget ).prev().focus();
1763          }
1764      },
1765  
1766      refresh: function() {
1767          var options = this.options;
1768          this._processPanels();
1769  
1770          // was collapsed or no panel
1771          if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
1772              options.active = false;
1773              this.active = $();
1774          // active false only when collapsible is true
1775          } else if ( options.active === false ) {
1776              this._activate( 0 );
1777          // was active, but active panel is gone
1778          } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
1779              // all remaining panel are disabled
1780              if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
1781                  options.active = false;
1782                  this.active = $();
1783              // activate previous panel
1784              } else {
1785                  this._activate( Math.max( 0, options.active - 1 ) );
1786              }
1787          // was active, active panel still exists
1788          } else {
1789              // make sure active index is correct
1790              options.active = this.headers.index( this.active );
1791          }
1792  
1793          this._destroyIcons();
1794  
1795          this._refresh();
1796      },
1797  
1798      _processPanels: function() {
1799          var prevHeaders = this.headers,
1800              prevPanels = this.panels;
1801  
1802          this.headers = this.element.find( this.options.header )
1803              .addClass( "ui-accordion-header ui-state-default ui-corner-all" );
1804  
1805          this.panels = this.headers.next()
1806              .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
1807              .filter( ":not(.ui-accordion-content-active)" )
1808              .hide();
1809  
1810          // Avoid memory leaks (#10056)
1811          if ( prevPanels ) {
1812              this._off( prevHeaders.not( this.headers ) );
1813              this._off( prevPanels.not( this.panels ) );
1814          }
1815      },
1816  
1817      _refresh: function() {
1818          var maxHeight,
1819              options = this.options,
1820              heightStyle = options.heightStyle,
1821              parent = this.element.parent();
1822  
1823          this.active = this._findActive( options.active )
1824              .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
1825              .removeClass( "ui-corner-all" );
1826          this.active.next()
1827              .addClass( "ui-accordion-content-active" )
1828              .show();
1829  
1830          this.headers
1831              .attr( "role", "tab" )
1832              .each(function() {
1833                  var header = $( this ),
1834                      headerId = header.uniqueId().attr( "id" ),
1835                      panel = header.next(),
1836                      panelId = panel.uniqueId().attr( "id" );
1837                  header.attr( "aria-controls", panelId );
1838                  panel.attr( "aria-labelledby", headerId );
1839              })
1840              .next()
1841                  .attr( "role", "tabpanel" );
1842  
1843          this.headers
1844              .not( this.active )
1845              .attr({
1846                  "aria-selected": "false",
1847                  "aria-expanded": "false",
1848                  tabIndex: -1
1849              })
1850              .next()
1851                  .attr({
1852                      "aria-hidden": "true"
1853                  })
1854                  .hide();
1855  
1856          // make sure at least one header is in the tab order
1857          if ( !this.active.length ) {
1858              this.headers.eq( 0 ).attr( "tabIndex", 0 );
1859          } else {
1860              this.active.attr({
1861                  "aria-selected": "true",
1862                  "aria-expanded": "true",
1863                  tabIndex: 0
1864              })
1865              .next()
1866                  .attr({
1867                      "aria-hidden": "false"
1868                  });
1869          }
1870  
1871          this._createIcons();
1872  
1873          this._setupEvents( options.event );
1874  
1875          if ( heightStyle === "fill" ) {
1876              maxHeight = parent.height();
1877              this.element.siblings( ":visible" ).each(function() {
1878                  var elem = $( this ),
1879                      position = elem.css( "position" );
1880  
1881                  if ( position === "absolute" || position === "fixed" ) {
1882                      return;
1883                  }
1884                  maxHeight -= elem.outerHeight( true );
1885              });
1886  
1887              this.headers.each(function() {
1888                  maxHeight -= $( this ).outerHeight( true );
1889              });
1890  
1891              this.headers.next()
1892                  .each(function() {
1893                      $( this ).height( Math.max( 0, maxHeight -
1894                          $( this ).innerHeight() + $( this ).height() ) );
1895                  })
1896                  .css( "overflow", "auto" );
1897          } else if ( heightStyle === "auto" ) {
1898              maxHeight = 0;
1899              this.headers.next()
1900                  .each(function() {
1901                      maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
1902                  })
1903                  .height( maxHeight );
1904          }
1905      },
1906  
1907      _activate: function( index ) {
1908          var active = this._findActive( index )[ 0 ];
1909  
1910          // trying to activate the already active panel
1911          if ( active === this.active[ 0 ] ) {
1912              return;
1913          }
1914  
1915          // trying to collapse, simulate a click on the currently active header
1916          active = active || this.active[ 0 ];
1917  
1918          this._eventHandler({
1919              target: active,
1920              currentTarget: active,
1921              preventDefault: $.noop
1922          });
1923      },
1924  
1925      _findActive: function( selector ) {
1926          return typeof selector === "number" ? this.headers.eq( selector ) : $();
1927      },
1928  
1929      _setupEvents: function( event ) {
1930          var events = {
1931              keydown: "_keydown"
1932          };
1933          if ( event ) {
1934              $.each( event.split( " " ), function( index, eventName ) {
1935                  events[ eventName ] = "_eventHandler";
1936              });
1937          }
1938  
1939          this._off( this.headers.add( this.headers.next() ) );
1940          this._on( this.headers, events );
1941          this._on( this.headers.next(), { keydown: "_panelKeyDown" });
1942          this._hoverable( this.headers );
1943          this._focusable( this.headers );
1944      },
1945  
1946      _eventHandler: function( event ) {
1947          var options = this.options,
1948              active = this.active,
1949              clicked = $( event.currentTarget ),
1950              clickedIsActive = clicked[ 0 ] === active[ 0 ],
1951              collapsing = clickedIsActive && options.collapsible,
1952              toShow = collapsing ? $() : clicked.next(),
1953              toHide = active.next(),
1954              eventData = {
1955                  oldHeader: active,
1956                  oldPanel: toHide,
1957                  newHeader: collapsing ? $() : clicked,
1958                  newPanel: toShow
1959              };
1960  
1961          event.preventDefault();
1962  
1963          if (
1964                  // click on active header, but not collapsible
1965                  ( clickedIsActive && !options.collapsible ) ||
1966                  // allow canceling activation
1967                  ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
1968              return;
1969          }
1970  
1971          options.active = collapsing ? false : this.headers.index( clicked );
1972  
1973          // when the call to ._toggle() comes after the class changes
1974          // it causes a very odd bug in IE 8 (see #6720)
1975          this.active = clickedIsActive ? $() : clicked;
1976          this._toggle( eventData );
1977  
1978          // switch classes
1979          // corner classes on the previously active header stay after the animation
1980          active.removeClass( "ui-accordion-header-active ui-state-active" );
1981          if ( options.icons ) {
1982              active.children( ".ui-accordion-header-icon" )
1983                  .removeClass( options.icons.activeHeader )
1984                  .addClass( options.icons.header );
1985          }
1986  
1987          if ( !clickedIsActive ) {
1988              clicked
1989                  .removeClass( "ui-corner-all" )
1990                  .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
1991              if ( options.icons ) {
1992                  clicked.children( ".ui-accordion-header-icon" )
1993                      .removeClass( options.icons.header )
1994                      .addClass( options.icons.activeHeader );
1995              }
1996  
1997              clicked
1998                  .next()
1999                  .addClass( "ui-accordion-content-active" );
2000          }
2001      },
2002  
2003      _toggle: function( data ) {
2004          var toShow = data.newPanel,
2005              toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
2006  
2007          // handle activating a panel during the animation for another activation
2008          this.prevShow.add( this.prevHide ).stop( true, true );
2009          this.prevShow = toShow;
2010          this.prevHide = toHide;
2011  
2012          if ( this.options.animate ) {
2013              this._animate( toShow, toHide, data );
2014          } else {
2015              toHide.hide();
2016              toShow.show();
2017              this._toggleComplete( data );
2018          }
2019  
2020          toHide.attr({
2021              "aria-hidden": "true"
2022          });
2023          toHide.prev().attr({
2024              "aria-selected": "false",
2025              "aria-expanded": "false"
2026          });
2027          // if we're switching panels, remove the old header from the tab order
2028          // if we're opening from collapsed state, remove the previous header from the tab order
2029          // if we're collapsing, then keep the collapsing header in the tab order
2030          if ( toShow.length && toHide.length ) {
2031              toHide.prev().attr({
2032                  "tabIndex": -1,
2033                  "aria-expanded": "false"
2034              });
2035          } else if ( toShow.length ) {
2036              this.headers.filter(function() {
2037                  return parseInt( $( this ).attr( "tabIndex" ), 10 ) === 0;
2038              })
2039              .attr( "tabIndex", -1 );
2040          }
2041  
2042          toShow
2043              .attr( "aria-hidden", "false" )
2044              .prev()
2045                  .attr({
2046                      "aria-selected": "true",
2047                      "aria-expanded": "true",
2048                      tabIndex: 0
2049                  });
2050      },
2051  
2052      _animate: function( toShow, toHide, data ) {
2053          var total, easing, duration,
2054              that = this,
2055              adjust = 0,
2056              boxSizing = toShow.css( "box-sizing" ),
2057              down = toShow.length &&
2058                  ( !toHide.length || ( toShow.index() < toHide.index() ) ),
2059              animate = this.options.animate || {},
2060              options = down && animate.down || animate,
2061              complete = function() {
2062                  that._toggleComplete( data );
2063              };
2064  
2065          if ( typeof options === "number" ) {
2066              duration = options;
2067          }
2068          if ( typeof options === "string" ) {
2069              easing = options;
2070          }
2071          // fall back from options to animation in case of partial down settings
2072          easing = easing || options.easing || animate.easing;
2073          duration = duration || options.duration || animate.duration;
2074  
2075          if ( !toHide.length ) {
2076              return toShow.animate( this.showProps, duration, easing, complete );
2077          }
2078          if ( !toShow.length ) {
2079              return toHide.animate( this.hideProps, duration, easing, complete );
2080          }
2081  
2082          total = toShow.show().outerHeight();
2083          toHide.animate( this.hideProps, {
2084              duration: duration,
2085              easing: easing,
2086              step: function( now, fx ) {
2087                  fx.now = Math.round( now );
2088              }
2089          });
2090          toShow
2091              .hide()
2092              .animate( this.showProps, {
2093                  duration: duration,
2094                  easing: easing,
2095                  complete: complete,
2096                  step: function( now, fx ) {
2097                      fx.now = Math.round( now );
2098                      if ( fx.prop !== "height" ) {
2099                          if ( boxSizing === "content-box" ) {
2100                              adjust += fx.now;
2101                          }
2102                      } else if ( that.options.heightStyle !== "content" ) {
2103                          fx.now = Math.round( total - toHide.outerHeight() - adjust );
2104                          adjust = 0;
2105                      }
2106                  }
2107              });
2108      },
2109  
2110      _toggleComplete: function( data ) {
2111          var toHide = data.oldPanel;
2112  
2113          toHide
2114              .removeClass( "ui-accordion-content-active" )
2115              .prev()
2116                  .removeClass( "ui-corner-top" )
2117                  .addClass( "ui-corner-all" );
2118  
2119          // Work around for rendering bug in IE (#5421)
2120          if ( toHide.length ) {
2121              toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
2122          }
2123          this._trigger( "activate", null, data );
2124      }
2125  });
2126  
2127  
2128  /*!
2129   * jQuery UI Menu 1.11.4
2130   * http://jqueryui.com
2131   *
2132   * Copyright jQuery Foundation and other contributors
2133   * Released under the MIT license.
2134   * http://jquery.org/license
2135   *
2136   * http://api.jqueryui.com/menu/
2137   */
2138  
2139  
2140  var menu = $.widget( "ui.menu", {
2141      version: "1.11.4",
2142      defaultElement: "<ul>",
2143      delay: 300,
2144      options: {
2145          icons: {
2146              submenu: "ui-icon-carat-1-e"
2147          },
2148          items: "> *",
2149          menus: "ul",
2150          position: {
2151              my: "left-1 top",
2152              at: "right top"
2153          },
2154          role: "menu",
2155  
2156          // callbacks
2157          blur: null,
2158          focus: null,
2159          select: null
2160      },
2161  
2162      _create: function() {
2163          this.activeMenu = this.element;
2164  
2165          // Flag used to prevent firing of the click handler
2166          // as the event bubbles up through nested menus
2167          this.mouseHandled = false;
2168          this.element
2169              .uniqueId()
2170              .addClass( "ui-menu ui-widget ui-widget-content" )
2171              .toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
2172              .attr({
2173                  role: this.options.role,
2174                  tabIndex: 0
2175              });
2176  
2177          if ( this.options.disabled ) {
2178              this.element
2179                  .addClass( "ui-state-disabled" )
2180                  .attr( "aria-disabled", "true" );
2181          }
2182  
2183          this._on({
2184              // Prevent focus from sticking to links inside menu after clicking
2185              // them (focus should always stay on UL during navigation).
2186              "mousedown .ui-menu-item": function( event ) {
2187                  event.preventDefault();
2188              },
2189              "click .ui-menu-item": function( event ) {
2190                  var target = $( event.target );
2191                  if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
2192                      this.select( event );
2193  
2194                      // Only set the mouseHandled flag if the event will bubble, see #9469.
2195                      if ( !event.isPropagationStopped() ) {
2196                          this.mouseHandled = true;
2197                      }
2198  
2199                      // Open submenu on click
2200                      if ( target.has( ".ui-menu" ).length ) {
2201                          this.expand( event );
2202                      } else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) {
2203  
2204                          // Redirect focus to the menu
2205                          this.element.trigger( "focus", [ true ] );
2206  
2207                          // If the active item is on the top level, let it stay active.
2208                          // Otherwise, blur the active item since it is no longer visible.
2209                          if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
2210                              clearTimeout( this.timer );
2211                          }
2212                      }
2213                  }
2214              },
2215              "mouseenter .ui-menu-item": function( event ) {
2216                  // Ignore mouse events while typeahead is active, see #10458.
2217                  // Prevents focusing the wrong item when typeahead causes a scroll while the mouse
2218                  // is over an item in the menu
2219                  if ( this.previousFilter ) {
2220                      return;
2221                  }
2222                  var target = $( event.currentTarget );
2223                  // Remove ui-state-active class from siblings of the newly focused menu item
2224                  // to avoid a jump caused by adjacent elements both having a class with a border
2225                  target.siblings( ".ui-state-active" ).removeClass( "ui-state-active" );
2226                  this.focus( event, target );
2227              },
2228              mouseleave: "collapseAll",
2229              "mouseleave .ui-menu": "collapseAll",
2230              focus: function( event, keepActiveItem ) {
2231                  // If there's already an active item, keep it active
2232                  // If not, activate the first item
2233                  var item = this.active || this.element.find( this.options.items ).eq( 0 );
2234  
2235                  if ( !keepActiveItem ) {
2236                      this.focus( event, item );
2237                  }
2238              },
2239              blur: function( event ) {
2240                  this._delay(function() {
2241                      if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
2242                          this.collapseAll( event );
2243                      }
2244                  });
2245              },
2246              keydown: "_keydown"
2247          });
2248  
2249          this.refresh();
2250  
2251          // Clicks outside of a menu collapse any open menus
2252          this._on( this.document, {
2253              click: function( event ) {
2254                  if ( this._closeOnDocumentClick( event ) ) {
2255                      this.collapseAll( event );
2256                  }
2257  
2258                  // Reset the mouseHandled flag
2259                  this.mouseHandled = false;
2260              }
2261          });
2262      },
2263  
2264      _destroy: function() {
2265          // Destroy (sub)menus
2266          this.element
2267              .removeAttr( "aria-activedescendant" )
2268              .find( ".ui-menu" ).addBack()
2269                  .removeClass( "ui-menu ui-widget ui-widget-content ui-menu-icons ui-front" )
2270                  .removeAttr( "role" )
2271                  .removeAttr( "tabIndex" )
2272                  .removeAttr( "aria-labelledby" )
2273                  .removeAttr( "aria-expanded" )
2274                  .removeAttr( "aria-hidden" )
2275                  .removeAttr( "aria-disabled" )
2276                  .removeUniqueId()
2277                  .show();
2278  
2279          // Destroy menu items
2280          this.element.find( ".ui-menu-item" )
2281              .removeClass( "ui-menu-item" )
2282              .removeAttr( "role" )
2283              .removeAttr( "aria-disabled" )
2284              .removeUniqueId()
2285              .removeClass( "ui-state-hover" )
2286              .removeAttr( "tabIndex" )
2287              .removeAttr( "role" )
2288              .removeAttr( "aria-haspopup" )
2289              .children().each( function() {
2290                  var elem = $( this );
2291                  if ( elem.data( "ui-menu-submenu-carat" ) ) {
2292                      elem.remove();
2293                  }
2294              });
2295  
2296          // Destroy menu dividers
2297          this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
2298      },
2299  
2300      _keydown: function( event ) {
2301          var match, prev, character, skip,
2302              preventDefault = true;
2303  
2304          switch ( event.keyCode ) {
2305          case $.ui.keyCode.PAGE_UP:
2306              this.previousPage( event );
2307              break;
2308          case $.ui.keyCode.PAGE_DOWN:
2309              this.nextPage( event );
2310              break;
2311          case $.ui.keyCode.HOME:
2312              this._move( "first", "first", event );
2313              break;
2314          case $.ui.keyCode.END:
2315              this._move( "last", "last", event );
2316              break;
2317          case $.ui.keyCode.UP:
2318              this.previous( event );
2319              break;
2320          case $.ui.keyCode.DOWN:
2321              this.next( event );
2322              break;
2323          case $.ui.keyCode.LEFT:
2324              this.collapse( event );
2325              break;
2326          case $.ui.keyCode.RIGHT:
2327              if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
2328                  this.expand( event );
2329              }
2330              break;
2331          case $.ui.keyCode.ENTER:
2332          case $.ui.keyCode.SPACE:
2333              this._activate( event );
2334              break;
2335          case $.ui.keyCode.ESCAPE:
2336              this.collapse( event );
2337              break;
2338          default:
2339              preventDefault = false;
2340              prev = this.previousFilter || "";
2341              character = String.fromCharCode( event.keyCode );
2342              skip = false;
2343  
2344              clearTimeout( this.filterTimer );
2345  
2346              if ( character === prev ) {
2347                  skip = true;
2348              } else {
2349                  character = prev + character;
2350              }
2351  
2352              match = this._filterMenuItems( character );
2353              match = skip && match.index( this.active.next() ) !== -1 ?
2354                  this.active.nextAll( ".ui-menu-item" ) :
2355                  match;
2356  
2357              // If no matches on the current filter, reset to the last character pressed
2358              // to move down the menu to the first item that starts with that character
2359              if ( !match.length ) {
2360                  character = String.fromCharCode( event.keyCode );
2361                  match = this._filterMenuItems( character );
2362              }
2363  
2364              if ( match.length ) {
2365                  this.focus( event, match );
2366                  this.previousFilter = character;
2367                  this.filterTimer = this._delay(function() {
2368                      delete this.previousFilter;
2369                  }, 1000 );
2370              } else {
2371                  delete this.previousFilter;
2372              }
2373          }
2374  
2375          if ( preventDefault ) {
2376              event.preventDefault();
2377          }
2378      },
2379  
2380      _activate: function( event ) {
2381          if ( !this.active.is( ".ui-state-disabled" ) ) {
2382              if ( this.active.is( "[aria-haspopup='true']" ) ) {
2383                  this.expand( event );
2384              } else {
2385                  this.select( event );
2386              }
2387          }
2388      },
2389  
2390      refresh: function() {
2391          var menus, items,
2392              that = this,
2393              icon = this.options.icons.submenu,
2394              submenus = this.element.find( this.options.menus );
2395  
2396          this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length );
2397  
2398          // Initialize nested menus
2399          submenus.filter( ":not(.ui-menu)" )
2400              .addClass( "ui-menu ui-widget ui-widget-content ui-front" )
2401              .hide()
2402              .attr({
2403                  role: this.options.role,
2404                  "aria-hidden": "true",
2405                  "aria-expanded": "false"
2406              })
2407              .each(function() {
2408                  var menu = $( this ),
2409                      item = menu.parent(),
2410                      submenuCarat = $( "<span>" )
2411                          .addClass( "ui-menu-icon ui-icon " + icon )
2412                          .data( "ui-menu-submenu-carat", true );
2413  
2414                  item
2415                      .attr( "aria-haspopup", "true" )
2416                      .prepend( submenuCarat );
2417                  menu.attr( "aria-labelledby", item.attr( "id" ) );
2418              });
2419  
2420          menus = submenus.add( this.element );
2421          items = menus.find( this.options.items );
2422  
2423          // Initialize menu-items containing spaces and/or dashes only as dividers
2424          items.not( ".ui-menu-item" ).each(function() {
2425              var item = $( this );
2426              if ( that._isDivider( item ) ) {
2427                  item.addClass( "ui-widget-content ui-menu-divider" );
2428              }
2429          });
2430  
2431          // Don't refresh list items that are already adapted
2432          items.not( ".ui-menu-item, .ui-menu-divider" )
2433              .addClass( "ui-menu-item" )
2434              .uniqueId()
2435              .attr({
2436                  tabIndex: -1,
2437                  role: this._itemRole()
2438              });
2439  
2440          // Add aria-disabled attribute to any disabled menu item
2441          items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
2442  
2443          // If the active item has been removed, blur the menu
2444          if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
2445              this.blur();
2446          }
2447      },
2448  
2449      _itemRole: function() {
2450          return {
2451              menu: "menuitem",
2452              listbox: "option"
2453          }[ this.options.role ];
2454      },
2455  
2456      _setOption: function( key, value ) {
2457          if ( key === "icons" ) {
2458              this.element.find( ".ui-menu-icon" )
2459                  .removeClass( this.options.icons.submenu )
2460                  .addClass( value.submenu );
2461          }
2462          if ( key === "disabled" ) {
2463              this.element
2464                  .toggleClass( "ui-state-disabled", !!value )
2465                  .attr( "aria-disabled", value );
2466          }
2467          this._super( key, value );
2468      },
2469  
2470      focus: function( event, item ) {
2471          var nested, focused;
2472          this.blur( event, event && event.type === "focus" );
2473  
2474          this._scrollIntoView( item );
2475  
2476          this.active = item.first();
2477          focused = this.active.addClass( "ui-state-focus" ).removeClass( "ui-state-active" );
2478          // Only update aria-activedescendant if there's a role
2479          // otherwise we assume focus is managed elsewhere
2480          if ( this.options.role ) {
2481              this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
2482          }
2483  
2484          // Highlight active parent menu item, if any
2485          this.active
2486              .parent()
2487              .closest( ".ui-menu-item" )
2488              .addClass( "ui-state-active" );
2489  
2490          if ( event && event.type === "keydown" ) {
2491              this._close();
2492          } else {
2493              this.timer = this._delay(function() {
2494                  this._close();
2495              }, this.delay );
2496          }
2497  
2498          nested = item.children( ".ui-menu" );
2499          if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
2500              this._startOpening(nested);
2501          }
2502          this.activeMenu = item.parent();
2503  
2504          this._trigger( "focus", event, { item: item } );
2505      },
2506  
2507      _scrollIntoView: function( item ) {
2508          var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
2509          if ( this._hasScroll() ) {
2510              borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
2511              paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
2512              offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
2513              scroll = this.activeMenu.scrollTop();
2514              elementHeight = this.activeMenu.height();
2515              itemHeight = item.outerHeight();
2516  
2517              if ( offset < 0 ) {
2518                  this.activeMenu.scrollTop( scroll + offset );
2519              } else if ( offset + itemHeight > elementHeight ) {
2520                  this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
2521              }
2522          }
2523      },
2524  
2525      blur: function( event, fromFocus ) {
2526          if ( !fromFocus ) {
2527              clearTimeout( this.timer );
2528          }
2529  
2530          if ( !this.active ) {
2531              return;
2532          }
2533  
2534          this.active.removeClass( "ui-state-focus" );
2535          this.active = null;
2536  
2537          this._trigger( "blur", event, { item: this.active } );
2538      },
2539  
2540      _startOpening: function( submenu ) {
2541          clearTimeout( this.timer );
2542  
2543          // Don't open if already open fixes a Firefox bug that caused a .5 pixel
2544          // shift in the submenu position when mousing over the carat icon
2545          if ( submenu.attr( "aria-hidden" ) !== "true" ) {
2546              return;
2547          }
2548  
2549          this.timer = this._delay(function() {
2550              this._close();
2551              this._open( submenu );
2552          }, this.delay );
2553      },
2554  
2555      _open: function( submenu ) {
2556          var position = $.extend({
2557              of: this.active
2558          }, this.options.position );
2559  
2560          clearTimeout( this.timer );
2561          this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
2562              .hide()
2563              .attr( "aria-hidden", "true" );
2564  
2565          submenu
2566              .show()
2567              .removeAttr( "aria-hidden" )
2568              .attr( "aria-expanded", "true" )
2569              .position( position );
2570      },
2571  
2572      collapseAll: function( event, all ) {
2573          clearTimeout( this.timer );
2574          this.timer = this._delay(function() {
2575              // If we were passed an event, look for the submenu that contains the event
2576              var currentMenu = all ? this.element :
2577                  $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
2578  
2579              // If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
2580              if ( !currentMenu.length ) {
2581                  currentMenu = this.element;
2582              }
2583  
2584              this._close( currentMenu );
2585  
2586              this.blur( event );
2587              this.activeMenu = currentMenu;
2588          }, this.delay );
2589      },
2590  
2591      // With no arguments, closes the currently active menu - if nothing is active
2592      // it closes all menus.  If passed an argument, it will search for menus BELOW
2593      _close: function( startMenu ) {
2594          if ( !startMenu ) {
2595              startMenu = this.active ? this.active.parent() : this.element;
2596          }
2597  
2598          startMenu
2599              .find( ".ui-menu" )
2600                  .hide()
2601                  .attr( "aria-hidden", "true" )
2602                  .attr( "aria-expanded", "false" )
2603              .end()
2604              .find( ".ui-state-active" ).not( ".ui-state-focus" )
2605                  .removeClass( "ui-state-active" );
2606      },
2607  
2608      _closeOnDocumentClick: function( event ) {
2609          return !$( event.target ).closest( ".ui-menu" ).length;
2610      },
2611  
2612      _isDivider: function( item ) {
2613  
2614          // Match hyphen, em dash, en dash
2615          return !/[^\-\u2014\u2013\s]/.test( item.text() );
2616      },
2617  
2618      collapse: function( event ) {
2619          var newItem = this.active &&
2620              this.active.parent().closest( ".ui-menu-item", this.element );
2621          if ( newItem && newItem.length ) {
2622              this._close();
2623              this.focus( event, newItem );
2624          }
2625      },
2626  
2627      expand: function( event ) {
2628          var newItem = this.active &&
2629              this.active
2630                  .children( ".ui-menu " )
2631                  .find( this.options.items )
2632                  .first();
2633  
2634          if ( newItem && newItem.length ) {
2635              this._open( newItem.parent() );
2636  
2637              // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
2638              this._delay(function() {
2639                  this.focus( event, newItem );
2640              });
2641          }
2642      },
2643  
2644      next: function( event ) {
2645          this._move( "next", "first", event );
2646      },
2647  
2648      previous: function( event ) {
2649          this._move( "prev", "last", event );
2650      },
2651  
2652      isFirstItem: function() {
2653          return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
2654      },
2655  
2656      isLastItem: function() {
2657          return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
2658      },
2659  
2660      _move: function( direction, filter, event ) {
2661          var next;
2662          if ( this.active ) {
2663              if ( direction === "first" || direction === "last" ) {
2664                  next = this.active
2665                      [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
2666                      .eq( -1 );
2667              } else {
2668                  next = this.active
2669                      [ direction + "All" ]( ".ui-menu-item" )
2670                      .eq( 0 );
2671              }
2672          }
2673          if ( !next || !next.length || !this.active ) {
2674              next = this.activeMenu.find( this.options.items )[ filter ]();
2675          }
2676  
2677          this.focus( event, next );
2678      },
2679  
2680      nextPage: function( event ) {
2681          var item, base, height;
2682  
2683          if ( !this.active ) {
2684              this.next( event );
2685              return;
2686          }
2687          if ( this.isLastItem() ) {
2688              return;
2689          }
2690          if ( this._hasScroll() ) {
2691              base = this.active.offset().top;
2692              height = this.element.height();
2693              this.active.nextAll( ".ui-menu-item" ).each(function() {
2694                  item = $( this );
2695                  return item.offset().top - base - height < 0;
2696              });
2697  
2698              this.focus( event, item );
2699          } else {
2700              this.focus( event, this.activeMenu.find( this.options.items )
2701                  [ !this.active ? "first" : "last" ]() );
2702          }
2703      },
2704  
2705      previousPage: function( event ) {
2706          var item, base, height;
2707          if ( !this.active ) {
2708              this.next( event );
2709              return;
2710          }
2711          if ( this.isFirstItem() ) {
2712              return;
2713          }
2714          if ( this._hasScroll() ) {
2715              base = this.active.offset().top;
2716              height = this.element.height();
2717              this.active.prevAll( ".ui-menu-item" ).each(function() {
2718                  item = $( this );
2719                  return item.offset().top - base + height > 0;
2720              });
2721  
2722              this.focus( event, item );
2723          } else {
2724              this.focus( event, this.activeMenu.find( this.options.items ).first() );
2725          }
2726      },
2727  
2728      _hasScroll: function() {
2729          return this.element.outerHeight() < this.element.prop( "scrollHeight" );
2730      },
2731  
2732      select: function( event ) {
2733          // TODO: It should never be possible to not have an active item at this
2734          // point, but the tests don't trigger mouseenter before click.
2735          this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
2736          var ui = { item: this.active };
2737          if ( !this.active.has( ".ui-menu" ).length ) {
2738              this.collapseAll( event, true );
2739          }
2740          this._trigger( "select", event, ui );
2741      },
2742  
2743      _filterMenuItems: function(character) {
2744          var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ),
2745              regex = new RegExp( "^" + escapedCharacter, "i" );
2746  
2747          return this.activeMenu
2748              .find( this.options.items )
2749  
2750              // Only match on items, not dividers or other content (#10571)
2751              .filter( ".ui-menu-item" )
2752              .filter(function() {
2753                  return regex.test( $.trim( $( this ).text() ) );
2754              });
2755      }
2756  });
2757  
2758  
2759  /*!
2760   * jQuery UI Autocomplete 1.11.4
2761   * http://jqueryui.com
2762   *
2763   * Copyright jQuery Foundation and other contributors
2764   * Released under the MIT license.
2765   * http://jquery.org/license
2766   *
2767   * http://api.jqueryui.com/autocomplete/
2768   */
2769  
2770  
2771  $.widget( "ui.autocomplete", {
2772      version: "1.11.4",
2773      defaultElement: "<input>",
2774      options: {
2775          appendTo: null,
2776          autoFocus: false,
2777          delay: 300,
2778          minLength: 1,
2779          position: {
2780              my: "left top",
2781              at: "left bottom",
2782              collision: "none"
2783          },
2784          source: null,
2785  
2786          // callbacks
2787          change: null,
2788          close: null,
2789          focus: null,
2790          open: null,
2791          response: null,
2792          search: null,
2793          select: null
2794      },
2795  
2796      requestIndex: 0,
2797      pending: 0,
2798  
2799      _create: function() {
2800          // Some browsers only repeat keydown events, not keypress events,
2801          // so we use the suppressKeyPress flag to determine if we've already
2802          // handled the keydown event. #7269
2803          // Unfortunately the code for & in keypress is the same as the up arrow,
2804          // so we use the suppressKeyPressRepeat flag to avoid handling keypress
2805          // events when we know the keydown event was used to modify the
2806          // search term. #7799
2807          var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
2808              nodeName = this.element[ 0 ].nodeName.toLowerCase(),
2809              isTextarea = nodeName === "textarea",
2810              isInput = nodeName === "input";
2811  
2812          this.isMultiLine =
2813              // Textareas are always multi-line
2814              isTextarea ? true :
2815              // Inputs are always single-line, even if inside a contentEditable element
2816              // IE also treats inputs as contentEditable
2817              isInput ? false :
2818              // All other element types are determined by whether or not they're contentEditable
2819              this.element.prop( "isContentEditable" );
2820  
2821          this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
2822          this.isNewMenu = true;
2823  
2824          this.element
2825              .addClass( "ui-autocomplete-input" )
2826              .attr( "autocomplete", "off" );
2827  
2828          this._on( this.element, {
2829              keydown: function( event ) {
2830                  if ( this.element.prop( "readOnly" ) ) {
2831                      suppressKeyPress = true;
2832                      suppressInput = true;
2833                      suppressKeyPressRepeat = true;
2834                      return;
2835                  }
2836  
2837                  suppressKeyPress = false;
2838                  suppressInput = false;
2839                  suppressKeyPressRepeat = false;
2840                  var keyCode = $.ui.keyCode;
2841                  switch ( event.keyCode ) {
2842                  case keyCode.PAGE_UP:
2843                      suppressKeyPress = true;
2844                      this._move( "previousPage", event );
2845                      break;
2846                  case keyCode.PAGE_DOWN:
2847                      suppressKeyPress = true;
2848                      this._move( "nextPage", event );
2849                      break;
2850                  case keyCode.UP:
2851                      suppressKeyPress = true;
2852                      this._keyEvent( "previous", event );
2853                      break;
2854                  case keyCode.DOWN:
2855                      suppressKeyPress = true;
2856                      this._keyEvent( "next", event );
2857                      break;
2858                  case keyCode.ENTER:
2859                      // when menu is open and has focus
2860                      if ( this.menu.active ) {
2861                          // #6055 - Opera still allows the keypress to occur
2862                          // which causes forms to submit
2863                          suppressKeyPress = true;
2864                          event.preventDefault();
2865                          this.menu.select( event );
2866                      }
2867                      break;
2868                  case keyCode.TAB:
2869                      if ( this.menu.active ) {
2870                          this.menu.select( event );
2871                      }
2872                      break;
2873                  case keyCode.ESCAPE:
2874                      if ( this.menu.element.is( ":visible" ) ) {
2875                          if ( !this.isMultiLine ) {
2876                              this._value( this.term );
2877                          }
2878                          this.close( event );
2879                          // Different browsers have different default behavior for escape
2880                          // Single press can mean undo or clear
2881                          // Double press in IE means clear the whole form
2882                          event.preventDefault();
2883                      }
2884                      break;
2885                  default:
2886                      suppressKeyPressRepeat = true;
2887                      // search timeout should be triggered before the input value is changed
2888                      this._searchTimeout( event );
2889                      break;
2890                  }
2891              },
2892              keypress: function( event ) {
2893                  if ( suppressKeyPress ) {
2894                      suppressKeyPress = false;
2895                      if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
2896                          event.preventDefault();
2897                      }
2898                      return;
2899                  }
2900                  if ( suppressKeyPressRepeat ) {
2901                      return;
2902                  }
2903  
2904                  // replicate some key handlers to allow them to repeat in Firefox and Opera
2905                  var keyCode = $.ui.keyCode;
2906                  switch ( event.keyCode ) {
2907                  case keyCode.PAGE_UP:
2908                      this._move( "previousPage", event );
2909                      break;
2910                  case keyCode.PAGE_DOWN:
2911                      this._move( "nextPage", event );
2912                      break;
2913                  case keyCode.UP:
2914                      this._keyEvent( "previous", event );
2915                      break;
2916                  case keyCode.DOWN:
2917                      this._keyEvent( "next", event );
2918                      break;
2919                  }
2920              },
2921              input: function( event ) {
2922                  if ( suppressInput ) {
2923                      suppressInput = false;
2924                      event.preventDefault();
2925                      return;
2926                  }
2927                  this._searchTimeout( event );
2928              },
2929              focus: function() {
2930                  this.selectedItem = null;
2931                  this.previous = this._value();
2932              },
2933              blur: function( event ) {
2934                  if ( this.cancelBlur ) {
2935                      delete this.cancelBlur;
2936                      return;
2937                  }
2938  
2939                  clearTimeout( this.searching );
2940                  this.close( event );
2941                  this._change( event );
2942              }
2943          });
2944  
2945          this._initSource();
2946          this.menu = $( "<ul>" )
2947              .addClass( "ui-autocomplete ui-front" )
2948              .appendTo( this._appendTo() )
2949              .menu({
2950                  // disable ARIA support, the live region takes care of that
2951                  role: null
2952              })
2953              .hide()
2954              .menu( "instance" );
2955  
2956          this._on( this.menu.element, {
2957              mousedown: function( event ) {
2958                  // prevent moving focus out of the text field
2959                  event.preventDefault();
2960  
2961                  // IE doesn't prevent moving focus even with event.preventDefault()
2962                  // so we set a flag to know when we should ignore the blur event
2963                  this.cancelBlur = true;
2964                  this._delay(function() {
2965                      delete this.cancelBlur;
2966                  });
2967  
2968                  // clicking on the scrollbar causes focus to shift to the body
2969                  // but we can't detect a mouseup or a click immediately afterward
2970                  // so we have to track the next mousedown and close the menu if
2971                  // the user clicks somewhere outside of the autocomplete
2972                  var menuElement = this.menu.element[ 0 ];
2973                  if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
2974                      this._delay(function() {
2975                          var that = this;
2976                          this.document.one( "mousedown", function( event ) {
2977                              if ( event.target !== that.element[ 0 ] &&
2978                                      event.target !== menuElement &&
2979                                      !$.contains( menuElement, event.target ) ) {
2980                                  that.close();
2981                              }
2982                          });
2983                      });
2984                  }
2985              },
2986              menufocus: function( event, ui ) {
2987                  var label, item;
2988                  // support: Firefox
2989                  // Prevent accidental activation of menu items in Firefox (#7024 #9118)
2990                  if ( this.isNewMenu ) {
2991                      this.isNewMenu = false;
2992                      if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
2993                          this.menu.blur();
2994  
2995                          this.document.one( "mousemove", function() {
2996                              $( event.target ).trigger( event.originalEvent );
2997                          });
2998  
2999                          return;
3000                      }
3001                  }
3002  
3003                  item = ui.item.data( "ui-autocomplete-item" );
3004                  if ( false !== this._trigger( "focus", event, { item: item } ) ) {
3005                      // use value to match what will end up in the input, if it was a key event
3006                      if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
3007                          this._value( item.value );
3008                      }
3009                  }
3010  
3011                  // Announce the value in the liveRegion
3012                  label = ui.item.attr( "aria-label" ) || item.value;
3013                  if ( label && $.trim( label ).length ) {
3014                      this.liveRegion.children().hide();
3015                      $( "<div>" ).text( label ).appendTo( this.liveRegion );
3016                  }
3017              },
3018              menuselect: function( event, ui ) {
3019                  var item = ui.item.data( "ui-autocomplete-item" ),
3020                      previous = this.previous;
3021  
3022                  // only trigger when focus was lost (click on menu)
3023                  if ( this.element[ 0 ] !== this.document[ 0 ].activeElement ) {
3024                      this.element.focus();
3025                      this.previous = previous;
3026                      // #6109 - IE triggers two focus events and the second
3027                      // is asynchronous, so we need to reset the previous
3028                      // term synchronously and asynchronously :-(
3029                      this._delay(function() {
3030                          this.previous = previous;
3031                          this.selectedItem = item;
3032                      });
3033                  }
3034  
3035                  if ( false !== this._trigger( "select", event, { item: item } ) ) {
3036                      this._value( item.value );
3037                  }
3038                  // reset the term after the select event
3039                  // this allows custom select handling to work properly
3040                  this.term = this._value();
3041  
3042                  this.close( event );
3043                  this.selectedItem = item;
3044              }
3045          });
3046  
3047          this.liveRegion = $( "<span>", {
3048                  role: "status",
3049                  "aria-live": "assertive",
3050                  "aria-relevant": "additions"
3051              })
3052              .addClass( "ui-helper-hidden-accessible" )
3053              .appendTo( this.document[ 0 ].body );
3054  
3055          // turning off autocomplete prevents the browser from remembering the
3056          // value when navigating through history, so we re-enable autocomplete
3057          // if the page is unloaded before the widget is destroyed. #7790
3058          this._on( this.window, {
3059              beforeunload: function() {
3060                  this.element.removeAttr( "autocomplete" );
3061              }
3062          });
3063      },
3064  
3065      _destroy: function() {
3066          clearTimeout( this.searching );
3067          this.element
3068              .removeClass( "ui-autocomplete-input" )
3069              .removeAttr( "autocomplete" );
3070          this.menu.element.remove();
3071          this.liveRegion.remove();
3072      },
3073  
3074      _setOption: function( key, value ) {
3075          this._super( key, value );
3076          if ( key === "source" ) {
3077              this._initSource();
3078          }
3079          if ( key === "appendTo" ) {
3080              this.menu.element.appendTo( this._appendTo() );
3081          }
3082          if ( key === "disabled" && value && this.xhr ) {
3083              this.xhr.abort();
3084          }
3085      },
3086  
3087      _appendTo: function() {
3088          var element = this.options.appendTo;
3089  
3090          if ( element ) {
3091              element = element.jquery || element.nodeType ?
3092                  $( element ) :
3093                  this.document.find( element ).eq( 0 );
3094          }
3095  
3096          if ( !element || !element[ 0 ] ) {
3097              element = this.element.closest( ".ui-front" );
3098          }
3099  
3100          if ( !element.length ) {
3101              element = this.document[ 0 ].body;
3102          }
3103  
3104          return element;
3105      },
3106  
3107      _initSource: function() {
3108          var array, url,
3109              that = this;
3110          if ( $.isArray( this.options.source ) ) {
3111              array = this.options.source;
3112              this.source = function( request, response ) {
3113                  response( $.ui.autocomplete.filter( array, request.term ) );
3114              };
3115          } else if ( typeof this.options.source === "string" ) {
3116              url = this.options.source;
3117              this.source = function( request, response ) {
3118                  if ( that.xhr ) {
3119                      that.xhr.abort();
3120                  }
3121                  that.xhr = $.ajax({
3122                      url: url,
3123                      data: request,
3124                      dataType: "json",
3125                      success: function( data ) {
3126                          response( data );
3127                      },
3128                      error: function() {
3129                          response([]);
3130                      }
3131                  });
3132              };
3133          } else {
3134              this.source = this.options.source;
3135          }
3136      },
3137  
3138      _searchTimeout: function( event ) {
3139          clearTimeout( this.searching );
3140          this.searching = this._delay(function() {
3141  
3142              // Search if the value has changed, or if the user retypes the same value (see #7434)
3143              var equalValues = this.term === this._value(),
3144                  menuVisible = this.menu.element.is( ":visible" ),
3145                  modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
3146  
3147              if ( !equalValues || ( equalValues && !menuVisible && !modifierKey ) ) {
3148                  this.selectedItem = null;
3149                  this.search( null, event );
3150              }
3151          }, this.options.delay );
3152      },
3153  
3154      search: function( value, event ) {
3155          value = value != null ? value : this._value();
3156  
3157          // always save the actual value, not the one passed as an argument
3158          this.term = this._value();
3159  
3160          if ( value.length < this.options.minLength ) {
3161              return this.close( event );
3162          }
3163  
3164          if ( this._trigger( "search", event ) === false ) {
3165              return;
3166          }
3167  
3168          return this._search( value );
3169      },
3170  
3171      _search: function( value ) {
3172          this.pending++;
3173          this.element.addClass( "ui-autocomplete-loading" );
3174          this.cancelSearch = false;
3175  
3176          this.source( { term: value }, this._response() );
3177      },
3178  
3179      _response: function() {
3180          var index = ++this.requestIndex;
3181  
3182          return $.proxy(function( content ) {
3183              if ( index === this.requestIndex ) {
3184                  this.__response( content );
3185              }
3186  
3187              this.pending--;
3188              if ( !this.pending ) {
3189                  this.element.removeClass( "ui-autocomplete-loading" );
3190              }
3191          }, this );
3192      },
3193  
3194      __response: function( content ) {
3195          if ( content ) {
3196              content = this._normalize( content );
3197          }
3198          this._trigger( "response", null, { content: content } );
3199          if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
3200              this._suggest( content );
3201              this._trigger( "open" );
3202          } else {
3203              // use ._close() instead of .close() so we don't cancel future searches
3204              this._close();
3205          }
3206      },
3207  
3208      close: function( event ) {
3209          this.cancelSearch = true;
3210          this._close( event );
3211      },
3212  
3213      _close: function( event ) {
3214          if ( this.menu.element.is( ":visible" ) ) {
3215              this.menu.element.hide();
3216              this.menu.blur();
3217              this.isNewMenu = true;
3218              this._trigger( "close", event );
3219          }
3220      },
3221  
3222      _change: function( event ) {
3223          if ( this.previous !== this._value() ) {
3224              this._trigger( "change", event, { item: this.selectedItem } );
3225          }
3226      },
3227  
3228      _normalize: function( items ) {
3229          // assume all items have the right format when the first item is complete
3230          if ( items.length && items[ 0 ].label && items[ 0 ].value ) {
3231              return items;
3232          }
3233          return $.map( items, function( item ) {
3234              if ( typeof item === "string" ) {
3235                  return {
3236                      label: item,
3237                      value: item
3238                  };
3239              }
3240              return $.extend( {}, item, {
3241                  label: item.label || item.value,
3242                  value: item.value || item.label
3243              });
3244          });
3245      },
3246  
3247      _suggest: function( items ) {
3248          var ul = this.menu.element.empty();
3249          this._renderMenu( ul, items );
3250          this.isNewMenu = true;
3251          this.menu.refresh();
3252  
3253          // size and position menu
3254          ul.show();
3255          this._resizeMenu();
3256          ul.position( $.extend({
3257              of: this.element
3258          }, this.options.position ) );
3259  
3260          if ( this.options.autoFocus ) {
3261              this.menu.next();
3262          }
3263      },
3264  
3265      _resizeMenu: function() {
3266          var ul = this.menu.element;
3267          ul.outerWidth( Math.max(
3268              // Firefox wraps long text (possibly a rounding bug)
3269              // so we add 1px to avoid the wrapping (#7513)
3270              ul.width( "" ).outerWidth() + 1,
3271              this.element.outerWidth()
3272          ) );
3273      },
3274  
3275      _renderMenu: function( ul, items ) {
3276          var that = this;
3277          $.each( items, function( index, item ) {
3278              that._renderItemData( ul, item );
3279          });
3280      },
3281  
3282      _renderItemData: function( ul, item ) {
3283          return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
3284      },
3285  
3286      _renderItem: function( ul, item ) {
3287          return $( "<li>" ).text( item.label ).appendTo( ul );
3288      },
3289  
3290      _move: function( direction, event ) {
3291          if ( !this.menu.element.is( ":visible" ) ) {
3292              this.search( null, event );
3293              return;
3294          }
3295          if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
3296                  this.menu.isLastItem() && /^next/.test( direction ) ) {
3297  
3298              if ( !this.isMultiLine ) {
3299                  this._value( this.term );
3300              }
3301  
3302              this.menu.blur();
3303              return;
3304          }
3305          this.menu[ direction ]( event );
3306      },
3307  
3308      widget: function() {
3309          return this.menu.element;
3310      },
3311  
3312      _value: function() {
3313          return this.valueMethod.apply( this.element, arguments );
3314      },
3315  
3316      _keyEvent: function( keyEvent, event ) {
3317          if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
3318              this._move( keyEvent, event );
3319  
3320              // prevents moving cursor to beginning/end of the text field in some browsers
3321              event.preventDefault();
3322          }
3323      }
3324  });
3325  
3326  $.extend( $.ui.autocomplete, {
3327      escapeRegex: function( value ) {
3328          return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
3329      },
3330      filter: function( array, term ) {
3331          var matcher = new RegExp( $.ui.autocomplete.escapeRegex( term ), "i" );
3332          return $.grep( array, function( value ) {
3333              return matcher.test( value.label || value.value || value );
3334          });
3335      }
3336  });
3337  
3338  // live region extension, adding a `messages` option
3339  // NOTE: This is an experimental API. We are still investigating
3340  // a full solution for string manipulation and internationalization.
3341  $.widget( "ui.autocomplete", $.ui.autocomplete, {
3342      options: {
3343          messages: {
3344              noResults: "No search results.",
3345              results: function( amount ) {
3346                  return amount + ( amount > 1 ? " results are" : " result is" ) +
3347                      " available, use up and down arrow keys to navigate.";
3348              }
3349          }
3350      },
3351  
3352      __response: function( content ) {
3353          var message;
3354          this._superApply( arguments );
3355          if ( this.options.disabled || this.cancelSearch ) {
3356              return;
3357          }
3358          if ( content && content.length ) {
3359              message = this.options.messages.results( content.length );
3360          } else {
3361              message = this.options.messages.noResults;
3362          }
3363          this.liveRegion.children().hide();
3364          $( "<div>" ).text( message ).appendTo( this.liveRegion );
3365      }
3366  });
3367  
3368  var autocomplete = $.ui.autocomplete;
3369  
3370  
3371  /*!
3372   * jQuery UI Button 1.11.4
3373   * http://jqueryui.com
3374   *
3375   * Copyright jQuery Foundation and other contributors
3376   * Released under the MIT license.
3377   * http://jquery.org/license
3378   *
3379   * http://api.jqueryui.com/button/
3380   */
3381  
3382  
3383  var lastActive,
3384      baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
3385      typeClasses = "ui-button-icons-only ui-button-icon-only ui-button-text-icons ui-button-text-icon-primary ui-button-text-icon-secondary ui-button-text-only",
3386      formResetHandler = function() {
3387          var form = $( this );
3388          setTimeout(function() {
3389              form.find( ":ui-button" ).button( "refresh" );
3390          }, 1 );
3391      },
3392      radioGroup = function( radio ) {
3393          var name = radio.name,
3394              form = radio.form,
3395              radios = $( [] );
3396          if ( name ) {
3397              name = name.replace( /'/g, "\\'" );
3398              if ( form ) {
3399                  radios = $( form ).find( "[name='" + name + "'][type=radio]" );
3400              } else {
3401                  radios = $( "[name='" + name + "'][type=radio]", radio.ownerDocument )
3402                      .filter(function() {
3403                          return !this.form;
3404                      });
3405              }
3406          }
3407          return radios;
3408      };
3409  
3410  $.widget( "ui.button", {
3411      version: "1.11.4",
3412      defaultElement: "<button>",
3413      options: {
3414          disabled: null,
3415          text: true,
3416          label: null,
3417          icons: {
3418              primary: null,
3419              secondary: null
3420          }
3421      },
3422      _create: function() {
3423          this.element.closest( "form" )
3424              .unbind( "reset" + this.eventNamespace )
3425              .bind( "reset" + this.eventNamespace, formResetHandler );
3426  
3427          if ( typeof this.options.disabled !== "boolean" ) {
3428              this.options.disabled = !!this.element.prop( "disabled" );
3429          } else {
3430              this.element.prop( "disabled", this.options.disabled );
3431          }
3432  
3433          this._determineButtonType();
3434          this.hasTitle = !!this.buttonElement.attr( "title" );
3435  
3436          var that = this,
3437              options = this.options,
3438              toggleButton = this.type === "checkbox" || this.type === "radio",
3439              activeClass = !toggleButton ? "ui-state-active" : "";
3440  
3441          if ( options.label === null ) {
3442              options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
3443          }
3444  
3445          this._hoverable( this.buttonElement );
3446  
3447          this.buttonElement
3448              .addClass( baseClasses )
3449              .attr( "role", "button" )
3450              .bind( "mouseenter" + this.eventNamespace, function() {
3451                  if ( options.disabled ) {
3452                      return;
3453                  }
3454                  if ( this === lastActive ) {
3455                      $( this ).addClass( "ui-state-active" );
3456                  }
3457              })
3458              .bind( "mouseleave" + this.eventNamespace, function() {
3459                  if ( options.disabled ) {
3460                      return;
3461                  }
3462                  $( this ).removeClass( activeClass );
3463              })
3464              .bind( "click" + this.eventNamespace, function( event ) {
3465                  if ( options.disabled ) {
3466                      event.preventDefault();
3467                      event.stopImmediatePropagation();
3468                  }
3469              });
3470  
3471          // Can't use _focusable() because the element that receives focus
3472          // and the element that gets the ui-state-focus class are different
3473          this._on({
3474              focus: function() {
3475                  this.buttonElement.addClass( "ui-state-focus" );
3476              },
3477              blur: function() {
3478                  this.buttonElement.removeClass( "ui-state-focus" );
3479              }
3480          });
3481  
3482          if ( toggleButton ) {
3483              this.element.bind( "change" + this.eventNamespace, function() {
3484                  that.refresh();
3485              });
3486          }
3487  
3488          if ( this.type === "checkbox" ) {
3489              this.buttonElement.bind( "click" + this.eventNamespace, function() {
3490                  if ( options.disabled ) {
3491                      return false;
3492                  }
3493              });
3494          } else if ( this.type === "radio" ) {
3495              this.buttonElement.bind( "click" + this.eventNamespace, function() {
3496                  if ( options.disabled ) {
3497                      return false;
3498                  }
3499                  $( this ).addClass( "ui-state-active" );
3500                  that.buttonElement.attr( "aria-pressed", "true" );
3501  
3502                  var radio = that.element[ 0 ];
3503                  radioGroup( radio )
3504                      .not( radio )
3505                      .map(function() {
3506                          return $( this ).button( "widget" )[ 0 ];
3507                      })
3508                      .removeClass( "ui-state-active" )
3509                      .attr( "aria-pressed", "false" );
3510              });
3511          } else {
3512              this.buttonElement
3513                  .bind( "mousedown" + this.eventNamespace, function() {
3514                      if ( options.disabled ) {
3515                          return false;
3516                      }
3517                      $( this ).addClass( "ui-state-active" );
3518                      lastActive = this;
3519                      that.document.one( "mouseup", function() {
3520                          lastActive = null;
3521                      });
3522                  })
3523                  .bind( "mouseup" + this.eventNamespace, function() {
3524                      if ( options.disabled ) {
3525                          return false;
3526                      }
3527                      $( this ).removeClass( "ui-state-active" );
3528                  })
3529                  .bind( "keydown" + this.eventNamespace, function(event) {
3530                      if ( options.disabled ) {
3531                          return false;
3532                      }
3533                      if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
3534                          $( this ).addClass( "ui-state-active" );
3535                      }
3536                  })
3537                  // see #8559, we bind to blur here in case the button element loses
3538                  // focus between keydown and keyup, it would be left in an "active" state
3539                  .bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() {
3540                      $( this ).removeClass( "ui-state-active" );
3541                  });
3542  
3543              if ( this.buttonElement.is("a") ) {
3544                  this.buttonElement.keyup(function(event) {
3545                      if ( event.keyCode === $.ui.keyCode.SPACE ) {
3546                          // TODO pass through original event correctly (just as 2nd argument doesn't work)
3547                          $( this ).click();
3548                      }
3549                  });
3550              }
3551          }
3552  
3553          this._setOption( "disabled", options.disabled );
3554          this._resetButton();
3555      },
3556  
3557      _determineButtonType: function() {
3558          var ancestor, labelSelector, checked;
3559  
3560          if ( this.element.is("[type=checkbox]") ) {
3561              this.type = "checkbox";
3562          } else if ( this.element.is("[type=radio]") ) {
3563              this.type = "radio";
3564          } else if ( this.element.is("input") ) {
3565              this.type = "input";
3566          } else {
3567              this.type = "button";
3568          }
3569  
3570          if ( this.type === "checkbox" || this.type === "radio" ) {
3571              // we don't search against the document in case the element
3572              // is disconnected from the DOM
3573              ancestor = this.element.parents().last();
3574              labelSelector = "label[for='" + this.element.attr("id") + "']";
3575              this.buttonElement = ancestor.find( labelSelector );
3576              if ( !this.buttonElement.length ) {
3577                  ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
3578                  this.buttonElement = ancestor.filter( labelSelector );
3579                  if ( !this.buttonElement.length ) {
3580                      this.buttonElement = ancestor.find( labelSelector );
3581                  }
3582              }
3583              this.element.addClass( "ui-helper-hidden-accessible" );
3584  
3585              checked = this.element.is( ":checked" );
3586              if ( checked ) {
3587                  this.buttonElement.addClass( "ui-state-active" );
3588              }
3589              this.buttonElement.prop( "aria-pressed", checked );
3590          } else {
3591              this.buttonElement = this.element;
3592          }
3593      },
3594  
3595      widget: function() {
3596          return this.buttonElement;
3597      },
3598  
3599      _destroy: function() {
3600          this.element
3601              .removeClass( "ui-helper-hidden-accessible" );
3602          this.buttonElement
3603              .removeClass( baseClasses + " ui-state-active " + typeClasses )
3604              .removeAttr( "role" )
3605              .removeAttr( "aria-pressed" )
3606              .html( this.buttonElement.find(".ui-button-text").html() );
3607  
3608          if ( !this.hasTitle ) {
3609              this.buttonElement.removeAttr( "title" );
3610          }
3611      },
3612  
3613      _setOption: function( key, value ) {
3614          this._super( key, value );
3615          if ( key === "disabled" ) {
3616              this.widget().toggleClass( "ui-state-disabled", !!value );
3617              this.element.prop( "disabled", !!value );
3618              if ( value ) {
3619                  if ( this.type === "checkbox" || this.type === "radio" ) {
3620                      this.buttonElement.removeClass( "ui-state-focus" );
3621                  } else {
3622                      this.buttonElement.removeClass( "ui-state-focus ui-state-active" );
3623                  }
3624              }
3625              return;
3626          }
3627          this._resetButton();
3628      },
3629  
3630      refresh: function() {
3631          //See #8237 & #8828
3632          var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
3633  
3634          if ( isDisabled !== this.options.disabled ) {
3635              this._setOption( "disabled", isDisabled );
3636          }
3637          if ( this.type === "radio" ) {
3638              radioGroup( this.element[0] ).each(function() {
3639                  if ( $( this ).is( ":checked" ) ) {
3640                      $( this ).button( "widget" )
3641                          .addClass( "ui-state-active" )
3642                          .attr( "aria-pressed", "true" );
3643                  } else {
3644                      $( this ).button( "widget" )
3645                          .removeClass( "ui-state-active" )
3646                          .attr( "aria-pressed", "false" );
3647                  }
3648              });
3649          } else if ( this.type === "checkbox" ) {
3650              if ( this.element.is( ":checked" ) ) {
3651                  this.buttonElement
3652                      .addClass( "ui-state-active" )
3653                      .attr( "aria-pressed", "true" );
3654              } else {
3655                  this.buttonElement
3656                      .removeClass( "ui-state-active" )
3657                      .attr( "aria-pressed", "false" );
3658              }
3659          }
3660      },
3661  
3662      _resetButton: function() {
3663          if ( this.type === "input" ) {
3664              if ( this.options.label ) {
3665                  this.element.val( this.options.label );
3666              }
3667              return;
3668          }
3669          var buttonElement = this.buttonElement.removeClass( typeClasses ),
3670              buttonText = $( "<span></span>", this.document[0] )
3671                  .addClass( "ui-button-text" )
3672                  .html( this.options.label )
3673                  .appendTo( buttonElement.empty() )
3674                  .text(),
3675              icons = this.options.icons,
3676              multipleIcons = icons.primary && icons.secondary,
3677              buttonClasses = [];
3678  
3679          if ( icons.primary || icons.secondary ) {
3680              if ( this.options.text ) {
3681                  buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
3682              }
3683  
3684              if ( icons.primary ) {
3685                  buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
3686              }
3687  
3688              if ( icons.secondary ) {
3689                  buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
3690              }
3691  
3692              if ( !this.options.text ) {
3693                  buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" );
3694  
3695                  if ( !this.hasTitle ) {
3696                      buttonElement.attr( "title", $.trim( buttonText ) );
3697                  }
3698              }
3699          } else {
3700              buttonClasses.push( "ui-button-text-only" );
3701          }
3702          buttonElement.addClass( buttonClasses.join( " " ) );
3703      }
3704  });
3705  
3706  $.widget( "ui.buttonset", {
3707      version: "1.11.4",
3708      options: {
3709          items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)"
3710      },
3711  
3712      _create: function() {
3713          this.element.addClass( "ui-buttonset" );
3714      },
3715  
3716      _init: function() {
3717          this.refresh();
3718      },
3719  
3720      _setOption: function( key, value ) {
3721          if ( key === "disabled" ) {
3722              this.buttons.button( "option", key, value );
3723          }
3724  
3725          this._super( key, value );
3726      },
3727  
3728      refresh: function() {
3729          var rtl = this.element.css( "direction" ) === "rtl",
3730              allButtons = this.element.find( this.options.items ),
3731              existingButtons = allButtons.filter( ":ui-button" );
3732  
3733          // Initialize new buttons
3734          allButtons.not( ":ui-button" ).button();
3735  
3736          // Refresh existing buttons
3737          existingButtons.button( "refresh" );
3738  
3739          this.buttons = allButtons
3740              .map(function() {
3741                  return $( this ).button( "widget" )[ 0 ];
3742              })
3743                  .removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
3744                  .filter( ":first" )
3745                      .addClass( rtl ? "ui-corner-right" : "ui-corner-left" )
3746                  .end()
3747                  .filter( ":last" )
3748                      .addClass( rtl ? "ui-corner-left" : "ui-corner-right" )
3749                  .end()
3750              .end();
3751      },
3752  
3753      _destroy: function() {
3754          this.element.removeClass( "ui-buttonset" );
3755          this.buttons
3756              .map(function() {
3757                  return $( this ).button( "widget" )[ 0 ];
3758              })
3759                  .removeClass( "ui-corner-left ui-corner-right" )
3760              .end()
3761              .button( "destroy" );
3762      }
3763  });
3764  
3765  var button = $.ui.button;
3766  
3767  
3768  /*!
3769   * jQuery UI Datepicker 1.11.4
3770   * http://jqueryui.com
3771   *
3772   * Copyright jQuery Foundation and other contributors
3773   * Released under the MIT license.
3774   * http://jquery.org/license
3775   *
3776   * http://api.jqueryui.com/datepicker/
3777   */
3778  
3779  
3780  $.extend($.ui, { datepicker: { version: "1.11.4" } });
3781  
3782  var datepicker_instActive;
3783  
3784  function datepicker_getZindex( elem ) {
3785      var position, value;
3786      while ( elem.length && elem[ 0 ] !== document ) {
3787          // Ignore z-index if position is set to a value where z-index is ignored by the browser
3788          // This makes behavior of this function consistent across browsers
3789          // WebKit always returns auto if the element is positioned
3790          position = elem.css( "position" );
3791          if ( position === "absolute" || position === "relative" || position === "fixed" ) {
3792              // IE returns 0 when zIndex is not specified
3793              // other browsers return a string
3794              // we ignore the case of nested elements with an explicit value of 0
3795              // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
3796              value = parseInt( elem.css( "zIndex" ), 10 );
3797              if ( !isNaN( value ) && value !== 0 ) {
3798                  return value;
3799              }
3800          }
3801          elem = elem.parent();
3802      }
3803  
3804      return 0;
3805  }
3806  /* Date picker manager.
3807     Use the singleton instance of this class, $.datepicker, to interact with the date picker.
3808     Settings for (groups of) date pickers are maintained in an instance object,
3809     allowing multiple different settings on the same page. */
3810  
3811  function Datepicker() {
3812      this._curInst = null; // The current instance in use
3813      this._keyEvent = false; // If the last event was a key event
3814      this._disabledInputs = []; // List of date picker inputs that have been disabled
3815      this._datepickerShowing = false; // True if the popup picker is showing , false if not
3816      this._inDialog = false; // True if showing within a "dialog", false if not
3817      this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
3818      this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
3819      this._appendClass = "ui-datepicker-append"; // The name of the append marker class
3820      this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
3821      this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
3822      this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
3823      this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
3824      this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
3825      this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
3826      this.regional = []; // Available regional settings, indexed by language code
3827      this.regional[""] = { // Default regional settings
3828          closeText: "Done", // Display text for close link
3829          prevText: "Prev", // Display text for previous month link
3830          nextText: "Next", // Display text for next month link
3831          currentText: "Today", // Display text for current month link
3832          monthNames: ["January","February","March","April","May","June",
3833              "July","August","September","October","November","December"], // Names of months for drop-down and formatting
3834          monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
3835          dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
3836          dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting
3837          dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday
3838          weekHeader: "Wk", // Column header for week of the year
3839          dateFormat: "mm/dd/yy", // See format options on parseDate
3840          firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
3841          isRTL: false, // True if right-to-left language, false if left-to-right
3842          showMonthAfterYear: false, // True if the year select precedes month, false for month then year
3843          yearSuffix: "" // Additional text to append to the year in the month headers
3844      };
3845      this._defaults = { // Global defaults for all the date picker instances
3846          showOn: "focus", // "focus" for popup on focus,
3847              // "button" for trigger button, or "both" for either
3848          showAnim: "fadeIn", // Name of jQuery animation for popup
3849          showOptions: {}, // Options for enhanced animations
3850          defaultDate: null, // Used when field is blank: actual date,
3851              // +/-number for offset from today, null for today
3852          appendText: "", // Display text following the input box, e.g. showing the format
3853          buttonText: "...", // Text for trigger button
3854          buttonImage: "", // URL for trigger button image
3855          buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
3856          hideIfNoPrevNext: false, // True to hide next/previous month links
3857              // if not applicable, false to just disable them
3858          navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
3859          gotoCurrent: false, // True if today link goes back to current selection instead
3860          changeMonth: false, // True if month can be selected directly, false if only prev/next
3861          changeYear: false, // True if year can be selected directly, false if only prev/next
3862          yearRange: "c-10:c+10", // Range of years to display in drop-down,
3863              // either relative to today's year (-nn:+nn), relative to currently displayed year
3864              // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
3865          showOtherMonths: false, // True to show dates in other months, false to leave blank
3866          selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
3867          showWeek: false, // True to show week of the year, false to not show it
3868          calculateWeek: this.iso8601Week, // How to calculate the week of the year,
3869              // takes a Date and returns the number of the week for it
3870          shortYearCutoff: "+10", // Short year values < this are in the current century,
3871              // > this are in the previous century,
3872              // string value starting with "+" for current year + value
3873          minDate: null, // The earliest selectable date, or null for no limit
3874          maxDate: null, // The latest selectable date, or null for no limit
3875          duration: "fast", // Duration of display/closure
3876          beforeShowDay: null, // Function that takes a date and returns an array with
3877              // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
3878              // [2] = cell title (optional), e.g. $.datepicker.noWeekends
3879          beforeShow: null, // Function that takes an input field and
3880              // returns a set of custom settings for the date picker
3881          onSelect: null, // Define a callback function when a date is selected
3882          onChangeMonthYear: null, // Define a callback function when the month or year is changed
3883          onClose: null, // Define a callback function when the datepicker is closed
3884          numberOfMonths: 1, // Number of months to show at a time
3885          showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
3886          stepMonths: 1, // Number of months to step back/forward
3887          stepBigMonths: 12, // Number of months to step back/forward for the big links
3888          altField: "", // Selector for an alternate field to store selected dates into
3889          altFormat: "", // The date format to use for the alternate field
3890          constrainInput: true, // The input is constrained by the current date format
3891          showButtonPanel: false, // True to show button panel, false to not show it
3892          autoSize: false, // True to size the input for the date format, false to leave as is
3893          disabled: false // The initial disabled state
3894      };
3895      $.extend(this._defaults, this.regional[""]);
3896      this.regional.en = $.extend( true, {}, this.regional[ "" ]);
3897      this.regional[ "en-US" ] = $.extend( true, {}, this.regional.en );
3898      this.dpDiv = datepicker_bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>"));
3899  }
3900  
3901  $.extend(Datepicker.prototype, {
3902      /* Class name added to elements to indicate already configured with a date picker. */
3903      markerClassName: "hasDatepicker",
3904  
3905      //Keep track of the maximum number of rows displayed (see #7043)
3906      maxRows: 4,
3907  
3908      // TODO rename to "widget" when switching to widget factory
3909      _widgetDatepicker: function() {
3910          return this.dpDiv;
3911      },
3912  
3913      /* Override the default settings for all instances of the date picker.
3914       * @param  settings  object - the new settings to use as defaults (anonymous object)
3915       * @return the manager object
3916       */
3917      setDefaults: function(settings) {
3918          datepicker_extendRemove(this._defaults, settings || {});
3919          return this;
3920      },
3921  
3922      /* Attach the date picker to a jQuery selection.
3923       * @param  target    element - the target input field or division or span
3924       * @param  settings  object - the new settings to use for this date picker instance (anonymous)
3925       */
3926      _attachDatepicker: function(target, settings) {
3927          var nodeName, inline, inst;
3928          nodeName = target.nodeName.toLowerCase();
3929          inline = (nodeName === "div" || nodeName === "span");
3930          if (!target.id) {
3931              this.uuid += 1;
3932              target.id = "dp" + this.uuid;
3933          }
3934          inst = this._newInst($(target), inline);
3935          inst.settings = $.extend({}, settings || {});
3936          if (nodeName === "input") {
3937              this._connectDatepicker(target, inst);
3938          } else if (inline) {
3939              this._inlineDatepicker(target, inst);
3940          }
3941      },
3942  
3943      /* Create a new instance object. */
3944      _newInst: function(target, inline) {
3945          var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars
3946          return {id: id, input: target, // associated target
3947              selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
3948              drawMonth: 0, drawYear: 0, // month being drawn
3949              inline: inline, // is datepicker inline or not
3950              dpDiv: (!inline ? this.dpDiv : // presentation div
3951              datepicker_bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))};
3952      },
3953  
3954      /* Attach the date picker to an input field. */
3955      _connectDatepicker: function(target, inst) {
3956          var input = $(target);
3957          inst.append = $([]);
3958          inst.trigger = $([]);
3959          if (input.hasClass(this.markerClassName)) {
3960              return;
3961          }
3962          this._attachments(input, inst);
3963          input.addClass(this.markerClassName).keydown(this._doKeyDown).
3964              keypress(this._doKeyPress).keyup(this._doKeyUp);
3965          this._autoSize(inst);
3966          $.data(target, "datepicker", inst);
3967          //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
3968          if( inst.settings.disabled ) {
3969              this._disableDatepicker( target );
3970          }
3971      },
3972  
3973      /* Make attachments based on settings. */
3974      _attachments: function(input, inst) {
3975          var showOn, buttonText, buttonImage,
3976              appendText = this._get(inst, "appendText"),
3977              isRTL = this._get(inst, "isRTL");
3978  
3979          if (inst.append) {
3980              inst.append.remove();
3981          }
3982          if (appendText) {
3983              inst.append = $("<span class='" + this._appendClass + "'>" + appendText + "</span>");
3984              input[isRTL ? "before" : "after"](inst.append);
3985          }
3986  
3987          input.unbind("focus", this._showDatepicker);
3988  
3989          if (inst.trigger) {
3990              inst.trigger.remove();
3991          }
3992  
3993          showOn = this._get(inst, "showOn");
3994          if (showOn === "focus" || showOn === "both") { // pop-up date picker when in the marked field
3995              input.focus(this._showDatepicker);
3996          }
3997          if (showOn === "button" || showOn === "both") { // pop-up date picker when button clicked
3998              buttonText = this._get(inst, "buttonText");
3999              buttonImage = this._get(inst, "buttonImage");
4000              inst.trigger = $(this._get(inst, "buttonImageOnly") ?
4001                  $("<img/>").addClass(this._triggerClass).
4002                      attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
4003                  $("<button type='button'></button>").addClass(this._triggerClass).
4004                      html(!buttonImage ? buttonText : $("<img/>").attr(
4005                      { src:buttonImage, alt:buttonText, title:buttonText })));
4006              input[isRTL ? "before" : "after"](inst.trigger);
4007              inst.trigger.click(function() {
4008                  if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) {
4009                      $.datepicker._hideDatepicker();
4010                  } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) {
4011                      $.datepicker._hideDatepicker();
4012                      $.datepicker._showDatepicker(input[0]);
4013                  } else {
4014                      $.datepicker._showDatepicker(input[0]);
4015                  }
4016                  return false;
4017              });
4018          }
4019      },
4020  
4021      /* Apply the maximum length for the date format. */
4022      _autoSize: function(inst) {
4023          if (this._get(inst, "autoSize") && !inst.inline) {
4024              var findMax, max, maxI, i,
4025                  date = new Date(2009, 12 - 1, 20), // Ensure double digits
4026                  dateFormat = this._get(inst, "dateFormat");
4027  
4028              if (dateFormat.match(/[DM]/)) {
4029                  findMax = function(names) {
4030                      max = 0;
4031                      maxI = 0;
4032                      for (i = 0; i < names.length; i++) {
4033                          if (names[i].length > max) {
4034                              max = names[i].length;
4035                              maxI = i;
4036                          }
4037                      }
4038                      return maxI;
4039                  };
4040                  date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
4041                      "monthNames" : "monthNamesShort"))));
4042                  date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
4043                      "dayNames" : "dayNamesShort"))) + 20 - date.getDay());
4044              }
4045              inst.input.attr("size", this._formatDate(inst, date).length);
4046          }
4047      },
4048  
4049      /* Attach an inline date picker to a div. */
4050      _inlineDatepicker: function(target, inst) {
4051          var divSpan = $(target);
4052          if (divSpan.hasClass(this.markerClassName)) {
4053              return;
4054          }
4055          divSpan.addClass(this.markerClassName).append(inst.dpDiv);
4056          $.data(target, "datepicker", inst);
4057          this._setDate(inst, this._getDefaultDate(inst), true);
4058          this._updateDatepicker(inst);
4059          this._updateAlternate(inst);
4060          //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
4061          if( inst.settings.disabled ) {
4062              this._disableDatepicker( target );
4063          }
4064          // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
4065          // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
4066          inst.dpDiv.css( "display", "block" );
4067      },
4068  
4069      /* Pop-up the date picker in a "dialog" box.
4070       * @param  input element - ignored
4071       * @param  date    string or Date - the initial date to display
4072       * @param  onSelect  function - the function to call when a date is selected
4073       * @param  settings  object - update the dialog date picker instance's settings (anonymous object)
4074       * @param  pos int[2] - coordinates for the dialog's position within the screen or
4075       *                    event - with x/y coordinates or
4076       *                    leave empty for default (screen centre)
4077       * @return the manager object
4078       */
4079      _dialogDatepicker: function(input, date, onSelect, settings, pos) {
4080          var id, browserWidth, browserHeight, scrollX, scrollY,
4081              inst = this._dialogInst; // internal instance
4082  
4083          if (!inst) {
4084              this.uuid += 1;
4085              id = "dp" + this.uuid;
4086              this._dialogInput = $("<input type='text' id='" + id +
4087                  "' style='position: absolute; top: -100px; width: 0px;'/>");
4088              this._dialogInput.keydown(this._doKeyDown);
4089              $("body").append(this._dialogInput);
4090              inst = this._dialogInst = this._newInst(this._dialogInput, false);
4091              inst.settings = {};
4092              $.data(this._dialogInput[0], "datepicker", inst);
4093          }
4094          datepicker_extendRemove(inst.settings, settings || {});
4095          date = (date && date.constructor === Date ? this._formatDate(inst, date) : date);
4096          this._dialogInput.val(date);
4097  
4098          this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
4099          if (!this._pos) {
4100              browserWidth = document.documentElement.clientWidth;
4101              browserHeight = document.documentElement.clientHeight;
4102              scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
4103              scrollY = document.documentElement.scrollTop || document.body.scrollTop;
4104              this._pos = // should use actual width/height below
4105                  [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
4106          }
4107  
4108          // move input on screen for focus, but hidden behind dialog
4109          this._dialogInput.css("left", (this._pos[0] + 20) + "px").css("top", this._pos[1] + "px");
4110          inst.settings.onSelect = onSelect;
4111          this._inDialog = true;
4112          this.dpDiv.addClass(this._dialogClass);
4113          this._showDatepicker(this._dialogInput[0]);
4114          if ($.blockUI) {
4115              $.blockUI(this.dpDiv);
4116          }
4117          $.data(this._dialogInput[0], "datepicker", inst);
4118          return this;
4119      },
4120  
4121      /* Detach a datepicker from its control.
4122       * @param  target    element - the target input field or division or span
4123       */
4124      _destroyDatepicker: function(target) {
4125          var nodeName,
4126              $target = $(target),
4127              inst = $.data(target, "datepicker");
4128  
4129          if (!$target.hasClass(this.markerClassName)) {
4130              return;
4131          }
4132  
4133          nodeName = target.nodeName.toLowerCase();
4134          $.removeData(target, "datepicker");
4135          if (nodeName === "input") {
4136              inst.append.remove();
4137              inst.trigger.remove();
4138              $target.removeClass(this.markerClassName).
4139                  unbind("focus", this._showDatepicker).
4140                  unbind("keydown", this._doKeyDown).
4141                  unbind("keypress", this._doKeyPress).
4142                  unbind("keyup", this._doKeyUp);
4143          } else if (nodeName === "div" || nodeName === "span") {
4144              $target.removeClass(this.markerClassName).empty();
4145          }
4146  
4147          if ( datepicker_instActive === inst ) {
4148              datepicker_instActive = null;
4149          }
4150      },
4151  
4152      /* Enable the date picker to a jQuery selection.
4153       * @param  target    element - the target input field or division or span
4154       */
4155      _enableDatepicker: function(target) {
4156          var nodeName, inline,
4157              $target = $(target),
4158              inst = $.data(target, "datepicker");
4159  
4160          if (!$target.hasClass(this.markerClassName)) {
4161              return;
4162          }
4163  
4164          nodeName = target.nodeName.toLowerCase();
4165          if (nodeName === "input") {
4166              target.disabled = false;
4167              inst.trigger.filter("button").
4168                  each(function() { this.disabled = false; }).end().
4169                  filter("img").css({opacity: "1.0", cursor: ""});
4170          } else if (nodeName === "div" || nodeName === "span") {
4171              inline = $target.children("." + this._inlineClass);
4172              inline.children().removeClass("ui-state-disabled");
4173              inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
4174                  prop("disabled", false);
4175          }
4176          this._disabledInputs = $.map(this._disabledInputs,
4177              function(value) { return (value === target ? null : value); }); // delete entry
4178      },
4179  
4180      /* Disable the date picker to a jQuery selection.
4181       * @param  target    element - the target input field or division or span
4182       */
4183      _disableDatepicker: function(target) {
4184          var nodeName, inline,
4185              $target = $(target),
4186              inst = $.data(target, "datepicker");
4187  
4188          if (!$target.hasClass(this.markerClassName)) {
4189              return;
4190          }
4191  
4192          nodeName = target.nodeName.toLowerCase();
4193          if (nodeName === "input") {
4194              target.disabled = true;
4195              inst.trigger.filter("button").
4196                  each(function() { this.disabled = true; }).end().
4197                  filter("img").css({opacity: "0.5", cursor: "default"});
4198          } else if (nodeName === "div" || nodeName === "span") {
4199              inline = $target.children("." + this._inlineClass);
4200              inline.children().addClass("ui-state-disabled");
4201              inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
4202                  prop("disabled", true);
4203          }
4204          this._disabledInputs = $.map(this._disabledInputs,
4205              function(value) { return (value === target ? null : value); }); // delete entry
4206          this._disabledInputs[this._disabledInputs.length] = target;
4207      },
4208  
4209      /* Is the first field in a jQuery collection disabled as a datepicker?
4210       * @param  target    element - the target input field or division or span
4211       * @return boolean - true if disabled, false if enabled
4212       */
4213      _isDisabledDatepicker: function(target) {
4214          if (!target) {
4215              return false;
4216          }
4217          for (var i = 0; i < this._disabledInputs.length; i++) {
4218              if (this._disabledInputs[i] === target) {
4219                  return true;
4220              }
4221          }
4222          return false;
4223      },
4224  
4225      /* Retrieve the instance data for the target control.
4226       * @param  target  element - the target input field or division or span
4227       * @return  object - the associated instance data
4228       * @throws  error if a jQuery problem getting data
4229       */
4230      _getInst: function(target) {
4231          try {
4232              return $.data(target, "datepicker");
4233          }
4234          catch (err) {
4235              throw "Missing instance data for this datepicker";
4236          }
4237      },
4238  
4239      /* Update or retrieve the settings for a date picker attached to an input field or division.
4240       * @param  target  element - the target input field or division or span
4241       * @param  name    object - the new settings to update or
4242       *                string - the name of the setting to change or retrieve,
4243       *                when retrieving also "all" for all instance settings or
4244       *                "defaults" for all global defaults
4245       * @param  value   any - the new value for the setting
4246       *                (omit if above is an object or to retrieve a value)
4247       */
4248      _optionDatepicker: function(target, name, value) {
4249          var settings, date, minDate, maxDate,
4250              inst = this._getInst(target);
4251  
4252          if (arguments.length === 2 && typeof name === "string") {
4253              return (name === "defaults" ? $.extend({}, $.datepicker._defaults) :
4254                  (inst ? (name === "all" ? $.extend({}, inst.settings) :
4255                  this._get(inst, name)) : null));
4256          }
4257  
4258          settings = name || {};
4259          if (typeof name === "string") {
4260              settings = {};
4261              settings[name] = value;
4262          }
4263  
4264          if (inst) {
4265              if (this._curInst === inst) {
4266                  this._hideDatepicker();
4267              }
4268  
4269              date = this._getDateDatepicker(target, true);
4270              minDate = this._getMinMaxDate(inst, "min");
4271              maxDate = this._getMinMaxDate(inst, "max");
4272              datepicker_extendRemove(inst.settings, settings);
4273              // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
4274              if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) {
4275                  inst.settings.minDate = this._formatDate(inst, minDate);
4276              }
4277              if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) {
4278                  inst.settings.maxDate = this._formatDate(inst, maxDate);
4279              }
4280              if ( "disabled" in settings ) {
4281                  if ( settings.disabled ) {
4282                      this._disableDatepicker(target);
4283                  } else {
4284                      this._enableDatepicker(target);
4285                  }
4286              }
4287              this._attachments($(target), inst);
4288              this._autoSize(inst);
4289              this._setDate(inst, date);
4290              this._updateAlternate(inst);
4291              this._updateDatepicker(inst);
4292          }
4293      },
4294  
4295      // change method deprecated
4296      _changeDatepicker: function(target, name, value) {
4297          this._optionDatepicker(target, name, value);
4298      },
4299  
4300      /* Redraw the date picker attached to an input field or division.
4301       * @param  target  element - the target input field or division or span
4302       */
4303      _refreshDatepicker: function(target) {
4304          var inst = this._getInst(target);
4305          if (inst) {
4306              this._updateDatepicker(inst);
4307          }
4308      },
4309  
4310      /* Set the dates for a jQuery selection.
4311       * @param  target element - the target input field or division or span
4312       * @param  date    Date - the new date
4313       */
4314      _setDateDatepicker: function(target, date) {
4315          var inst = this._getInst(target);
4316          if (inst) {
4317              this._setDate(inst, date);
4318              this._updateDatepicker(inst);
4319              this._updateAlternate(inst);
4320          }
4321      },
4322  
4323      /* Get the date(s) for the first entry in a jQuery selection.
4324       * @param  target element - the target input field or division or span
4325       * @param  noDefault boolean - true if no default date is to be used
4326       * @return Date - the current date
4327       */
4328      _getDateDatepicker: function(target, noDefault) {
4329          var inst = this._getInst(target);
4330          if (inst && !inst.inline) {
4331              this._setDateFromField(inst, noDefault);
4332          }
4333          return (inst ? this._getDate(inst) : null);
4334      },
4335  
4336      /* Handle keystrokes. */
4337      _doKeyDown: function(event) {
4338          var onSelect, dateStr, sel,
4339              inst = $.datepicker._getInst(event.target),
4340              handled = true,
4341              isRTL = inst.dpDiv.is(".ui-datepicker-rtl");
4342  
4343          inst._keyEvent = true;
4344          if ($.datepicker._datepickerShowing) {
4345              switch (event.keyCode) {
4346                  case 9: $.datepicker._hideDatepicker();
4347                          handled = false;
4348                          break; // hide on tab out
4349                  case 13: sel = $("td." + $.datepicker._dayOverClass + ":not(." +
4350                                      $.datepicker._currentClass + ")", inst.dpDiv);
4351                          if (sel[0]) {
4352                              $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
4353                          }
4354  
4355                          onSelect = $.datepicker._get(inst, "onSelect");
4356                          if (onSelect) {
4357                              dateStr = $.datepicker._formatDate(inst);
4358  
4359                              // trigger custom callback
4360                              onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);
4361                          } else {
4362                              $.datepicker._hideDatepicker();
4363                          }
4364  
4365                          return false; // don't submit the form
4366                  case 27: $.datepicker._hideDatepicker();
4367                          break; // hide on escape
4368                  case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4369                              -$.datepicker._get(inst, "stepBigMonths") :
4370                              -$.datepicker._get(inst, "stepMonths")), "M");
4371                          break; // previous month/year on page up/+ ctrl
4372                  case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4373                              +$.datepicker._get(inst, "stepBigMonths") :
4374                              +$.datepicker._get(inst, "stepMonths")), "M");
4375                          break; // next month/year on page down/+ ctrl
4376                  case 35: if (event.ctrlKey || event.metaKey) {
4377                              $.datepicker._clearDate(event.target);
4378                          }
4379                          handled = event.ctrlKey || event.metaKey;
4380                          break; // clear on ctrl or command +end
4381                  case 36: if (event.ctrlKey || event.metaKey) {
4382                              $.datepicker._gotoToday(event.target);
4383                          }
4384                          handled = event.ctrlKey || event.metaKey;
4385                          break; // current on ctrl or command +home
4386                  case 37: if (event.ctrlKey || event.metaKey) {
4387                              $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), "D");
4388                          }
4389                          handled = event.ctrlKey || event.metaKey;
4390                          // -1 day on ctrl or command +left
4391                          if (event.originalEvent.altKey) {
4392                              $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4393                                  -$.datepicker._get(inst, "stepBigMonths") :
4394                                  -$.datepicker._get(inst, "stepMonths")), "M");
4395                          }
4396                          // next month/year on alt +left on Mac
4397                          break;
4398                  case 38: if (event.ctrlKey || event.metaKey) {
4399                              $.datepicker._adjustDate(event.target, -7, "D");
4400                          }
4401                          handled = event.ctrlKey || event.metaKey;
4402                          break; // -1 week on ctrl or command +up
4403                  case 39: if (event.ctrlKey || event.metaKey) {
4404                              $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), "D");
4405                          }
4406                          handled = event.ctrlKey || event.metaKey;
4407                          // +1 day on ctrl or command +right
4408                          if (event.originalEvent.altKey) {
4409                              $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4410                                  +$.datepicker._get(inst, "stepBigMonths") :
4411                                  +$.datepicker._get(inst, "stepMonths")), "M");
4412                          }
4413                          // next month/year on alt +right
4414                          break;
4415                  case 40: if (event.ctrlKey || event.metaKey) {
4416                              $.datepicker._adjustDate(event.target, +7, "D");
4417                          }
4418                          handled = event.ctrlKey || event.metaKey;
4419                          break; // +1 week on ctrl or command +down
4420                  default: handled = false;
4421              }
4422          } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home
4423              $.datepicker._showDatepicker(this);
4424          } else {
4425              handled = false;
4426          }
4427  
4428          if (handled) {
4429              event.preventDefault();
4430              event.stopPropagation();
4431          }
4432      },
4433  
4434      /* Filter entered characters - based on date format. */
4435      _doKeyPress: function(event) {
4436          var chars, chr,
4437              inst = $.datepicker._getInst(event.target);
4438  
4439          if ($.datepicker._get(inst, "constrainInput")) {
4440              chars = $.datepicker._possibleChars($.datepicker._get(inst, "dateFormat"));
4441              chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode);
4442              return event.ctrlKey || event.metaKey || (chr < " " || !chars || chars.indexOf(chr) > -1);
4443          }
4444      },
4445  
4446      /* Synchronise manual entry and field/alternate field. */
4447      _doKeyUp: function(event) {
4448          var date,
4449              inst = $.datepicker._getInst(event.target);
4450  
4451          if (inst.input.val() !== inst.lastVal) {
4452              try {
4453                  date = $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
4454                      (inst.input ? inst.input.val() : null),
4455                      $.datepicker._getFormatConfig(inst));
4456  
4457                  if (date) { // only if valid
4458                      $.datepicker._setDateFromField(inst);
4459                      $.datepicker._updateAlternate(inst);
4460                      $.datepicker._updateDatepicker(inst);
4461                  }
4462              }
4463              catch (err) {
4464              }
4465          }
4466          return true;
4467      },
4468  
4469      /* Pop-up the date picker for a given input field.
4470       * If false returned from beforeShow event handler do not show.
4471       * @param  input  element - the input field attached to the date picker or
4472       *                    event - if triggered by focus
4473       */
4474      _showDatepicker: function(input) {
4475          input = input.target || input;
4476          if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger
4477              input = $("input", input.parentNode)[0];
4478          }
4479  
4480          if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here
4481              return;
4482          }
4483  
4484          var inst, beforeShow, beforeShowSettings, isFixed,
4485              offset, showAnim, duration;
4486  
4487          inst = $.datepicker._getInst(input);
4488          if ($.datepicker._curInst && $.datepicker._curInst !== inst) {
4489              $.datepicker._curInst.dpDiv.stop(true, true);
4490              if ( inst && $.datepicker._datepickerShowing ) {
4491                  $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] );
4492              }
4493          }
4494  
4495          beforeShow = $.datepicker._get(inst, "beforeShow");
4496          beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {};
4497          if(beforeShowSettings === false){
4498              return;
4499          }
4500          datepicker_extendRemove(inst.settings, beforeShowSettings);
4501  
4502          inst.lastVal = null;
4503          $.datepicker._lastInput = input;
4504          $.datepicker._setDateFromField(inst);
4505  
4506          if ($.datepicker._inDialog) { // hide cursor
4507              input.value = "";
4508          }
4509          if (!$.datepicker._pos) { // position below input
4510              $.datepicker._pos = $.datepicker._findPos(input);
4511              $.datepicker._pos[1] += input.offsetHeight; // add the height
4512          }
4513  
4514          isFixed = false;
4515          $(input).parents().each(function() {
4516              isFixed |= $(this).css("position") === "fixed";
4517              return !isFixed;
4518          });
4519  
4520          offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
4521          $.datepicker._pos = null;
4522          //to avoid flashes on Firefox
4523          inst.dpDiv.empty();
4524          // determine sizing offscreen
4525          inst.dpDiv.css({position: "absolute", display: "block", top: "-1000px"});
4526          $.datepicker._updateDatepicker(inst);
4527          // fix width for dynamic number of date pickers
4528          // and adjust position before showing
4529          offset = $.datepicker._checkOffset(inst, offset, isFixed);
4530          inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
4531              "static" : (isFixed ? "fixed" : "absolute")), display: "none",
4532              left: offset.left + "px", top: offset.top + "px"});
4533  
4534          if (!inst.inline) {
4535              showAnim = $.datepicker._get(inst, "showAnim");
4536              duration = $.datepicker._get(inst, "duration");
4537              inst.dpDiv.css( "z-index", datepicker_getZindex( $( input ) ) + 1 );
4538              $.datepicker._datepickerShowing = true;
4539  
4540              if ( $.effects && $.effects.effect[ showAnim ] ) {
4541                  inst.dpDiv.show(showAnim, $.datepicker._get(inst, "showOptions"), duration);
4542              } else {
4543                  inst.dpDiv[showAnim || "show"](showAnim ? duration : null);
4544              }
4545  
4546              if ( $.datepicker._shouldFocusInput( inst ) ) {
4547                  inst.input.focus();
4548              }
4549  
4550              $.datepicker._curInst = inst;
4551          }
4552      },
4553  
4554      /* Generate the date picker content. */
4555      _updateDatepicker: function(inst) {
4556          this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
4557          datepicker_instActive = inst; // for delegate hover events
4558          inst.dpDiv.empty().append(this._generateHTML(inst));
4559          this._attachHandlers(inst);
4560  
4561          var origyearshtml,
4562              numMonths = this._getNumberOfMonths(inst),
4563              cols = numMonths[1],
4564              width = 17,
4565              activeCell = inst.dpDiv.find( "." + this._dayOverClass + " a" );
4566  
4567          if ( activeCell.length > 0 ) {
4568              datepicker_handleMouseover.apply( activeCell.get( 0 ) );
4569          }
4570  
4571          inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width("");
4572          if (cols > 1) {
4573              inst.dpDiv.addClass("ui-datepicker-multi-" + cols).css("width", (width * cols) + "em");
4574          }
4575          inst.dpDiv[(numMonths[0] !== 1 || numMonths[1] !== 1 ? "add" : "remove") +
4576              "Class"]("ui-datepicker-multi");
4577          inst.dpDiv[(this._get(inst, "isRTL") ? "add" : "remove") +
4578              "Class"]("ui-datepicker-rtl");
4579  
4580          if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
4581              inst.input.focus();
4582          }
4583  
4584          // deffered render of the years select (to avoid flashes on Firefox)
4585          if( inst.yearshtml ){
4586              origyearshtml = inst.yearshtml;
4587              setTimeout(function(){
4588                  //assure that inst.yearshtml didn't change.
4589                  if( origyearshtml === inst.yearshtml && inst.yearshtml ){
4590                      inst.dpDiv.find("select.ui-datepicker-year:first").replaceWith(inst.yearshtml);
4591                  }
4592                  origyearshtml = inst.yearshtml = null;
4593              }, 0);
4594          }
4595      },
4596  
4597      // #6694 - don't focus the input if it's already focused
4598      // this breaks the change event in IE
4599      // Support: IE and jQuery <1.9
4600      _shouldFocusInput: function( inst ) {
4601          return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
4602      },
4603  
4604      /* Check positioning to remain on screen. */
4605      _checkOffset: function(inst, offset, isFixed) {
4606          var dpWidth = inst.dpDiv.outerWidth(),
4607              dpHeight = inst.dpDiv.outerHeight(),
4608              inputWidth = inst.input ? inst.input.outerWidth() : 0,
4609              inputHeight = inst.input ? inst.input.outerHeight() : 0,
4610              viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()),
4611              viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop());
4612  
4613          offset.left -= (this._get(inst, "isRTL") ? (dpWidth - inputWidth) : 0);
4614          offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0;
4615          offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
4616  
4617          // now check if datepicker is showing outside window viewport - move to a better place if so.
4618          offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
4619              Math.abs(offset.left + dpWidth - viewWidth) : 0);
4620          offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
4621              Math.abs(dpHeight + inputHeight) : 0);
4622  
4623          return offset;
4624      },
4625  
4626      /* Find an object's position on the screen. */
4627      _findPos: function(obj) {
4628          var position,
4629              inst = this._getInst(obj),
4630              isRTL = this._get(inst, "isRTL");
4631  
4632          while (obj && (obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden(obj))) {
4633              obj = obj[isRTL ? "previousSibling" : "nextSibling"];
4634          }
4635  
4636          position = $(obj).offset();
4637          return [position.left, position.top];
4638      },
4639  
4640      /* Hide the date picker from view.
4641       * @param  input  element - the input field attached to the date picker
4642       */
4643      _hideDatepicker: function(input) {
4644          var showAnim, duration, postProcess, onClose,
4645              inst = this._curInst;
4646  
4647          if (!inst || (input && inst !== $.data(input, "datepicker"))) {
4648              return;
4649          }
4650  
4651          if (this._datepickerShowing) {
4652              showAnim = this._get(inst, "showAnim");
4653              duration = this._get(inst, "duration");
4654              postProcess = function() {
4655                  $.datepicker._tidyDialog(inst);
4656              };
4657  
4658              // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
4659              if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
4660                  inst.dpDiv.hide(showAnim, $.datepicker._get(inst, "showOptions"), duration, postProcess);
4661              } else {
4662                  inst.dpDiv[(showAnim === "slideDown" ? "slideUp" :
4663                      (showAnim === "fadeIn" ? "fadeOut" : "hide"))]((showAnim ? duration : null), postProcess);
4664              }
4665  
4666              if (!showAnim) {
4667                  postProcess();
4668              }
4669              this._datepickerShowing = false;
4670  
4671              onClose = this._get(inst, "onClose");
4672              if (onClose) {
4673                  onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]);
4674              }
4675  
4676              this._lastInput = null;
4677              if (this._inDialog) {
4678                  this._dialogInput.css({ position: "absolute", left: "0", top: "-100px" });
4679                  if ($.blockUI) {
4680                      $.unblockUI();
4681                      $("body").append(this.dpDiv);
4682                  }
4683              }
4684              this._inDialog = false;
4685          }
4686      },
4687  
4688      /* Tidy up after a dialog display. */
4689      _tidyDialog: function(inst) {
4690          inst.dpDiv.removeClass(this._dialogClass).unbind(".ui-datepicker-calendar");
4691      },
4692  
4693      /* Close date picker if clicked elsewhere. */
4694      _checkExternalClick: function(event) {
4695          if (!$.datepicker._curInst) {
4696              return;
4697          }
4698  
4699          var $target = $(event.target),
4700              inst = $.datepicker._getInst($target[0]);
4701  
4702          if ( ( ( $target[0].id !== $.datepicker._mainDivId &&
4703                  $target.parents("#" + $.datepicker._mainDivId).length === 0 &&
4704                  !$target.hasClass($.datepicker.markerClassName) &&
4705                  !$target.closest("." + $.datepicker._triggerClass).length &&
4706                  $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) ||
4707              ( $target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst ) ) {
4708                  $.datepicker._hideDatepicker();
4709          }
4710      },
4711  
4712      /* Adjust one of the date sub-fields. */
4713      _adjustDate: function(id, offset, period) {
4714          var target = $(id),
4715              inst = this._getInst(target[0]);
4716  
4717          if (this._isDisabledDatepicker(target[0])) {
4718              return;
4719          }
4720          this._adjustInstDate(inst, offset +
4721              (period === "M" ? this._get(inst, "showCurrentAtPos") : 0), // undo positioning
4722              period);
4723          this._updateDatepicker(inst);
4724      },
4725  
4726      /* Action for current link. */
4727      _gotoToday: function(id) {
4728          var date,
4729              target = $(id),
4730              inst = this._getInst(target[0]);
4731  
4732          if (this._get(inst, "gotoCurrent") && inst.currentDay) {
4733              inst.selectedDay = inst.currentDay;
4734              inst.drawMonth = inst.selectedMonth = inst.currentMonth;
4735              inst.drawYear = inst.selectedYear = inst.currentYear;
4736          } else {
4737              date = new Date();
4738              inst.selectedDay = date.getDate();
4739              inst.drawMonth = inst.selectedMonth = date.getMonth();
4740              inst.drawYear = inst.selectedYear = date.getFullYear();
4741          }
4742          this._notifyChange(inst);
4743          this._adjustDate(target);
4744      },
4745  
4746      /* Action for selecting a new month/year. */
4747      _selectMonthYear: function(id, select, period) {
4748          var target = $(id),
4749              inst = this._getInst(target[0]);
4750  
4751          inst["selected" + (period === "M" ? "Month" : "Year")] =
4752          inst["draw" + (period === "M" ? "Month" : "Year")] =
4753              parseInt(select.options[select.selectedIndex].value,10);
4754  
4755          this._notifyChange(inst);
4756          this._adjustDate(target);
4757      },
4758  
4759      /* Action for selecting a day. */
4760      _selectDay: function(id, month, year, td) {
4761          var inst,
4762              target = $(id);
4763  
4764          if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
4765              return;
4766          }
4767  
4768          inst = this._getInst(target[0]);
4769          inst.selectedDay = inst.currentDay = $("a", td).html();
4770          inst.selectedMonth = inst.currentMonth = month;
4771          inst.selectedYear = inst.currentYear = year;
4772          this._selectDate(id, this._formatDate(inst,
4773              inst.currentDay, inst.currentMonth, inst.currentYear));
4774      },
4775  
4776      /* Erase the input field and hide the date picker. */
4777      _clearDate: function(id) {
4778          var target = $(id);
4779          this._selectDate(target, "");
4780      },
4781  
4782      /* Update the input field with the selected date. */
4783      _selectDate: function(id, dateStr) {
4784          var onSelect,
4785              target = $(id),
4786              inst = this._getInst(target[0]);
4787  
4788          dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
4789          if (inst.input) {
4790              inst.input.val(dateStr);
4791          }
4792          this._updateAlternate(inst);
4793  
4794          onSelect = this._get(inst, "onSelect");
4795          if (onSelect) {
4796              onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);  // trigger custom callback
4797          } else if (inst.input) {
4798              inst.input.trigger("change"); // fire the change event
4799          }
4800  
4801          if (inst.inline){
4802              this._updateDatepicker(inst);
4803          } else {
4804              this._hideDatepicker();
4805              this._lastInput = inst.input[0];
4806              if (typeof(inst.input[0]) !== "object") {
4807                  inst.input.focus(); // restore focus
4808              }
4809              this._lastInput = null;
4810          }
4811      },
4812  
4813      /* Update any alternate field to synchronise with the main field. */
4814      _updateAlternate: function(inst) {
4815          var altFormat, date, dateStr,
4816              altField = this._get(inst, "altField");
4817  
4818          if (altField) { // update alternate field too
4819              altFormat = this._get(inst, "altFormat") || this._get(inst, "dateFormat");
4820              date = this._getDate(inst);
4821              dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
4822              $(altField).each(function() { $(this).val(dateStr); });
4823          }
4824      },
4825  
4826      /* Set as beforeShowDay function to prevent selection of weekends.
4827       * @param  date  Date - the date to customise
4828       * @return [boolean, string] - is this date selectable?, what is its CSS class?
4829       */
4830      noWeekends: function(date) {
4831          var day = date.getDay();
4832          return [(day > 0 && day < 6), ""];
4833      },
4834  
4835      /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
4836       * @param  date  Date - the date to get the week for
4837       * @return  number - the number of the week within the year that contains this date
4838       */
4839      iso8601Week: function(date) {
4840          var time,
4841              checkDate = new Date(date.getTime());
4842  
4843          // Find Thursday of this week starting on Monday
4844          checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
4845  
4846          time = checkDate.getTime();
4847          checkDate.setMonth(0); // Compare with Jan 1
4848          checkDate.setDate(1);
4849          return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
4850      },
4851  
4852      /* Parse a string value into a date object.
4853       * See formatDate below for the possible formats.
4854       *
4855       * @param  format string - the expected format of the date
4856       * @param  value string - the date in the above format
4857       * @param  settings Object - attributes include:
4858       *                    shortYearCutoff  number - the cutoff year for determining the century (optional)
4859       *                    dayNamesShort    string[7] - abbreviated names of the days from Sunday (optional)
4860       *                    dayNames        string[7] - names of the days from Sunday (optional)
4861       *                    monthNamesShort string[12] - abbreviated names of the months (optional)
4862       *                    monthNames        string[12] - names of the months (optional)
4863       * @return  Date - the extracted date value or null if value is blank
4864       */
4865      parseDate: function (format, value, settings) {
4866          if (format == null || value == null) {
4867              throw "Invalid arguments";
4868          }
4869  
4870          value = (typeof value === "object" ? value.toString() : value + "");
4871          if (value === "") {
4872              return null;
4873          }
4874  
4875          var iFormat, dim, extra,
4876              iValue = 0,
4877              shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff,
4878              shortYearCutoff = (typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
4879                  new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)),
4880              dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
4881              dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
4882              monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
4883              monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
4884              year = -1,
4885              month = -1,
4886              day = -1,
4887              doy = -1,
4888              literal = false,
4889              date,
4890              // Check whether a format character is doubled
4891              lookAhead = function(match) {
4892                  var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
4893                  if (matches) {
4894                      iFormat++;
4895                  }
4896                  return matches;
4897              },
4898              // Extract a number from the string value
4899              getNumber = function(match) {
4900                  var isDoubled = lookAhead(match),
4901                      size = (match === "@" ? 14 : (match === "!" ? 20 :
4902                      (match === "y" && isDoubled ? 4 : (match === "o" ? 3 : 2)))),
4903                      minSize = (match === "y" ? size : 1),
4904                      digits = new RegExp("^\\d{" + minSize + "," + size + "}"),
4905                      num = value.substring(iValue).match(digits);
4906                  if (!num) {
4907                      throw "Missing number at position " + iValue;
4908                  }
4909                  iValue += num[0].length;
4910                  return parseInt(num[0], 10);
4911              },
4912              // Extract a name from the string value and convert to an index
4913              getName = function(match, shortNames, longNames) {
4914                  var index = -1,
4915                      names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
4916                          return [ [k, v] ];
4917                      }).sort(function (a, b) {
4918                          return -(a[1].length - b[1].length);
4919                      });
4920  
4921                  $.each(names, function (i, pair) {
4922                      var name = pair[1];
4923                      if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
4924                          index = pair[0];
4925                          iValue += name.length;
4926                          return false;
4927                      }
4928                  });
4929                  if (index !== -1) {
4930                      return index + 1;
4931                  } else {
4932                      throw "Unknown name at position " + iValue;
4933                  }
4934              },
4935              // Confirm that a literal character matches the string value
4936              checkLiteral = function() {
4937                  if (value.charAt(iValue) !== format.charAt(iFormat)) {
4938                      throw "Unexpected literal at position " + iValue;
4939                  }
4940                  iValue++;
4941              };
4942  
4943          for (iFormat = 0; iFormat < format.length; iFormat++) {
4944              if (literal) {
4945                  if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
4946                      literal = false;
4947                  } else {
4948                      checkLiteral();
4949                  }
4950              } else {
4951                  switch (format.charAt(iFormat)) {
4952                      case "d":
4953                          day = getNumber("d");
4954                          break;
4955                      case "D":
4956                          getName("D", dayNamesShort, dayNames);
4957                          break;
4958                      case "o":
4959                          doy = getNumber("o");
4960                          break;
4961                      case "m":
4962                          month = getNumber("m");
4963                          break;
4964                      case "M":
4965                          month = getName("M", monthNamesShort, monthNames);
4966                          break;
4967                      case "y":
4968                          year = getNumber("y");
4969                          break;
4970                      case "@":
4971                          date = new Date(getNumber("@"));
4972                          year = date.getFullYear();
4973                          month = date.getMonth() + 1;
4974                          day = date.getDate();
4975                          break;
4976                      case "!":
4977                          date = new Date((getNumber("!") - this._ticksTo1970) / 10000);
4978                          year = date.getFullYear();
4979                          month = date.getMonth() + 1;
4980                          day = date.getDate();
4981                          break;
4982                      case "'":
4983                          if (lookAhead("'")){
4984                              checkLiteral();
4985                          } else {
4986                              literal = true;
4987                          }
4988                          break;
4989                      default:
4990                          checkLiteral();
4991                  }
4992              }
4993          }
4994  
4995          if (iValue < value.length){
4996              extra = value.substr(iValue);
4997              if (!/^\s+/.test(extra)) {
4998                  throw "Extra/unparsed characters found in date: " + extra;
4999              }
5000          }
5001  
5002          if (year === -1) {
5003              year = new Date().getFullYear();
5004          } else if (year < 100) {
5005              year += new Date().getFullYear() - new Date().getFullYear() % 100 +
5006                  (year <= shortYearCutoff ? 0 : -100);
5007          }
5008  
5009          if (doy > -1) {
5010              month = 1;
5011              day = doy;
5012              do {
5013                  dim = this._getDaysInMonth(year, month - 1);
5014                  if (day <= dim) {
5015                      break;
5016                  }
5017                  month++;
5018                  day -= dim;
5019              } while (true);
5020          }
5021  
5022          date = this._daylightSavingAdjust(new Date(year, month - 1, day));
5023          if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
5024              throw "Invalid date"; // E.g. 31/02/00
5025          }
5026          return date;
5027      },
5028  
5029      /* Standard date formats. */
5030      ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
5031      COOKIE: "D, dd M yy",
5032      ISO_8601: "yy-mm-dd",
5033      RFC_822: "D, d M y",
5034      RFC_850: "DD, dd-M-y",
5035      RFC_1036: "D, d M y",
5036      RFC_1123: "D, d M yy",
5037      RFC_2822: "D, d M yy",
5038      RSS: "D, d M y", // RFC 822
5039      TICKS: "!",
5040      TIMESTAMP: "@",
5041      W3C: "yy-mm-dd", // ISO 8601
5042  
5043      _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
5044          Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
5045  
5046      /* Format a date object into a string value.
5047       * The format can be combinations of the following:
5048       * d  - day of month (no leading zero)
5049       * dd - day of month (two digit)
5050       * o  - day of year (no leading zeros)
5051       * oo - day of year (three digit)
5052       * D  - day name short
5053       * DD - day name long
5054       * m  - month of year (no leading zero)
5055       * mm - month of year (two digit)
5056       * M  - month name short
5057       * MM - month name long
5058       * y  - year (two digit)
5059       * yy - year (four digit)
5060       * @ - Unix timestamp (ms since 01/01/1970)
5061       * ! - Windows ticks (100ns since 01/01/0001)
5062       * "..." - literal text
5063       * '' - single quote
5064       *
5065       * @param  format string - the desired format of the date
5066       * @param  date Date - the date value to format
5067       * @param  settings Object - attributes include:
5068       *                    dayNamesShort    string[7] - abbreviated names of the days from Sunday (optional)
5069       *                    dayNames        string[7] - names of the days from Sunday (optional)
5070       *                    monthNamesShort string[12] - abbreviated names of the months (optional)
5071       *                    monthNames        string[12] - names of the months (optional)
5072       * @return  string - the date in the above format
5073       */
5074      formatDate: function (format, date, settings) {
5075          if (!date) {
5076              return "";
5077          }
5078  
5079          var iFormat,
5080              dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
5081              dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
5082              monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
5083              monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
5084              // Check whether a format character is doubled
5085              lookAhead = function(match) {
5086                  var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
5087                  if (matches) {
5088                      iFormat++;
5089                  }
5090                  return matches;
5091              },
5092              // Format a number, with leading zero if necessary
5093              formatNumber = function(match, value, len) {
5094                  var num = "" + value;
5095                  if (lookAhead(match)) {
5096                      while (num.length < len) {
5097                          num = "0" + num;
5098                      }
5099                  }
5100                  return num;
5101              },
5102              // Format a name, short or long as requested
5103              formatName = function(match, value, shortNames, longNames) {
5104                  return (lookAhead(match) ? longNames[value] : shortNames[value]);
5105              },
5106              output = "",
5107              literal = false;
5108  
5109          if (date) {
5110              for (iFormat = 0; iFormat < format.length; iFormat++) {
5111                  if (literal) {
5112                      if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
5113                          literal = false;
5114                      } else {
5115                          output += format.charAt(iFormat);
5116                      }
5117                  } else {
5118                      switch (format.charAt(iFormat)) {
5119                          case "d":
5120                              output += formatNumber("d", date.getDate(), 2);
5121                              break;
5122                          case "D":
5123                              output += formatName("D", date.getDay(), dayNamesShort, dayNames);
5124                              break;
5125                          case "o":
5126                              output += formatNumber("o",
5127                                  Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
5128                              break;
5129                          case "m":
5130                              output += formatNumber("m", date.getMonth() + 1, 2);
5131                              break;
5132                          case "M":
5133                              output += formatName("M", date.getMonth(), monthNamesShort, monthNames);
5134                              break;
5135                          case "y":
5136                              output += (lookAhead("y") ? date.getFullYear() :
5137                                  (date.getYear() % 100 < 10 ? "0" : "") + date.getYear() % 100);
5138                              break;
5139                          case "@":
5140                              output += date.getTime();
5141                              break;
5142                          case "!":
5143                              output += date.getTime() * 10000 + this._ticksTo1970;
5144                              break;
5145                          case "'":
5146                              if (lookAhead("'")) {
5147                                  output += "'";
5148                              } else {
5149                                  literal = true;
5150                              }
5151                              break;
5152                          default:
5153                              output += format.charAt(iFormat);
5154                      }
5155                  }
5156              }
5157          }
5158          return output;
5159      },
5160  
5161      /* Extract all possible characters from the date format. */
5162      _possibleChars: function (format) {
5163          var iFormat,
5164              chars = "",
5165              literal = false,
5166              // Check whether a format character is doubled
5167              lookAhead = function(match) {
5168                  var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
5169                  if (matches) {
5170                      iFormat++;
5171                  }
5172                  return matches;
5173              };
5174  
5175          for (iFormat = 0; iFormat < format.length; iFormat++) {
5176              if (literal) {
5177                  if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
5178                      literal = false;
5179                  } else {
5180                      chars += format.charAt(iFormat);
5181                  }
5182              } else {
5183                  switch (format.charAt(iFormat)) {
5184                      case "d": case "m": case "y": case "@":
5185                          chars += "0123456789";
5186                          break;
5187                      case "D": case "M":
5188                          return null; // Accept anything
5189                      case "'":
5190                          if (lookAhead("'")) {
5191                              chars += "'";
5192                          } else {
5193                              literal = true;
5194                          }
5195                          break;
5196                      default:
5197                          chars += format.charAt(iFormat);
5198                  }
5199              }
5200          }
5201          return chars;
5202      },
5203  
5204      /* Get a setting value, defaulting if necessary. */
5205      _get: function(inst, name) {
5206          return inst.settings[name] !== undefined ?
5207              inst.settings[name] : this._defaults[name];
5208      },
5209  
5210      /* Parse existing date and initialise date picker. */
5211      _setDateFromField: function(inst, noDefault) {
5212          if (inst.input.val() === inst.lastVal) {
5213              return;
5214          }
5215  
5216          var dateFormat = this._get(inst, "dateFormat"),
5217              dates = inst.lastVal = inst.input ? inst.input.val() : null,
5218              defaultDate = this._getDefaultDate(inst),
5219              date = defaultDate,
5220              settings = this._getFormatConfig(inst);
5221  
5222          try {
5223              date = this.parseDate(dateFormat, dates, settings) || defaultDate;
5224          } catch (event) {
5225              dates = (noDefault ? "" : dates);
5226          }
5227          inst.selectedDay = date.getDate();
5228          inst.drawMonth = inst.selectedMonth = date.getMonth();
5229          inst.drawYear = inst.selectedYear = date.getFullYear();
5230          inst.currentDay = (dates ? date.getDate() : 0);
5231          inst.currentMonth = (dates ? date.getMonth() : 0);
5232          inst.currentYear = (dates ? date.getFullYear() : 0);
5233          this._adjustInstDate(inst);
5234      },
5235  
5236      /* Retrieve the default date shown on opening. */
5237      _getDefaultDate: function(inst) {
5238          return this._restrictMinMax(inst,
5239              this._determineDate(inst, this._get(inst, "defaultDate"), new Date()));
5240      },
5241  
5242      /* A date may be specified as an exact value or a relative one. */
5243      _determineDate: function(inst, date, defaultDate) {
5244          var offsetNumeric = function(offset) {
5245                  var date = new Date();
5246                  date.setDate(date.getDate() + offset);
5247                  return date;
5248              },
5249              offsetString = function(offset) {
5250                  try {
5251                      return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
5252                          offset, $.datepicker._getFormatConfig(inst));
5253                  }
5254                  catch (e) {
5255                      // Ignore
5256                  }
5257  
5258                  var date = (offset.toLowerCase().match(/^c/) ?
5259                      $.datepicker._getDate(inst) : null) || new Date(),
5260                      year = date.getFullYear(),
5261                      month = date.getMonth(),
5262                      day = date.getDate(),
5263                      pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
5264                      matches = pattern.exec(offset);
5265  
5266                  while (matches) {
5267                      switch (matches[2] || "d") {
5268                          case "d" : case "D" :
5269                              day += parseInt(matches[1],10); break;
5270                          case "w" : case "W" :
5271                              day += parseInt(matches[1],10) * 7; break;
5272                          case "m" : case "M" :
5273                              month += parseInt(matches[1],10);
5274                              day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
5275                              break;
5276                          case "y": case "Y" :
5277                              year += parseInt(matches[1],10);
5278                              day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
5279                              break;
5280                      }
5281                      matches = pattern.exec(offset);
5282                  }
5283                  return new Date(year, month, day);
5284              },
5285              newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) :
5286                  (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
5287  
5288          newDate = (newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate);
5289          if (newDate) {
5290              newDate.setHours(0);
5291              newDate.setMinutes(0);
5292              newDate.setSeconds(0);
5293              newDate.setMilliseconds(0);
5294          }
5295          return this._daylightSavingAdjust(newDate);
5296      },
5297  
5298      /* Handle switch to/from daylight saving.
5299       * Hours may be non-zero on daylight saving cut-over:
5300       * > 12 when midnight changeover, but then cannot generate
5301       * midnight datetime, so jump to 1AM, otherwise reset.
5302       * @param  date  (Date) the date to check
5303       * @return  (Date) the corrected date
5304       */
5305      _daylightSavingAdjust: function(date) {
5306          if (!date) {
5307              return null;
5308          }
5309          date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
5310          return date;
5311      },
5312  
5313      /* Set the date(s) directly. */
5314      _setDate: function(inst, date, noChange) {
5315          var clear = !date,
5316              origMonth = inst.selectedMonth,
5317              origYear = inst.selectedYear,
5318              newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
5319  
5320          inst.selectedDay = inst.currentDay = newDate.getDate();
5321          inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
5322          inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
5323          if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) {
5324              this._notifyChange(inst);
5325          }
5326          this._adjustInstDate(inst);
5327          if (inst.input) {
5328              inst.input.val(clear ? "" : this._formatDate(inst));
5329          }
5330      },
5331  
5332      /* Retrieve the date(s) directly. */
5333      _getDate: function(inst) {
5334          var startDate = (!inst.currentYear || (inst.input && inst.input.val() === "") ? null :
5335              this._daylightSavingAdjust(new Date(
5336              inst.currentYear, inst.currentMonth, inst.currentDay)));
5337              return startDate;
5338      },
5339  
5340      /* Attach the onxxx handlers.  These are declared statically so
5341       * they work with static code transformers like Caja.
5342       */
5343      _attachHandlers: function(inst) {
5344          var stepMonths = this._get(inst, "stepMonths"),
5345              id = "#" + inst.id.replace( /\\\\/g, "\\" );
5346          inst.dpDiv.find("[data-handler]").map(function () {
5347              var handler = {
5348                  prev: function () {
5349                      $.datepicker._adjustDate(id, -stepMonths, "M");
5350                  },
5351                  next: function () {
5352                      $.datepicker._adjustDate(id, +stepMonths, "M");
5353                  },
5354                  hide: function () {
5355                      $.datepicker._hideDatepicker();
5356                  },
5357                  today: function () {
5358                      $.datepicker._gotoToday(id);
5359                  },
5360                  selectDay: function () {
5361                      $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this);
5362                      return false;
5363                  },
5364                  selectMonth: function () {
5365                      $.datepicker._selectMonthYear(id, this, "M");
5366                      return false;
5367                  },
5368                  selectYear: function () {
5369                      $.datepicker._selectMonthYear(id, this, "Y");
5370                      return false;
5371                  }
5372              };
5373              $(this).bind(this.getAttribute("data-event"), handler[this.getAttribute("data-handler")]);
5374          });
5375      },
5376  
5377      /* Generate the HTML for the current state of the date picker. */
5378      _generateHTML: function(inst) {
5379          var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
5380              controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
5381              monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
5382              selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
5383              cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
5384              printDate, dRow, tbody, daySettings, otherMonth, unselectable,
5385              tempDate = new Date(),
5386              today = this._daylightSavingAdjust(
5387                  new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time
5388              isRTL = this._get(inst, "isRTL"),
5389              showButtonPanel = this._get(inst, "showButtonPanel"),
5390              hideIfNoPrevNext = this._get(inst, "hideIfNoPrevNext"),
5391              navigationAsDateFormat = this._get(inst, "navigationAsDateFormat"),
5392              numMonths = this._getNumberOfMonths(inst),
5393              showCurrentAtPos = this._get(inst, "showCurrentAtPos"),
5394              stepMonths = this._get(inst, "stepMonths"),
5395              isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1),
5396              currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
5397                  new Date(inst.currentYear, inst.currentMonth, inst.currentDay))),
5398              minDate = this._getMinMaxDate(inst, "min"),
5399              maxDate = this._getMinMaxDate(inst, "max"),
5400              drawMonth = inst.drawMonth - showCurrentAtPos,
5401              drawYear = inst.drawYear;
5402  
5403          if (drawMonth < 0) {
5404              drawMonth += 12;
5405              drawYear--;
5406          }
5407          if (maxDate) {
5408              maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
5409                  maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
5410              maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
5411              while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
5412                  drawMonth--;
5413                  if (drawMonth < 0) {
5414                      drawMonth = 11;
5415                      drawYear--;
5416                  }
5417              }
5418          }
5419          inst.drawMonth = drawMonth;
5420          inst.drawYear = drawYear;
5421  
5422          prevText = this._get(inst, "prevText");
5423          prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
5424              this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
5425              this._getFormatConfig(inst)));
5426  
5427          prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
5428              "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" +
5429              " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" :
5430              (hideIfNoPrevNext ? "" : "<a class='ui-datepicker-prev ui-corner-all ui-state-disabled' title='"+ prevText +"'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>"));
5431  
5432          nextText = this._get(inst, "nextText");
5433          nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
5434              this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
5435              this._getFormatConfig(inst)));
5436  
5437          next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
5438              "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" +
5439              " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" :
5440              (hideIfNoPrevNext ? "" : "<a class='ui-datepicker-next ui-corner-all ui-state-disabled' title='"+ nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>"));
5441  
5442          currentText = this._get(inst, "currentText");
5443          gotoDate = (this._get(inst, "gotoCurrent") && inst.currentDay ? currentDate : today);
5444          currentText = (!navigationAsDateFormat ? currentText :
5445              this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
5446  
5447          controls = (!inst.inline ? "<button type='button' class='ui-datepicker-close ui-state-default ui-priority-primary ui-corner-all' data-handler='hide' data-event='click'>" +
5448              this._get(inst, "closeText") + "</button>" : "");
5449  
5450          buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") +
5451              (this._isInRange(inst, gotoDate) ? "<button type='button' class='ui-datepicker-current ui-state-default ui-priority-secondary ui-corner-all' data-handler='today' data-event='click'" +
5452              ">" + currentText + "</button>" : "") + (isRTL ? "" : controls) + "</div>" : "";
5453  
5454          firstDay = parseInt(this._get(inst, "firstDay"),10);
5455          firstDay = (isNaN(firstDay) ? 0 : firstDay);
5456  
5457          showWeek = this._get(inst, "showWeek");
5458          dayNames = this._get(inst, "dayNames");
5459          dayNamesMin = this._get(inst, "dayNamesMin");
5460          monthNames = this._get(inst, "monthNames");
5461          monthNamesShort = this._get(inst, "monthNamesShort");
5462          beforeShowDay = this._get(inst, "beforeShowDay");
5463          showOtherMonths = this._get(inst, "showOtherMonths");
5464          selectOtherMonths = this._get(inst, "selectOtherMonths");
5465          defaultDate = this._getDefaultDate(inst);
5466          html = "";
5467          dow;
5468          for (row = 0; row < numMonths[0]; row++) {
5469              group = "";
5470              this.maxRows = 4;
5471              for (col = 0; col < numMonths[1]; col++) {
5472                  selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
5473                  cornerClass = " ui-corner-all";
5474                  calender = "";
5475                  if (isMultiMonth) {
5476                      calender += "<div class='ui-datepicker-group";
5477                      if (numMonths[1] > 1) {
5478                          switch (col) {
5479                              case 0: calender += " ui-datepicker-group-first";
5480                                  cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
5481                              case numMonths[1]-1: calender += " ui-datepicker-group-last";
5482                                  cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;
5483                              default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
5484                          }
5485                      }
5486                      calender += "'>";
5487                  }
5488                  calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
5489                      (/all|left/.test(cornerClass) && row === 0 ? (isRTL ? next : prev) : "") +
5490                      (/all|right/.test(cornerClass) && row === 0 ? (isRTL ? prev : next) : "") +
5491                      this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
5492                      row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
5493                      "</div><table class='ui-datepicker-calendar'><thead>" +
5494                      "<tr>";
5495                  thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : "");
5496                  for (dow = 0; dow < 7; dow++) { // days of the week
5497                      day = (dow + firstDay) % 7;
5498                      thead += "<th scope='col'" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" +
5499                          "<span title='" + dayNames[day] + "'>" + dayNamesMin[day] + "</span></th>";
5500                  }
5501                  calender += thead + "</tr></thead><tbody>";
5502                  daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
5503                  if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) {
5504                      inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
5505                  }
5506                  leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
5507                  curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
5508                  numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043)
5509                  this.maxRows = numRows;
5510                  printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
5511                  for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows
5512                      calender += "<tr>";
5513                      tbody = (!showWeek ? "" : "<td class='ui-datepicker-week-col'>" +
5514                          this._get(inst, "calculateWeek")(printDate) + "</td>");
5515                      for (dow = 0; dow < 7; dow++) { // create date picker days
5516                          daySettings = (beforeShowDay ?
5517                              beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, ""]);
5518                          otherMonth = (printDate.getMonth() !== drawMonth);
5519                          unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
5520                              (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
5521                          tbody += "<td class='" +
5522                              ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends
5523                              (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months
5524                              ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key
5525                              (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ?
5526                              // or defaultDate is current printedDate and defaultDate is selectedDate
5527                              " " + this._dayOverClass : "") + // highlight selected day
5528                              (unselectable ? " " + this._unselectableClass + " ui-state-disabled": "") +  // highlight unselectable days
5529                              (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates
5530                              (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day
5531                              (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different)
5532                              ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "&#39;") + "'" : "") + // cell title
5533                              (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions
5534                              (otherMonth && !showOtherMonths ? "&#xa0;" : // display for other months
5535                              (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
5536                              (printDate.getTime() === today.getTime() ? " ui-state-highlight" : "") +
5537                              (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day
5538                              (otherMonth ? " ui-priority-secondary" : "") + // distinguish dates from other months
5539                              "' href='#'>" + printDate.getDate() + "</a>")) + "</td>"; // display selectable date
5540                          printDate.setDate(printDate.getDate() + 1);
5541                          printDate = this._daylightSavingAdjust(printDate);
5542                      }
5543                      calender += tbody + "</tr>";
5544                  }
5545                  drawMonth++;
5546                  if (drawMonth > 11) {
5547                      drawMonth = 0;
5548                      drawYear++;
5549                  }
5550                  calender += "</tbody></table>" + (isMultiMonth ? "</div>" +
5551                              ((numMonths[0] > 0 && col === numMonths[1]-1) ? "<div class='ui-datepicker-row-break'></div>" : "") : "");
5552                  group += calender;
5553              }
5554              html += group;
5555          }
5556          html += buttonPanel;
5557          inst._keyEvent = false;
5558          return html;
5559      },
5560  
5561      /* Generate the month and year header. */
5562      _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
5563              secondary, monthNames, monthNamesShort) {
5564  
5565          var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
5566              changeMonth = this._get(inst, "changeMonth"),
5567              changeYear = this._get(inst, "changeYear"),
5568              showMonthAfterYear = this._get(inst, "showMonthAfterYear"),
5569              html = "<div class='ui-datepicker-title'>",
5570              monthHtml = "";
5571  
5572          // month selection
5573          if (secondary || !changeMonth) {
5574              monthHtml += "<span class='ui-datepicker-month'>" + monthNames[drawMonth] + "</span>";
5575          } else {
5576              inMinYear = (minDate && minDate.getFullYear() === drawYear);
5577              inMaxYear = (maxDate && maxDate.getFullYear() === drawYear);
5578              monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
5579              for ( month = 0; month < 12; month++) {
5580                  if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) {
5581                      monthHtml += "<option value='" + month + "'" +
5582                          (month === drawMonth ? " selected='selected'" : "") +
5583                          ">" + monthNamesShort[month] + "</option>";
5584                  }
5585              }
5586              monthHtml += "</select>";
5587          }
5588  
5589          if (!showMonthAfterYear) {
5590              html += monthHtml + (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "");
5591          }
5592  
5593          // year selection
5594          if ( !inst.yearshtml ) {
5595              inst.yearshtml = "";
5596              if (secondary || !changeYear) {
5597                  html += "<span class='ui-datepicker-year'>" + drawYear + "</span>";
5598              } else {
5599                  // determine range of years to display
5600                  years = this._get(inst, "yearRange").split(":");
5601                  thisYear = new Date().getFullYear();
5602                  determineYear = function(value) {
5603                      var year = (value.match(/c[+\-].*/) ? drawYear + parseInt(value.substring(1), 10) :
5604                          (value.match(/[+\-].*/) ? thisYear + parseInt(value, 10) :
5605                          parseInt(value, 10)));
5606                      return (isNaN(year) ? thisYear : year);
5607                  };
5608                  year = determineYear(years[0]);
5609                  endYear = Math.max(year, determineYear(years[1] || ""));
5610                  year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
5611                  endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
5612                  inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
5613                  for (; year <= endYear; year++) {
5614                      inst.yearshtml += "<option value='" + year + "'" +
5615                          (year === drawYear ? " selected='selected'" : "") +
5616                          ">" + year + "</option>";
5617                  }
5618                  inst.yearshtml += "</select>";
5619  
5620                  html += inst.yearshtml;
5621                  inst.yearshtml = null;
5622              }
5623          }
5624  
5625          html += this._get(inst, "yearSuffix");
5626          if (showMonthAfterYear) {
5627              html += (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "") + monthHtml;
5628          }
5629          html += "</div>"; // Close datepicker_header
5630          return html;
5631      },
5632  
5633      /* Adjust one of the date sub-fields. */
5634      _adjustInstDate: function(inst, offset, period) {
5635          var year = inst.drawYear + (period === "Y" ? offset : 0),
5636              month = inst.drawMonth + (period === "M" ? offset : 0),
5637              day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0),
5638              date = this._restrictMinMax(inst, this._daylightSavingAdjust(new Date(year, month, day)));
5639  
5640          inst.selectedDay = date.getDate();
5641          inst.drawMonth = inst.selectedMonth = date.getMonth();
5642          inst.drawYear = inst.selectedYear = date.getFullYear();
5643          if (period === "M" || period === "Y") {
5644              this._notifyChange(inst);
5645          }
5646      },
5647  
5648      /* Ensure a date is within any min/max bounds. */
5649      _restrictMinMax: function(inst, date) {
5650          var minDate = this._getMinMaxDate(inst, "min"),
5651              maxDate = this._getMinMaxDate(inst, "max"),
5652              newDate = (minDate && date < minDate ? minDate : date);
5653          return (maxDate && newDate > maxDate ? maxDate : newDate);
5654      },
5655  
5656      /* Notify change of month/year. */
5657      _notifyChange: function(inst) {
5658          var onChange = this._get(inst, "onChangeMonthYear");
5659          if (onChange) {
5660              onChange.apply((inst.input ? inst.input[0] : null),
5661                  [inst.selectedYear, inst.selectedMonth + 1, inst]);
5662          }
5663      },
5664  
5665      /* Determine the number of months to show. */
5666      _getNumberOfMonths: function(inst) {
5667          var numMonths = this._get(inst, "numberOfMonths");
5668          return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths));
5669      },
5670  
5671      /* Determine the current maximum date - ensure no time components are set. */
5672      _getMinMaxDate: function(inst, minMax) {
5673          return this._determineDate(inst, this._get(inst, minMax + "Date"), null);
5674      },
5675  
5676      /* Find the number of days in a given month. */
5677      _getDaysInMonth: function(year, month) {
5678          return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate();
5679      },
5680  
5681      /* Find the day of the week of the first of a month. */
5682      _getFirstDayOfMonth: function(year, month) {
5683          return new Date(year, month, 1).getDay();
5684      },
5685  
5686      /* Determines if we should allow a "next/prev" month display change. */
5687      _canAdjustMonth: function(inst, offset, curYear, curMonth) {
5688          var numMonths = this._getNumberOfMonths(inst),
5689              date = this._daylightSavingAdjust(new Date(curYear,
5690              curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
5691  
5692          if (offset < 0) {
5693              date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
5694          }
5695          return this._isInRange(inst, date);
5696      },
5697  
5698      /* Is the given date in the accepted range? */
5699      _isInRange: function(inst, date) {
5700          var yearSplit, currentYear,
5701              minDate = this._getMinMaxDate(inst, "min"),
5702              maxDate = this._getMinMaxDate(inst, "max"),
5703              minYear = null,
5704              maxYear = null,
5705              years = this._get(inst, "yearRange");
5706              if (years){
5707                  yearSplit = years.split(":");
5708                  currentYear = new Date().getFullYear();
5709                  minYear = parseInt(yearSplit[0], 10);
5710                  maxYear = parseInt(yearSplit[1], 10);
5711                  if ( yearSplit[0].match(/[+\-].*/) ) {
5712                      minYear += currentYear;
5713                  }
5714                  if ( yearSplit[1].match(/[+\-].*/) ) {
5715                      maxYear += currentYear;
5716                  }
5717              }
5718  
5719          return ((!minDate || date.getTime() >= minDate.getTime()) &&
5720              (!maxDate || date.getTime() <= maxDate.getTime()) &&
5721              (!minYear || date.getFullYear() >= minYear) &&
5722              (!maxYear || date.getFullYear() <= maxYear));
5723      },
5724  
5725      /* Provide the configuration settings for formatting/parsing. */
5726      _getFormatConfig: function(inst) {
5727          var shortYearCutoff = this._get(inst, "shortYearCutoff");
5728          shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff :
5729              new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
5730          return {shortYearCutoff: shortYearCutoff,
5731              dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"),
5732              monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")};
5733      },
5734  
5735      /* Format the given date for display. */
5736      _formatDate: function(inst, day, month, year) {
5737          if (!day) {
5738              inst.currentDay = inst.selectedDay;
5739              inst.currentMonth = inst.selectedMonth;
5740              inst.currentYear = inst.selectedYear;
5741          }
5742          var date = (day ? (typeof day === "object" ? day :
5743              this._daylightSavingAdjust(new Date(year, month, day))) :
5744              this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
5745          return this.formatDate(this._get(inst, "dateFormat"), date, this._getFormatConfig(inst));
5746      }
5747  });
5748  
5749  /*
5750   * Bind hover events for datepicker elements.
5751   * Done via delegate so the binding only occurs once in the lifetime of the parent div.
5752   * Global datepicker_instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
5753   */
5754  function datepicker_bindHover(dpDiv) {
5755      var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
5756      return dpDiv.delegate(selector, "mouseout", function() {
5757              $(this).removeClass("ui-state-hover");
5758              if (this.className.indexOf("ui-datepicker-prev") !== -1) {
5759                  $(this).removeClass("ui-datepicker-prev-hover");
5760              }
5761              if (this.className.indexOf("ui-datepicker-next") !== -1) {
5762                  $(this).removeClass("ui-datepicker-next-hover");
5763              }
5764          })
5765          .delegate( selector, "mouseover", datepicker_handleMouseover );
5766  }
5767  
5768  function datepicker_handleMouseover() {
5769      if (!$.datepicker._isDisabledDatepicker( datepicker_instActive.inline? datepicker_instActive.dpDiv.parent()[0] : datepicker_instActive.input[0])) {
5770          $(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover");
5771          $(this).addClass("ui-state-hover");
5772          if (this.className.indexOf("ui-datepicker-prev") !== -1) {
5773              $(this).addClass("ui-datepicker-prev-hover");
5774          }
5775          if (this.className.indexOf("ui-datepicker-next") !== -1) {
5776              $(this).addClass("ui-datepicker-next-hover");
5777          }
5778      }
5779  }
5780  
5781  /* jQuery extend now ignores nulls! */
5782  function datepicker_extendRemove(target, props) {
5783      $.extend(target, props);
5784      for (var name in props) {
5785          if (props[name] == null) {
5786              target[name] = props[name];
5787          }
5788      }
5789      return target;
5790  }
5791  
5792  /* Invoke the datepicker functionality.
5793     @param  options  string - a command, optionally followed by additional parameters or
5794                      Object - settings for attaching new datepicker functionality
5795     @return  jQuery object */
5796  $.fn.datepicker = function(options){
5797  
5798      /* Verify an empty collection wasn't passed - Fixes #6976 */
5799      if ( !this.length ) {
5800          return this;
5801      }
5802  
5803      /* Initialise the date picker. */
5804      if (!$.datepicker.initialized) {
5805          $(document).mousedown($.datepicker._checkExternalClick);
5806          $.datepicker.initialized = true;
5807      }
5808  
5809      /* Append datepicker main container to body if not exist. */
5810      if ($("#"+$.datepicker._mainDivId).length === 0) {
5811          $("body").append($.datepicker.dpDiv);
5812      }
5813  
5814      var otherArgs = Array.prototype.slice.call(arguments, 1);
5815      if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) {
5816          return $.datepicker["_" + options + "Datepicker"].
5817              apply($.datepicker, [this[0]].concat(otherArgs));
5818      }
5819      if (options === "option" && arguments.length === 2 && typeof arguments[1] === "string") {
5820          return $.datepicker["_" + options + "Datepicker"].
5821              apply($.datepicker, [this[0]].concat(otherArgs));
5822      }
5823      return this.each(function() {
5824          typeof options === "string" ?
5825              $.datepicker["_" + options + "Datepicker"].
5826                  apply($.datepicker, [this].concat(otherArgs)) :
5827              $.datepicker._attachDatepicker(this, options);
5828      });
5829  };
5830  
5831  $.datepicker = new Datepicker(); // singleton instance
5832  $.datepicker.initialized = false;
5833  $.datepicker.uuid = new Date().getTime();
5834  $.datepicker.version = "1.11.4";
5835  
5836  var datepicker = $.datepicker;
5837  
5838  
5839  /*!
5840   * jQuery UI Draggable 1.11.4
5841   * http://jqueryui.com
5842   *
5843   * Copyright jQuery Foundation and other contributors
5844   * Released under the MIT license.
5845   * http://jquery.org/license
5846   *
5847   * http://api.jqueryui.com/draggable/
5848   */
5849  
5850  
5851  $.widget("ui.draggable", $.ui.mouse, {
5852      version: "1.11.4",
5853      widgetEventPrefix: "drag",
5854      options: {
5855          addClasses: true,
5856          appendTo: "parent",
5857          axis: false,
5858          connectToSortable: false,
5859          containment: false,
5860          cursor: "auto",
5861          cursorAt: false,
5862          grid: false,
5863          handle: false,
5864          helper: "original",
5865          iframeFix: false,
5866          opacity: false,
5867          refreshPositions: false,
5868          revert: false,
5869          revertDuration: 500,
5870          scope: "default",
5871          scroll: true,
5872          scrollSensitivity: 20,
5873          scrollSpeed: 20,
5874          snap: false,
5875          snapMode: "both",
5876          snapTolerance: 20,
5877          stack: false,
5878          zIndex: false,
5879  
5880          // callbacks
5881          drag: null,
5882          start: null,
5883          stop: null
5884      },
5885      _create: function() {
5886  
5887          if ( this.options.helper === "original" ) {
5888              this._setPositionRelative();
5889          }
5890          if (this.options.addClasses){
5891              this.element.addClass("ui-draggable");
5892          }
5893          if (this.options.disabled){
5894              this.element.addClass("ui-draggable-disabled");
5895          }
5896          this._setHandleClassName();
5897  
5898          this._mouseInit();
5899      },
5900  
5901      _setOption: function( key, value ) {
5902          this._super( key, value );
5903          if ( key === "handle" ) {
5904              this._removeHandleClassName();
5905              this._setHandleClassName();
5906          }
5907      },
5908  
5909      _destroy: function() {
5910          if ( ( this.helper || this.element ).is( ".ui-draggable-dragging" ) ) {
5911              this.destroyOnClear = true;
5912              return;
5913          }
5914          this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
5915          this._removeHandleClassName();
5916          this._mouseDestroy();
5917      },
5918  
5919      _mouseCapture: function(event) {
5920          var o = this.options;
5921  
5922          this._blurActiveElement( event );
5923  
5924          // among others, prevent a drag on a resizable-handle
5925          if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
5926              return false;
5927          }
5928  
5929          //Quit if we're not on a valid handle
5930          this.handle = this._getHandle(event);
5931          if (!this.handle) {
5932              return false;
5933          }
5934  
5935          this._blockFrames( o.iframeFix === true ? "iframe" : o.iframeFix );
5936  
5937          return true;
5938  
5939      },
5940  
5941      _blockFrames: function( selector ) {
5942          this.iframeBlocks = this.document.find( selector ).map(function() {
5943              var iframe = $( this );
5944  
5945              return $( "<div>" )
5946                  .css( "position", "absolute" )
5947                  .appendTo( iframe.parent() )
5948                  .outerWidth( iframe.outerWidth() )
5949                  .outerHeight( iframe.outerHeight() )
5950                  .offset( iframe.offset() )[ 0 ];
5951          });
5952      },
5953  
5954      _unblockFrames: function() {
5955          if ( this.iframeBlocks ) {
5956              this.iframeBlocks.remove();
5957              delete this.iframeBlocks;
5958          }
5959      },
5960  
5961      _blurActiveElement: function( event ) {
5962          var document = this.document[ 0 ];
5963  
5964          // Only need to blur if the event occurred on the draggable itself, see #10527
5965          if ( !this.handleElement.is( event.target ) ) {
5966              return;
5967          }
5968  
5969          // support: IE9
5970          // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
5971          try {
5972  
5973              // Support: IE9, IE10
5974              // If the <body> is blurred, IE will switch windows, see #9520
5975              if ( document.activeElement && document.activeElement.nodeName.toLowerCase() !== "body" ) {
5976  
5977                  // Blur any element that currently has focus, see #4261
5978                  $( document.activeElement ).blur();
5979              }
5980          } catch ( error ) {}
5981      },
5982  
5983      _mouseStart: function(event) {
5984  
5985          var o = this.options;
5986  
5987          //Create and append the visible helper
5988          this.helper = this._createHelper(event);
5989  
5990          this.helper.addClass("ui-draggable-dragging");
5991  
5992          //Cache the helper size
5993          this._cacheHelperProportions();
5994  
5995          //If ddmanager is used for droppables, set the global draggable
5996          if ($.ui.ddmanager) {
5997              $.ui.ddmanager.current = this;
5998          }
5999  
6000          /*
6001           * - Position generation -
6002           * This block generates everything position related - it's the core of draggables.
6003           */
6004  
6005          //Cache the margins of the original element
6006          this._cacheMargins();
6007  
6008          //Store the helper's css position
6009          this.cssPosition = this.helper.css( "position" );
6010          this.scrollParent = this.helper.scrollParent( true );
6011          this.offsetParent = this.helper.offsetParent();
6012          this.hasFixedAncestor = this.helper.parents().filter(function() {
6013                  return $( this ).css( "position" ) === "fixed";
6014              }).length > 0;
6015  
6016          //The element's absolute position on the page minus margins
6017          this.positionAbs = this.element.offset();
6018          this._refreshOffsets( event );
6019  
6020          //Generate the original position
6021          this.originalPosition = this.position = this._generatePosition( event, false );
6022          this.originalPageX = event.pageX;
6023          this.originalPageY = event.pageY;
6024  
6025          //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
6026          (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
6027  
6028          //Set a containment if given in the options
6029          this._setContainment();
6030  
6031          //Trigger event + callbacks
6032          if (this._trigger("start", event) === false) {
6033              this._clear();
6034              return false;
6035          }
6036  
6037          //Recache the helper size
6038          this._cacheHelperProportions();
6039  
6040          //Prepare the droppable offsets
6041          if ($.ui.ddmanager && !o.dropBehaviour) {
6042              $.ui.ddmanager.prepareOffsets(this, event);
6043          }
6044  
6045          // Reset helper's right/bottom css if they're set and set explicit width/height instead
6046          // as this prevents resizing of elements with right/bottom set (see #7772)
6047          this._normalizeRightBottom();
6048  
6049          this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
6050  
6051          //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
6052          if ( $.ui.ddmanager ) {
6053              $.ui.ddmanager.dragStart(this, event);
6054          }
6055  
6056          return true;
6057      },
6058  
6059      _refreshOffsets: function( event ) {
6060          this.offset = {
6061              top: this.positionAbs.top - this.margins.top,
6062              left: this.positionAbs.left - this.margins.left,
6063              scroll: false,
6064              parent: this._getParentOffset(),
6065              relative: this._getRelativeOffset()
6066          };
6067  
6068          this.offset.click = {
6069              left: event.pageX - this.offset.left,
6070              top: event.pageY - this.offset.top
6071          };
6072      },
6073  
6074      _mouseDrag: function(event, noPropagation) {
6075          // reset any necessary cached properties (see #5009)
6076          if ( this.hasFixedAncestor ) {
6077              this.offset.parent = this._getParentOffset();
6078          }
6079  
6080          //Compute the helpers position
6081          this.position = this._generatePosition( event, true );
6082          this.positionAbs = this._convertPositionTo("absolute");
6083  
6084          //Call plugins and callbacks and use the resulting position if something is returned
6085          if (!noPropagation) {
6086              var ui = this._uiHash();
6087              if (this._trigger("drag", event, ui) === false) {
6088                  this._mouseUp({});
6089                  return false;
6090              }
6091              this.position = ui.position;
6092          }
6093  
6094          this.helper[ 0 ].style.left = this.position.left + "px";
6095          this.helper[ 0 ].style.top = this.position.top + "px";
6096  
6097          if ($.ui.ddmanager) {
6098              $.ui.ddmanager.drag(this, event);
6099          }
6100  
6101          return false;
6102      },
6103  
6104      _mouseStop: function(event) {
6105  
6106          //If we are using droppables, inform the manager about the drop
6107          var that = this,
6108              dropped = false;
6109          if ($.ui.ddmanager && !this.options.dropBehaviour) {
6110              dropped = $.ui.ddmanager.drop(this, event);
6111          }
6112  
6113          //if a drop comes from outside (a sortable)
6114          if (this.dropped) {
6115              dropped = this.dropped;
6116              this.dropped = false;
6117          }
6118  
6119          if ((this.options.revert === "invalid" && !dropped) || (this.options.revert === "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
6120              $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
6121                  if (that._trigger("stop", event) !== false) {
6122                      that._clear();
6123                  }
6124              });
6125          } else {
6126              if (this._trigger("stop", event) !== false) {
6127                  this._clear();
6128              }
6129          }
6130  
6131          return false;
6132      },
6133  
6134      _mouseUp: function( event ) {
6135          this._unblockFrames();
6136  
6137          //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
6138          if ( $.ui.ddmanager ) {
6139              $.ui.ddmanager.dragStop(this, event);
6140          }
6141  
6142          // Only need to focus if the event occurred on the draggable itself, see #10527
6143          if ( this.handleElement.is( event.target ) ) {
6144              // The interaction is over; whether or not the click resulted in a drag, focus the element
6145              this.element.focus();
6146          }
6147  
6148          return $.ui.mouse.prototype._mouseUp.call(this, event);
6149      },
6150  
6151      cancel: function() {
6152  
6153          if (this.helper.is(".ui-draggable-dragging")) {
6154              this._mouseUp({});
6155          } else {
6156              this._clear();
6157          }
6158  
6159          return this;
6160  
6161      },
6162  
6163      _getHandle: function(event) {
6164          return this.options.handle ?
6165              !!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
6166              true;
6167      },
6168  
6169      _setHandleClassName: function() {
6170          this.handleElement = this.options.handle ?
6171              this.element.find( this.options.handle ) : this.element;
6172          this.handleElement.addClass( "ui-draggable-handle" );
6173      },
6174  
6175      _removeHandleClassName: function() {
6176          this.handleElement.removeClass( "ui-draggable-handle" );
6177      },
6178  
6179      _createHelper: function(event) {
6180  
6181          var o = this.options,
6182              helperIsFunction = $.isFunction( o.helper ),
6183              helper = helperIsFunction ?
6184                  $( o.helper.apply( this.element[ 0 ], [ event ] ) ) :
6185                  ( o.helper === "clone" ?
6186                      this.element.clone().removeAttr( "id" ) :
6187                      this.element );
6188  
6189          if (!helper.parents("body").length) {
6190              helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
6191          }
6192  
6193          // http://bugs.jqueryui.com/ticket/9446
6194          // a helper function can return the original element
6195          // which wouldn't have been set to relative in _create
6196          if ( helperIsFunction && helper[ 0 ] === this.element[ 0 ] ) {
6197              this._setPositionRelative();
6198          }
6199  
6200          if (helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
6201              helper.css("position", "absolute");
6202          }
6203  
6204          return helper;
6205  
6206      },
6207  
6208      _setPositionRelative: function() {
6209          if ( !( /^(?:r|a|f)/ ).test( this.element.css( "position" ) ) ) {
6210              this.element[ 0 ].style.position = "relative";
6211          }
6212      },
6213  
6214      _adjustOffsetFromHelper: function(obj) {
6215          if (typeof obj === "string") {
6216              obj = obj.split(" ");
6217          }
6218          if ($.isArray(obj)) {
6219              obj = { left: +obj[0], top: +obj[1] || 0 };
6220          }
6221          if ("left" in obj) {
6222              this.offset.click.left = obj.left + this.margins.left;
6223          }
6224          if ("right" in obj) {
6225              this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
6226          }
6227          if ("top" in obj) {
6228              this.offset.click.top = obj.top + this.margins.top;
6229          }
6230          if ("bottom" in obj) {
6231              this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
6232          }
6233      },
6234  
6235      _isRootNode: function( element ) {
6236          return ( /(html|body)/i ).test( element.tagName ) || element === this.document[ 0 ];
6237      },
6238  
6239      _getParentOffset: function() {
6240  
6241          //Get the offsetParent and cache its position
6242          var po = this.offsetParent.offset(),
6243              document = this.document[ 0 ];
6244  
6245          // This is a special case where we need to modify a offset calculated on start, since the following happened:
6246          // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
6247          // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
6248          //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
6249          if (this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
6250              po.left += this.scrollParent.scrollLeft();
6251              po.top += this.scrollParent.scrollTop();
6252          }
6253  
6254          if ( this._isRootNode( this.offsetParent[ 0 ] ) ) {
6255              po = { top: 0, left: 0 };
6256          }
6257  
6258          return {
6259              top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) || 0),
6260              left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) || 0)
6261          };
6262  
6263      },
6264  
6265      _getRelativeOffset: function() {
6266          if ( this.cssPosition !== "relative" ) {
6267              return { top: 0, left: 0 };
6268          }
6269  
6270          var p = this.element.position(),
6271              scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
6272  
6273          return {
6274              top: p.top - ( parseInt(this.helper.css( "top" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollTop() : 0 ),
6275              left: p.left - ( parseInt(this.helper.css( "left" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollLeft() : 0 )
6276          };
6277  
6278      },
6279  
6280      _cacheMargins: function() {
6281          this.margins = {
6282              left: (parseInt(this.element.css("marginLeft"), 10) || 0),
6283              top: (parseInt(this.element.css("marginTop"), 10) || 0),
6284              right: (parseInt(this.element.css("marginRight"), 10) || 0),
6285              bottom: (parseInt(this.element.css("marginBottom"), 10) || 0)
6286          };
6287      },
6288  
6289      _cacheHelperProportions: function() {
6290          this.helperProportions = {
6291              width: this.helper.outerWidth(),
6292              height: this.helper.outerHeight()
6293          };
6294      },
6295  
6296      _setContainment: function() {
6297  
6298          var isUserScrollable, c, ce,
6299              o = this.options,
6300              document = this.document[ 0 ];
6301  
6302          this.relativeContainer = null;
6303  
6304          if ( !o.containment ) {
6305              this.containment = null;
6306              return;
6307          }
6308  
6309          if ( o.containment === "window" ) {
6310              this.containment = [
6311                  $( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
6312                  $( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
6313                  $( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
6314                  $( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
6315              ];
6316              return;
6317          }
6318  
6319          if ( o.containment === "document") {
6320              this.containment = [
6321                  0,
6322                  0,
6323                  $( document ).width() - this.helperProportions.width - this.margins.left,
6324                  ( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
6325              ];
6326              return;
6327          }
6328  
6329          if ( o.containment.constructor === Array ) {
6330              this.containment = o.containment;
6331              return;
6332          }
6333  
6334          if ( o.containment === "parent" ) {
6335              o.containment = this.helper[ 0 ].parentNode;
6336          }
6337  
6338          c = $( o.containment );
6339          ce = c[ 0 ];
6340  
6341          if ( !ce ) {
6342              return;
6343          }
6344  
6345          isUserScrollable = /(scroll|auto)/.test( c.css( "overflow" ) );
6346  
6347          this.containment = [
6348              ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
6349              ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ),
6350              ( isUserScrollable ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) -
6351                  ( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) -
6352                  ( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) -
6353                  this.helperProportions.width -
6354                  this.margins.left -
6355                  this.margins.right,
6356              ( isUserScrollable ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) -
6357                  ( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) -
6358                  ( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) -
6359                  this.helperProportions.height -
6360                  this.margins.top -
6361                  this.margins.bottom
6362          ];
6363          this.relativeContainer = c;
6364      },
6365  
6366      _convertPositionTo: function(d, pos) {
6367  
6368          if (!pos) {
6369              pos = this.position;
6370          }
6371  
6372          var mod = d === "absolute" ? 1 : -1,
6373              scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
6374  
6375          return {
6376              top: (
6377                  pos.top    +                                                                // The absolute mouse position
6378                  this.offset.relative.top * mod +                                        // Only for relative positioned nodes: Relative offset from element to offset parent
6379                  this.offset.parent.top * mod -                                        // The offsetParent's offset without borders (offset + border)
6380                  ( ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) ) * mod)
6381              ),
6382              left: (
6383                  pos.left +                                                                // The absolute mouse position
6384                  this.offset.relative.left * mod +                                        // Only for relative positioned nodes: Relative offset from element to offset parent
6385                  this.offset.parent.left * mod    -                                        // The offsetParent's offset without borders (offset + border)
6386                  ( ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) ) * mod)
6387              )
6388          };
6389  
6390      },
6391  
6392      _generatePosition: function( event, constrainPosition ) {
6393  
6394          var containment, co, top, left,
6395              o = this.options,
6396              scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] ),
6397              pageX = event.pageX,
6398              pageY = event.pageY;
6399  
6400          // Cache the scroll
6401          if ( !scrollIsRootNode || !this.offset.scroll ) {
6402              this.offset.scroll = {
6403                  top: this.scrollParent.scrollTop(),
6404                  left: this.scrollParent.scrollLeft()
6405              };
6406          }
6407  
6408          /*
6409           * - Position constraining -
6410           * Constrain the position to a mix of grid, containment.
6411           */
6412  
6413          // If we are not dragging yet, we won't check for options
6414          if ( constrainPosition ) {
6415              if ( this.containment ) {
6416                  if ( this.relativeContainer ){
6417                      co = this.relativeContainer.offset();
6418                      containment = [
6419                          this.containment[ 0 ] + co.left,
6420                          this.containment[ 1 ] + co.top,
6421                          this.containment[ 2 ] + co.left,
6422                          this.containment[ 3 ] + co.top
6423                      ];
6424                  } else {
6425                      containment = this.containment;
6426                  }
6427  
6428                  if (event.pageX - this.offset.click.left < containment[0]) {
6429                      pageX = containment[0] + this.offset.click.left;
6430                  }
6431                  if (event.pageY - this.offset.click.top < containment[1]) {
6432                      pageY = containment[1] + this.offset.click.top;
6433                  }
6434                  if (event.pageX - this.offset.click.left > containment[2]) {
6435                      pageX = containment[2] + this.offset.click.left;
6436                  }
6437                  if (event.pageY - this.offset.click.top > containment[3]) {
6438                      pageY = containment[3] + this.offset.click.top;
6439                  }
6440              }
6441  
6442              if (o.grid) {
6443                  //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
6444                  top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
6445                  pageY = containment ? ((top - this.offset.click.top >= containment[1] || top - this.offset.click.top > containment[3]) ? top : ((top - this.offset.click.top >= containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
6446  
6447                  left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
6448                  pageX = containment ? ((left - this.offset.click.left >= containment[0] || left - this.offset.click.left > containment[2]) ? left : ((left - this.offset.click.left >= containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
6449              }
6450  
6451              if ( o.axis === "y" ) {
6452                  pageX = this.originalPageX;
6453              }
6454  
6455              if ( o.axis === "x" ) {
6456                  pageY = this.originalPageY;
6457              }
6458          }
6459  
6460          return {
6461              top: (
6462                  pageY -                                                                    // The absolute mouse position
6463                  this.offset.click.top    -                                                // Click offset (relative to the element)
6464                  this.offset.relative.top -                                                // Only for relative positioned nodes: Relative offset from element to offset parent
6465                  this.offset.parent.top +                                                // The offsetParent's offset without borders (offset + border)
6466                  ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) )
6467              ),
6468              left: (
6469                  pageX -                                                                    // The absolute mouse position
6470                  this.offset.click.left -                                                // Click offset (relative to the element)
6471                  this.offset.relative.left -                                                // Only for relative positioned nodes: Relative offset from element to offset parent
6472                  this.offset.parent.left +                                                // The offsetParent's offset without borders (offset + border)
6473                  ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) )
6474              )
6475          };
6476  
6477      },
6478  
6479      _clear: function() {
6480          this.helper.removeClass("ui-draggable-dragging");
6481          if (this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
6482              this.helper.remove();
6483          }
6484          this.helper = null;
6485          this.cancelHelperRemoval = false;
6486          if ( this.destroyOnClear ) {
6487              this.destroy();
6488          }
6489      },
6490  
6491      _normalizeRightBottom: function() {
6492          if ( this.options.axis !== "y" && this.helper.css( "right" ) !== "auto" ) {
6493              this.helper.width( this.helper.width() );
6494              this.helper.css( "right", "auto" );
6495          }
6496          if ( this.options.axis !== "x" && this.helper.css( "bottom" ) !== "auto" ) {
6497              this.helper.height( this.helper.height() );
6498              this.helper.css( "bottom", "auto" );
6499          }
6500      },
6501  
6502      // From now on bulk stuff - mainly helpers
6503  
6504      _trigger: function( type, event, ui ) {
6505          ui = ui || this._uiHash();
6506          $.ui.plugin.call( this, type, [ event, ui, this ], true );
6507  
6508          // Absolute position and offset (see #6884 ) have to be recalculated after plugins
6509          if ( /^(drag|start|stop)/.test( type ) ) {
6510              this.positionAbs = this._convertPositionTo( "absolute" );
6511              ui.offset = this.positionAbs;
6512          }
6513          return $.Widget.prototype._trigger.call( this, type, event, ui );
6514      },
6515  
6516      plugins: {},
6517  
6518      _uiHash: function() {
6519          return {
6520              helper: this.helper,
6521              position: this.position,
6522              originalPosition: this.originalPosition,
6523              offset: this.positionAbs
6524          };
6525      }
6526  
6527  });
6528  
6529  $.ui.plugin.add( "draggable", "connectToSortable", {
6530      start: function( event, ui, draggable ) {
6531          var uiSortable = $.extend( {}, ui, {
6532              item: draggable.element
6533          });
6534  
6535          draggable.sortables = [];
6536          $( draggable.options.connectToSortable ).each(function() {
6537              var sortable = $( this ).sortable( "instance" );
6538  
6539              if ( sortable && !sortable.options.disabled ) {
6540                  draggable.sortables.push( sortable );
6541  
6542                  // refreshPositions is called at drag start to refresh the containerCache
6543                  // which is used in drag. This ensures it's initialized and synchronized
6544                  // with any changes that might have happened on the page since initialization.
6545                  sortable.refreshPositions();
6546                  sortable._trigger("activate", event, uiSortable);
6547              }
6548          });
6549      },
6550      stop: function( event, ui, draggable ) {
6551          var uiSortable = $.extend( {}, ui, {
6552              item: draggable.element
6553          });
6554  
6555          draggable.cancelHelperRemoval = false;
6556  
6557          $.each( draggable.sortables, function() {
6558              var sortable = this;
6559  
6560              if ( sortable.isOver ) {
6561                  sortable.isOver = 0;
6562  
6563                  // Allow this sortable to handle removing the helper
6564                  draggable.cancelHelperRemoval = true;
6565                  sortable.cancelHelperRemoval = false;
6566  
6567                  // Use _storedCSS To restore properties in the sortable,
6568                  // as this also handles revert (#9675) since the draggable
6569                  // may have modified them in unexpected ways (#8809)
6570                  sortable._storedCSS = {
6571                      position: sortable.placeholder.css( "position" ),
6572                      top: sortable.placeholder.css( "top" ),
6573                      left: sortable.placeholder.css( "left" )
6574                  };
6575  
6576                  sortable._mouseStop(event);
6577  
6578                  // Once drag has ended, the sortable should return to using
6579                  // its original helper, not the shared helper from draggable
6580                  sortable.options.helper = sortable.options._helper;
6581              } else {
6582                  // Prevent this Sortable from removing the helper.
6583                  // However, don't set the draggable to remove the helper
6584                  // either as another connected Sortable may yet handle the removal.
6585                  sortable.cancelHelperRemoval = true;
6586  
6587                  sortable._trigger( "deactivate", event, uiSortable );
6588              }
6589          });
6590      },
6591      drag: function( event, ui, draggable ) {
6592          $.each( draggable.sortables, function() {
6593              var innermostIntersecting = false,
6594                  sortable = this;
6595  
6596              // Copy over variables that sortable's _intersectsWith uses
6597              sortable.positionAbs = draggable.positionAbs;
6598              sortable.helperProportions = draggable.helperProportions;
6599              sortable.offset.click = draggable.offset.click;
6600  
6601              if ( sortable._intersectsWith( sortable.containerCache ) ) {
6602                  innermostIntersecting = true;
6603  
6604                  $.each( draggable.sortables, function() {
6605                      // Copy over variables that sortable's _intersectsWith uses
6606                      this.positionAbs = draggable.positionAbs;
6607                      this.helperProportions = draggable.helperProportions;
6608                      this.offset.click = draggable.offset.click;
6609  
6610                      if ( this !== sortable &&
6611                              this._intersectsWith( this.containerCache ) &&
6612                              $.contains( sortable.element[ 0 ], this.element[ 0 ] ) ) {
6613                          innermostIntersecting = false;
6614                      }
6615  
6616                      return innermostIntersecting;
6617                  });
6618              }
6619  
6620              if ( innermostIntersecting ) {
6621                  // If it intersects, we use a little isOver variable and set it once,
6622                  // so that the move-in stuff gets fired only once.
6623                  if ( !sortable.isOver ) {
6624                      sortable.isOver = 1;
6625  
6626                      // Store draggable's parent in case we need to reappend to it later.
6627                      draggable._parent = ui.helper.parent();
6628  
6629                      sortable.currentItem = ui.helper
6630                          .appendTo( sortable.element )
6631                          .data( "ui-sortable-item", true );
6632  
6633                      // Store helper option to later restore it
6634                      sortable.options._helper = sortable.options.helper;
6635  
6636                      sortable.options.helper = function() {
6637                          return ui.helper[ 0 ];
6638                      };
6639  
6640                      // Fire the start events of the sortable with our passed browser event,
6641                      // and our own helper (so it doesn't create a new one)
6642                      event.target = sortable.currentItem[ 0 ];
6643                      sortable._mouseCapture( event, true );
6644                      sortable._mouseStart( event, true, true );
6645  
6646                      // Because the browser event is way off the new appended portlet,
6647                      // modify necessary variables to reflect the changes
6648                      sortable.offset.click.top = draggable.offset.click.top;
6649                      sortable.offset.click.left = draggable.offset.click.left;
6650                      sortable.offset.parent.left -= draggable.offset.parent.left -
6651                          sortable.offset.parent.left;
6652                      sortable.offset.parent.top -= draggable.offset.parent.top -
6653                          sortable.offset.parent.top;
6654  
6655                      draggable._trigger( "toSortable", event );
6656  
6657                      // Inform draggable that the helper is in a valid drop zone,
6658                      // used solely in the revert option to handle "valid/invalid".
6659                      draggable.dropped = sortable.element;
6660  
6661                      // Need to refreshPositions of all sortables in the case that
6662                      // adding to one sortable changes the location of the other sortables (#9675)
6663                      $.each( draggable.sortables, function() {
6664                          this.refreshPositions();
6665                      });
6666  
6667                      // hack so receive/update callbacks work (mostly)
6668                      draggable.currentItem = draggable.element;
6669                      sortable.fromOutside = draggable;
6670                  }
6671  
6672                  if ( sortable.currentItem ) {
6673                      sortable._mouseDrag( event );
6674                      // Copy the sortable's position because the draggable's can potentially reflect
6675                      // a relative position, while sortable is always absolute, which the dragged
6676                      // element has now become. (#8809)
6677                      ui.position = sortable.position;
6678                  }
6679              } else {
6680                  // If it doesn't intersect with the sortable, and it intersected before,
6681                  // we fake the drag stop of the sortable, but make sure it doesn't remove
6682                  // the helper by using cancelHelperRemoval.
6683                  if ( sortable.isOver ) {
6684  
6685                      sortable.isOver = 0;
6686                      sortable.cancelHelperRemoval = true;
6687  
6688                      // Calling sortable's mouseStop would trigger a revert,
6689                      // so revert must be temporarily false until after mouseStop is called.
6690                      sortable.options._revert = sortable.options.revert;
6691                      sortable.options.revert = false;
6692  
6693                      sortable._trigger( "out", event, sortable._uiHash( sortable ) );
6694                      sortable._mouseStop( event, true );
6695  
6696                      // restore sortable behaviors that were modfied
6697                      // when the draggable entered the sortable area (#9481)
6698                      sortable.options.revert = sortable.options._revert;
6699                      sortable.options.helper = sortable.options._helper;
6700  
6701                      if ( sortable.placeholder ) {
6702                          sortable.placeholder.remove();
6703                      }
6704  
6705                      // Restore and recalculate the draggable's offset considering the sortable
6706                      // may have modified them in unexpected ways. (#8809, #10669)
6707                      ui.helper.appendTo( draggable._parent );
6708                      draggable._refreshOffsets( event );
6709                      ui.position = draggable._generatePosition( event, true );
6710  
6711                      draggable._trigger( "fromSortable", event );
6712  
6713                      // Inform draggable that the helper is no longer in a valid drop zone
6714                      draggable.dropped = false;
6715  
6716                      // Need to refreshPositions of all sortables just in case removing
6717                      // from one sortable changes the location of other sortables (#9675)
6718                      $.each( draggable.sortables, function() {
6719                          this.refreshPositions();
6720                      });
6721                  }
6722              }
6723          });
6724      }
6725  });
6726  
6727  $.ui.plugin.add("draggable", "cursor", {
6728      start: function( event, ui, instance ) {
6729          var t = $( "body" ),
6730              o = instance.options;
6731  
6732          if (t.css("cursor")) {
6733              o._cursor = t.css("cursor");
6734          }
6735          t.css("cursor", o.cursor);
6736      },
6737      stop: function( event, ui, instance ) {
6738          var o = instance.options;
6739          if (o._cursor) {
6740              $("body").css("cursor", o._cursor);
6741          }
6742      }
6743  });
6744  
6745  $.ui.plugin.add("draggable", "opacity", {
6746      start: function( event, ui, instance ) {
6747          var t = $( ui.helper ),
6748              o = instance.options;
6749          if (t.css("opacity")) {
6750              o._opacity = t.css("opacity");
6751          }
6752          t.css("opacity", o.opacity);
6753      },
6754      stop: function( event, ui, instance ) {
6755          var o = instance.options;
6756          if (o._opacity) {
6757              $(ui.helper).css("opacity", o._opacity);
6758          }
6759      }
6760  });
6761  
6762  $.ui.plugin.add("draggable", "scroll", {
6763      start: function( event, ui, i ) {
6764          if ( !i.scrollParentNotHidden ) {
6765              i.scrollParentNotHidden = i.helper.scrollParent( false );
6766          }
6767  
6768          if ( i.scrollParentNotHidden[ 0 ] !== i.document[ 0 ] && i.scrollParentNotHidden[ 0 ].tagName !== "HTML" ) {
6769              i.overflowOffset = i.scrollParentNotHidden.offset();
6770          }
6771      },
6772      drag: function( event, ui, i  ) {
6773  
6774          var o = i.options,
6775              scrolled = false,
6776              scrollParent = i.scrollParentNotHidden[ 0 ],
6777              document = i.document[ 0 ];
6778  
6779          if ( scrollParent !== document && scrollParent.tagName !== "HTML" ) {
6780              if ( !o.axis || o.axis !== "x" ) {
6781                  if ( ( i.overflowOffset.top + scrollParent.offsetHeight ) - event.pageY < o.scrollSensitivity ) {
6782                      scrollParent.scrollTop = scrolled = scrollParent.scrollTop + o.scrollSpeed;
6783                  } else if ( event.pageY - i.overflowOffset.top < o.scrollSensitivity ) {
6784                      scrollParent.scrollTop = scrolled = scrollParent.scrollTop - o.scrollSpeed;
6785                  }
6786              }
6787  
6788              if ( !o.axis || o.axis !== "y" ) {
6789                  if ( ( i.overflowOffset.left + scrollParent.offsetWidth ) - event.pageX < o.scrollSensitivity ) {
6790                      scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft + o.scrollSpeed;
6791                  } else if ( event.pageX - i.overflowOffset.left < o.scrollSensitivity ) {
6792                      scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft - o.scrollSpeed;
6793                  }
6794              }
6795  
6796          } else {
6797  
6798              if (!o.axis || o.axis !== "x") {
6799                  if (event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
6800                      scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
6801                  } else if ($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
6802                      scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
6803                  }
6804              }
6805  
6806              if (!o.axis || o.axis !== "y") {
6807                  if (event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
6808                      scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
6809                  } else if ($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
6810                      scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
6811                  }
6812              }
6813  
6814          }
6815  
6816          if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
6817              $.ui.ddmanager.prepareOffsets(i, event);
6818          }
6819  
6820      }
6821  });
6822  
6823  $.ui.plugin.add("draggable", "snap", {
6824      start: function( event, ui, i ) {
6825  
6826          var o = i.options;
6827  
6828          i.snapElements = [];
6829  
6830          $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
6831              var $t = $(this),
6832                  $o = $t.offset();
6833              if (this !== i.element[0]) {
6834                  i.snapElements.push({
6835                      item: this,
6836                      width: $t.outerWidth(), height: $t.outerHeight(),
6837                      top: $o.top, left: $o.left
6838                  });
6839              }
6840          });
6841  
6842      },
6843      drag: function( event, ui, inst ) {
6844  
6845          var ts, bs, ls, rs, l, r, t, b, i, first,
6846              o = inst.options,
6847              d = o.snapTolerance,
6848              x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
6849              y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
6850  
6851          for (i = inst.snapElements.length - 1; i >= 0; i--){
6852  
6853              l = inst.snapElements[i].left - inst.margins.left;
6854              r = l + inst.snapElements[i].width;
6855              t = inst.snapElements[i].top - inst.margins.top;
6856              b = t + inst.snapElements[i].height;
6857  
6858              if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
6859                  if (inst.snapElements[i].snapping) {
6860                      (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
6861                  }
6862                  inst.snapElements[i].snapping = false;
6863                  continue;
6864              }
6865  
6866              if (o.snapMode !== "inner") {
6867                  ts = Math.abs(t - y2) <= d;
6868                  bs = Math.abs(b - y1) <= d;
6869                  ls = Math.abs(l - x2) <= d;
6870                  rs = Math.abs(r - x1) <= d;
6871                  if (ts) {
6872                      ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top;
6873                  }
6874                  if (bs) {
6875                      ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top;
6876                  }
6877                  if (ls) {
6878                      ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left;
6879                  }
6880                  if (rs) {
6881                      ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left;
6882                  }
6883              }
6884  
6885              first = (ts || bs || ls || rs);
6886  
6887              if (o.snapMode !== "outer") {
6888                  ts = Math.abs(t - y1) <= d;
6889                  bs = Math.abs(b - y2) <= d;
6890                  ls = Math.abs(l - x1) <= d;
6891                  rs = Math.abs(r - x2) <= d;
6892                  if (ts) {
6893                      ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top;
6894                  }
6895                  if (bs) {
6896                      ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top;
6897                  }
6898                  if (ls) {
6899                      ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left;
6900                  }
6901                  if (rs) {
6902                      ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left;
6903                  }
6904              }
6905  
6906              if (!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
6907                  (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
6908              }
6909              inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
6910  
6911          }
6912  
6913      }
6914  });
6915  
6916  $.ui.plugin.add("draggable", "stack", {
6917      start: function( event, ui, instance ) {
6918          var min,
6919              o = instance.options,
6920              group = $.makeArray($(o.stack)).sort(function(a, b) {
6921                  return (parseInt($(a).css("zIndex"), 10) || 0) - (parseInt($(b).css("zIndex"), 10) || 0);
6922              });
6923  
6924          if (!group.length) { return; }
6925  
6926          min = parseInt($(group[0]).css("zIndex"), 10) || 0;
6927          $(group).each(function(i) {
6928              $(this).css("zIndex", min + i);
6929          });
6930          this.css("zIndex", (min + group.length));
6931      }
6932  });
6933  
6934  $.ui.plugin.add("draggable", "zIndex", {
6935      start: function( event, ui, instance ) {
6936          var t = $( ui.helper ),
6937              o = instance.options;
6938  
6939          if (t.css("zIndex")) {
6940              o._zIndex = t.css("zIndex");
6941          }
6942          t.css("zIndex", o.zIndex);
6943      },
6944      stop: function( event, ui, instance ) {
6945          var o = instance.options;
6946  
6947          if (o._zIndex) {
6948              $(ui.helper).css("zIndex", o._zIndex);
6949          }
6950      }
6951  });
6952  
6953  var draggable = $.ui.draggable;
6954  
6955  
6956  /*!
6957   * jQuery UI Resizable 1.11.4
6958   * http://jqueryui.com
6959   *
6960   * Copyright jQuery Foundation and other contributors
6961   * Released under the MIT license.
6962   * http://jquery.org/license
6963   *
6964   * http://api.jqueryui.com/resizable/
6965   */
6966  
6967  
6968  $.widget("ui.resizable", $.ui.mouse, {
6969      version: "1.11.4",
6970      widgetEventPrefix: "resize",
6971      options: {
6972          alsoResize: false,
6973          animate: false,
6974          animateDuration: "slow",
6975          animateEasing: "swing",
6976          aspectRatio: false,
6977          autoHide: false,
6978          containment: false,
6979          ghost: false,
6980          grid: false,
6981          handles: "e,s,se",
6982          helper: false,
6983          maxHeight: null,
6984          maxWidth: null,
6985          minHeight: 10,
6986          minWidth: 10,
6987          // See #7960
6988          zIndex: 90,
6989  
6990          // callbacks
6991          resize: null,
6992          start: null,
6993          stop: null
6994      },
6995  
6996      _num: function( value ) {
6997          return parseInt( value, 10 ) || 0;
6998      },
6999  
7000      _isNumber: function( value ) {
7001          return !isNaN( parseInt( value, 10 ) );
7002      },
7003  
7004      _hasScroll: function( el, a ) {
7005  
7006          if ( $( el ).css( "overflow" ) === "hidden") {
7007              return false;
7008          }
7009  
7010          var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
7011              has = false;
7012  
7013          if ( el[ scroll ] > 0 ) {
7014              return true;
7015          }
7016  
7017          // TODO: determine which cases actually cause this to happen
7018          // if the element doesn't have the scroll set, see if it's possible to
7019          // set the scroll
7020          el[ scroll ] = 1;
7021          has = ( el[ scroll ] > 0 );
7022          el[ scroll ] = 0;
7023          return has;
7024      },
7025  
7026      _create: function() {
7027  
7028          var n, i, handle, axis, hname,
7029              that = this,
7030              o = this.options;
7031          this.element.addClass("ui-resizable");
7032  
7033          $.extend(this, {
7034              _aspectRatio: !!(o.aspectRatio),
7035              aspectRatio: o.aspectRatio,
7036              originalElement: this.element,
7037              _proportionallyResizeElements: [],
7038              _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
7039          });
7040  
7041          // Wrap the element if it cannot hold child nodes
7042          if (this.element[0].nodeName.match(/^(canvas|textarea|input|select|button|img)$/i)) {
7043  
7044              this.element.wrap(
7045                  $("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
7046                      position: this.element.css("position"),
7047                      width: this.element.outerWidth(),
7048                      height: this.element.outerHeight(),
7049                      top: this.element.css("top"),
7050                      left: this.element.css("left")
7051                  })
7052              );
7053  
7054              this.element = this.element.parent().data(
7055                  "ui-resizable", this.element.resizable( "instance" )
7056              );
7057  
7058              this.elementIsWrapper = true;
7059  
7060              this.element.css({
7061                  marginLeft: this.originalElement.css("marginLeft"),
7062                  marginTop: this.originalElement.css("marginTop"),
7063                  marginRight: this.originalElement.css("marginRight"),
7064                  marginBottom: this.originalElement.css("marginBottom")
7065              });
7066              this.originalElement.css({
7067                  marginLeft: 0,
7068                  marginTop: 0,
7069                  marginRight: 0,
7070                  marginBottom: 0
7071              });
7072              // support: Safari
7073              // Prevent Safari textarea resize
7074              this.originalResizeStyle = this.originalElement.css("resize");
7075              this.originalElement.css("resize", "none");
7076  
7077              this._proportionallyResizeElements.push( this.originalElement.css({
7078                  position: "static",
7079                  zoom: 1,
7080                  display: "block"
7081              }) );
7082  
7083              // support: IE9
7084              // avoid IE jump (hard set the margin)
7085              this.originalElement.css({ margin: this.originalElement.css("margin") });
7086  
7087              this._proportionallyResize();
7088          }
7089  
7090          this.handles = o.handles ||
7091              ( !$(".ui-resizable-handle", this.element).length ?
7092                  "e,s,se" : {
7093                      n: ".ui-resizable-n",
7094                      e: ".ui-resizable-e",
7095                      s: ".ui-resizable-s",
7096                      w: ".ui-resizable-w",
7097                      se: ".ui-resizable-se",
7098                      sw: ".ui-resizable-sw",
7099                      ne: ".ui-resizable-ne",
7100                      nw: ".ui-resizable-nw"
7101                  } );
7102  
7103          this._handles = $();
7104          if ( this.handles.constructor === String ) {
7105  
7106              if ( this.handles === "all") {
7107                  this.handles = "n,e,s,w,se,sw,ne,nw";
7108              }
7109  
7110              n = this.handles.split(",");
7111              this.handles = {};
7112  
7113              for (i = 0; i < n.length; i++) {
7114  
7115                  handle = $.trim(n[i]);
7116                  hname = "ui-resizable-" + handle;
7117                  axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
7118  
7119                  axis.css({ zIndex: o.zIndex });
7120  
7121                  // TODO : What's going on here?
7122                  if ("se" === handle) {
7123                      axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
7124                  }
7125  
7126                  this.handles[handle] = ".ui-resizable-" + handle;
7127                  this.element.append(axis);
7128              }
7129  
7130          }
7131  
7132          this._renderAxis = function(target) {
7133  
7134              var i, axis, padPos, padWrapper;
7135  
7136              target = target || this.element;
7137  
7138              for (i in this.handles) {
7139  
7140                  if (this.handles[i].constructor === String) {
7141                      this.handles[i] = this.element.children( this.handles[ i ] ).first().show();
7142                  } else if ( this.handles[ i ].jquery || this.handles[ i ].nodeType ) {
7143                      this.handles[ i ] = $( this.handles[ i ] );
7144                      this._on( this.handles[ i ], { "mousedown": that._mouseDown });
7145                  }
7146  
7147                  if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/^(textarea|input|select|button)$/i)) {
7148  
7149                      axis = $(this.handles[i], this.element);
7150  
7151                      padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
7152  
7153                      padPos = [ "padding",
7154                          /ne|nw|n/.test(i) ? "Top" :
7155                          /se|sw|s/.test(i) ? "Bottom" :
7156                          /^e$/.test(i) ? "Right" : "Left" ].join("");
7157  
7158                      target.css(padPos, padWrapper);
7159  
7160                      this._proportionallyResize();
7161                  }
7162  
7163                  this._handles = this._handles.add( this.handles[ i ] );
7164              }
7165          };
7166  
7167          // TODO: make renderAxis a prototype function
7168          this._renderAxis(this.element);
7169  
7170          this._handles = this._handles.add( this.element.find( ".ui-resizable-handle" ) );
7171          this._handles.disableSelection();
7172  
7173          this._handles.mouseover(function() {
7174              if (!that.resizing) {
7175                  if (this.className) {
7176                      axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
7177                  }
7178                  that.axis = axis && axis[1] ? axis[1] : "se";
7179              }
7180          });
7181  
7182          if (o.autoHide) {
7183              this._handles.hide();
7184              $(this.element)
7185                  .addClass("ui-resizable-autohide")
7186                  .mouseenter(function() {
7187                      if (o.disabled) {
7188                          return;
7189                      }
7190                      $(this).removeClass("ui-resizable-autohide");
7191                      that._handles.show();
7192                  })
7193                  .mouseleave(function() {
7194                      if (o.disabled) {
7195                          return;
7196                      }
7197                      if (!that.resizing) {
7198                          $(this).addClass("ui-resizable-autohide");
7199                          that._handles.hide();
7200                      }
7201                  });
7202          }
7203  
7204          this._mouseInit();
7205      },
7206  
7207      _destroy: function() {
7208  
7209          this._mouseDestroy();
7210  
7211          var wrapper,
7212              _destroy = function(exp) {
7213                  $(exp)
7214                      .removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
7215                      .removeData("resizable")
7216                      .removeData("ui-resizable")
7217                      .unbind(".resizable")
7218                      .find(".ui-resizable-handle")
7219                          .remove();
7220              };
7221  
7222          // TODO: Unwrap at same DOM position
7223          if (this.elementIsWrapper) {
7224              _destroy(this.element);
7225              wrapper = this.element;
7226              this.originalElement.css({
7227                  position: wrapper.css("position"),
7228                  width: wrapper.outerWidth(),
7229                  height: wrapper.outerHeight(),
7230                  top: wrapper.css("top"),
7231                  left: wrapper.css("left")
7232              }).insertAfter( wrapper );
7233              wrapper.remove();
7234          }
7235  
7236          this.originalElement.css("resize", this.originalResizeStyle);
7237          _destroy(this.originalElement);
7238  
7239          return this;
7240      },
7241  
7242      _mouseCapture: function(event) {
7243          var i, handle,
7244              capture = false;
7245  
7246          for (i in this.handles) {
7247              handle = $(this.handles[i])[0];
7248              if (handle === event.target || $.contains(handle, event.target)) {
7249                  capture = true;
7250              }
7251          }
7252  
7253          return !this.options.disabled && capture;
7254      },
7255  
7256      _mouseStart: function(event) {
7257  
7258          var curleft, curtop, cursor,
7259              o = this.options,
7260              el = this.element;
7261  
7262          this.resizing = true;
7263  
7264          this._renderProxy();
7265  
7266          curleft = this._num(this.helper.css("left"));
7267          curtop = this._num(this.helper.css("top"));
7268  
7269          if (o.containment) {
7270              curleft += $(o.containment).scrollLeft() || 0;
7271              curtop += $(o.containment).scrollTop() || 0;
7272          }
7273  
7274          this.offset = this.helper.offset();
7275          this.position = { left: curleft, top: curtop };
7276  
7277          this.size = this._helper ? {
7278                  width: this.helper.width(),
7279                  height: this.helper.height()
7280              } : {
7281                  width: el.width(),
7282                  height: el.height()
7283              };
7284  
7285          this.originalSize = this._helper ? {
7286                  width: el.outerWidth(),
7287                  height: el.outerHeight()
7288              } : {
7289                  width: el.width(),
7290                  height: el.height()
7291              };
7292  
7293          this.sizeDiff = {
7294              width: el.outerWidth() - el.width(),
7295              height: el.outerHeight() - el.height()
7296          };
7297  
7298          this.originalPosition = { left: curleft, top: curtop };
7299          this.originalMousePosition = { left: event.pageX, top: event.pageY };
7300  
7301          this.aspectRatio = (typeof o.aspectRatio === "number") ?
7302              o.aspectRatio :
7303              ((this.originalSize.width / this.originalSize.height) || 1);
7304  
7305          cursor = $(".ui-resizable-" + this.axis).css("cursor");
7306          $("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
7307  
7308          el.addClass("ui-resizable-resizing");
7309          this._propagate("start", event);
7310          return true;
7311      },
7312  
7313      _mouseDrag: function(event) {
7314  
7315          var data, props,
7316              smp = this.originalMousePosition,
7317              a = this.axis,
7318              dx = (event.pageX - smp.left) || 0,
7319              dy = (event.pageY - smp.top) || 0,
7320              trigger = this._change[a];
7321  
7322          this._updatePrevProperties();
7323  
7324          if (!trigger) {
7325              return false;
7326          }
7327  
7328          data = trigger.apply(this, [ event, dx, dy ]);
7329  
7330          this._updateVirtualBoundaries(event.shiftKey);
7331          if (this._aspectRatio || event.shiftKey) {
7332              data = this._updateRatio(data, event);
7333          }
7334  
7335          data = this._respectSize(data, event);
7336  
7337          this._updateCache(data);
7338  
7339          this._propagate("resize", event);
7340  
7341          props = this._applyChanges();
7342  
7343          if ( !this._helper && this._proportionallyResizeElements.length ) {
7344              this._proportionallyResize();
7345          }
7346  
7347          if ( !$.isEmptyObject( props ) ) {
7348              this._updatePrevProperties();
7349              this._trigger( "resize", event, this.ui() );
7350              this._applyChanges();
7351          }
7352  
7353          return false;
7354      },
7355  
7356      _mouseStop: function(event) {
7357  
7358          this.resizing = false;
7359          var pr, ista, soffseth, soffsetw, s, left, top,
7360              o = this.options, that = this;
7361  
7362          if (this._helper) {
7363  
7364              pr = this._proportionallyResizeElements;
7365              ista = pr.length && (/textarea/i).test(pr[0].nodeName);
7366              soffseth = ista && this._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height;
7367              soffsetw = ista ? 0 : that.sizeDiff.width;
7368  
7369              s = {
7370                  width: (that.helper.width()  - soffsetw),
7371                  height: (that.helper.height() - soffseth)
7372              };
7373              left = (parseInt(that.element.css("left"), 10) +
7374                  (that.position.left - that.originalPosition.left)) || null;
7375              top = (parseInt(that.element.css("top"), 10) +
7376                  (that.position.top - that.originalPosition.top)) || null;
7377  
7378              if (!o.animate) {
7379                  this.element.css($.extend(s, { top: top, left: left }));
7380              }
7381  
7382              that.helper.height(that.size.height);
7383              that.helper.width(that.size.width);
7384  
7385              if (this._helper && !o.animate) {
7386                  this._proportionallyResize();
7387              }
7388          }
7389  
7390          $("body").css("cursor", "auto");
7391  
7392          this.element.removeClass("ui-resizable-resizing");
7393  
7394          this._propagate("stop", event);
7395  
7396          if (this._helper) {
7397              this.helper.remove();
7398          }
7399  
7400          return false;
7401  
7402      },
7403  
7404      _updatePrevProperties: function() {
7405          this.prevPosition = {
7406              top: this.position.top,
7407              left: this.position.left
7408          };
7409          this.prevSize = {
7410              width: this.size.width,
7411              height: this.size.height
7412          };
7413      },
7414  
7415      _applyChanges: function() {
7416          var props = {};
7417  
7418          if ( this.position.top !== this.prevPosition.top ) {
7419              props.top = this.position.top + "px";
7420          }
7421          if ( this.position.left !== this.prevPosition.left ) {
7422              props.left = this.position.left + "px";
7423          }
7424          if ( this.size.width !== this.prevSize.width ) {
7425              props.width = this.size.width + "px";
7426          }
7427          if ( this.size.height !== this.prevSize.height ) {
7428              props.height = this.size.height + "px";
7429          }
7430  
7431          this.helper.css( props );
7432  
7433          return props;
7434      },
7435  
7436      _updateVirtualBoundaries: function(forceAspectRatio) {
7437          var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
7438              o = this.options;
7439  
7440          b = {
7441              minWidth: this._isNumber(o.minWidth) ? o.minWidth : 0,
7442              maxWidth: this._isNumber(o.maxWidth) ? o.maxWidth : Infinity,
7443              minHeight: this._isNumber(o.minHeight) ? o.minHeight : 0,
7444              maxHeight: this._isNumber(o.maxHeight) ? o.maxHeight : Infinity
7445          };
7446  
7447          if (this._aspectRatio || forceAspectRatio) {
7448              pMinWidth = b.minHeight * this.aspectRatio;
7449              pMinHeight = b.minWidth / this.aspectRatio;
7450              pMaxWidth = b.maxHeight * this.aspectRatio;
7451              pMaxHeight = b.maxWidth / this.aspectRatio;
7452  
7453              if (pMinWidth > b.minWidth) {
7454                  b.minWidth = pMinWidth;
7455              }
7456              if (pMinHeight > b.minHeight) {
7457                  b.minHeight = pMinHeight;
7458              }
7459              if (pMaxWidth < b.maxWidth) {
7460                  b.maxWidth = pMaxWidth;
7461              }
7462              if (pMaxHeight < b.maxHeight) {
7463                  b.maxHeight = pMaxHeight;
7464              }
7465          }
7466          this._vBoundaries = b;
7467      },
7468  
7469      _updateCache: function(data) {
7470          this.offset = this.helper.offset();
7471          if (this._isNumber(data.left)) {
7472              this.position.left = data.left;
7473          }
7474          if (this._isNumber(data.top)) {
7475              this.position.top = data.top;
7476          }
7477          if (this._isNumber(data.height)) {
7478              this.size.height = data.height;
7479          }
7480          if (this._isNumber(data.width)) {
7481              this.size.width = data.width;
7482          }
7483      },
7484  
7485      _updateRatio: function( data ) {
7486  
7487          var cpos = this.position,
7488              csize = this.size,
7489              a = this.axis;
7490  
7491          if (this._isNumber(data.height)) {
7492              data.width = (data.height * this.aspectRatio);
7493          } else if (this._isNumber(data.width)) {
7494              data.height = (data.width / this.aspectRatio);
7495          }
7496  
7497          if (a === "sw") {
7498              data.left = cpos.left + (csize.width - data.width);
7499              data.top = null;
7500          }
7501          if (a === "nw") {
7502              data.top = cpos.top + (csize.height - data.height);
7503              data.left = cpos.left + (csize.width - data.width);
7504          }
7505  
7506          return data;
7507      },
7508  
7509      _respectSize: function( data ) {
7510  
7511          var o = this._vBoundaries,
7512              a = this.axis,
7513              ismaxw = this._isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width),
7514              ismaxh = this._isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
7515              isminw = this._isNumber(data.width) && o.minWidth && (o.minWidth > data.width),
7516              isminh = this._isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
7517              dw = this.originalPosition.left + this.originalSize.width,
7518              dh = this.position.top + this.size.height,
7519              cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
7520          if (isminw) {
7521              data.width = o.minWidth;
7522          }
7523          if (isminh) {
7524              data.height = o.minHeight;
7525          }
7526          if (ismaxw) {
7527              data.width = o.maxWidth;
7528          }
7529          if (ismaxh) {
7530              data.height = o.maxHeight;
7531          }
7532  
7533          if (isminw && cw) {
7534              data.left = dw - o.minWidth;
7535          }
7536          if (ismaxw && cw) {
7537              data.left = dw - o.maxWidth;
7538          }
7539          if (isminh && ch) {
7540              data.top = dh - o.minHeight;
7541          }
7542          if (ismaxh && ch) {
7543              data.top = dh - o.maxHeight;
7544          }
7545  
7546          // Fixing jump error on top/left - bug #2330
7547          if (!data.width && !data.height && !data.left && data.top) {
7548              data.top = null;
7549          } else if (!data.width && !data.height && !data.top && data.left) {
7550              data.left = null;
7551          }
7552  
7553          return data;
7554      },
7555  
7556      _getPaddingPlusBorderDimensions: function( element ) {
7557          var i = 0,
7558              widths = [],
7559              borders = [
7560                  element.css( "borderTopWidth" ),
7561                  element.css( "borderRightWidth" ),
7562                  element.css( "borderBottomWidth" ),
7563                  element.css( "borderLeftWidth" )
7564              ],
7565              paddings = [
7566                  element.css( "paddingTop" ),
7567                  element.css( "paddingRight" ),
7568                  element.css( "paddingBottom" ),
7569                  element.css( "paddingLeft" )
7570              ];
7571  
7572          for ( ; i < 4; i++ ) {
7573              widths[ i ] = ( parseInt( borders[ i ], 10 ) || 0 );
7574              widths[ i ] += ( parseInt( paddings[ i ], 10 ) || 0 );
7575          }
7576  
7577          return {
7578              height: widths[ 0 ] + widths[ 2 ],
7579              width: widths[ 1 ] + widths[ 3 ]
7580          };
7581      },
7582  
7583      _proportionallyResize: function() {
7584  
7585          if (!this._proportionallyResizeElements.length) {
7586              return;
7587          }
7588  
7589          var prel,
7590              i = 0,
7591              element = this.helper || this.element;
7592  
7593          for ( ; i < this._proportionallyResizeElements.length; i++) {
7594  
7595              prel = this._proportionallyResizeElements[i];
7596  
7597              // TODO: Seems like a bug to cache this.outerDimensions
7598              // considering that we are in a loop.
7599              if (!this.outerDimensions) {
7600                  this.outerDimensions = this._getPaddingPlusBorderDimensions( prel );
7601              }
7602  
7603              prel.css({
7604                  height: (element.height() - this.outerDimensions.height) || 0,
7605                  width: (element.width() - this.outerDimensions.width) || 0
7606              });
7607  
7608          }
7609  
7610      },
7611  
7612      _renderProxy: function() {
7613  
7614          var el = this.element, o = this.options;
7615          this.elementOffset = el.offset();
7616  
7617          if (this._helper) {
7618  
7619              this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
7620  
7621              this.helper.addClass(this._helper).css({
7622                  width: this.element.outerWidth() - 1,
7623                  height: this.element.outerHeight() - 1,
7624                  position: "absolute",
7625                  left: this.elementOffset.left + "px",
7626                  top: this.elementOffset.top + "px",
7627                  zIndex: ++o.zIndex //TODO: Don't modify option
7628              });
7629  
7630              this.helper
7631                  .appendTo("body")
7632                  .disableSelection();
7633  
7634          } else {
7635              this.helper = this.element;
7636          }
7637  
7638      },
7639  
7640      _change: {
7641          e: function(event, dx) {
7642              return { width: this.originalSize.width + dx };
7643          },
7644          w: function(event, dx) {
7645              var cs = this.originalSize, sp = this.originalPosition;
7646              return { left: sp.left + dx, width: cs.width - dx };
7647          },
7648          n: function(event, dx, dy) {
7649              var cs = this.originalSize, sp = this.originalPosition;
7650              return { top: sp.top + dy, height: cs.height - dy };
7651          },
7652          s: function(event, dx, dy) {
7653              return { height: this.originalSize.height + dy };
7654          },
7655          se: function(event, dx, dy) {
7656              return $.extend(this._change.s.apply(this, arguments),
7657                  this._change.e.apply(this, [ event, dx, dy ]));
7658          },
7659          sw: function(event, dx, dy) {
7660              return $.extend(this._change.s.apply(this, arguments),
7661                  this._change.w.apply(this, [ event, dx, dy ]));
7662          },
7663          ne: function(event, dx, dy) {
7664              return $.extend(this._change.n.apply(this, arguments),
7665                  this._change.e.apply(this, [ event, dx, dy ]));
7666          },
7667          nw: function(event, dx, dy) {
7668              return $.extend(this._change.n.apply(this, arguments),
7669                  this._change.w.apply(this, [ event, dx, dy ]));
7670          }
7671      },
7672  
7673      _propagate: function(n, event) {
7674          $.ui.plugin.call(this, n, [ event, this.ui() ]);
7675          (n !== "resize" && this._trigger(n, event, this.ui()));
7676      },
7677  
7678      plugins: {},
7679  
7680      ui: function() {
7681          return {
7682              originalElement: this.originalElement,
7683              element: this.element,
7684              helper: this.helper,
7685              position: this.position,
7686              size: this.size,
7687              originalSize: this.originalSize,
7688              originalPosition: this.originalPosition
7689          };
7690      }
7691  
7692  });
7693  
7694  /*
7695   * Resizable Extensions
7696   */
7697  
7698  $.ui.plugin.add("resizable", "animate", {
7699  
7700      stop: function( event ) {
7701          var that = $(this).resizable( "instance" ),
7702              o = that.options,
7703              pr = that._proportionallyResizeElements,
7704              ista = pr.length && (/textarea/i).test(pr[0].nodeName),
7705              soffseth = ista && that._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height,
7706              soffsetw = ista ? 0 : that.sizeDiff.width,
7707              style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
7708              left = (parseInt(that.element.css("left"), 10) +
7709                  (that.position.left - that.originalPosition.left)) || null,
7710              top = (parseInt(that.element.css("top"), 10) +
7711                  (that.position.top - that.originalPosition.top)) || null;
7712  
7713          that.element.animate(
7714              $.extend(style, top && left ? { top: top, left: left } : {}), {
7715                  duration: o.animateDuration,
7716                  easing: o.animateEasing,
7717                  step: function() {
7718  
7719                      var data = {
7720                          width: parseInt(that.element.css("width"), 10),
7721                          height: parseInt(that.element.css("height"), 10),
7722                          top: parseInt(that.element.css("top"), 10),
7723                          left: parseInt(that.element.css("left"), 10)
7724                      };
7725  
7726                      if (pr && pr.length) {
7727                          $(pr[0]).css({ width: data.width, height: data.height });
7728                      }
7729  
7730                      // propagating resize, and updating values for each animation step
7731                      that._updateCache(data);
7732                      that._propagate("resize", event);
7733  
7734                  }
7735              }
7736          );
7737      }
7738  
7739  });
7740  
7741  $.ui.plugin.add( "resizable", "containment", {
7742  
7743      start: function() {
7744          var element, p, co, ch, cw, width, height,
7745              that = $( this ).resizable( "instance" ),
7746              o = that.options,
7747              el = that.element,
7748              oc = o.containment,
7749              ce = ( oc instanceof $ ) ? oc.get( 0 ) : ( /parent/.test( oc ) ) ? el.parent().get( 0 ) : oc;
7750  
7751          if ( !ce ) {
7752              return;
7753          }
7754  
7755          that.containerElement = $( ce );
7756  
7757          if ( /document/.test( oc ) || oc === document ) {
7758              that.containerOffset = {
7759                  left: 0,
7760                  top: 0
7761              };
7762              that.containerPosition = {
7763                  left: 0,
7764                  top: 0
7765              };
7766  
7767              that.parentData = {
7768                  element: $( document ),
7769                  left: 0,
7770                  top: 0,
7771                  width: $( document ).width(),
7772                  height: $( document ).height() || document.body.parentNode.scrollHeight
7773              };
7774          } else {
7775              element = $( ce );
7776              p = [];
7777              $([ "Top", "Right", "Left", "Bottom" ]).each(function( i, name ) {
7778                  p[ i ] = that._num( element.css( "padding" + name ) );
7779              });
7780  
7781              that.containerOffset = element.offset();
7782              that.containerPosition = element.position();
7783              that.containerSize = {
7784                  height: ( element.innerHeight() - p[ 3 ] ),
7785                  width: ( element.innerWidth() - p[ 1 ] )
7786              };
7787  
7788              co = that.containerOffset;
7789              ch = that.containerSize.height;
7790              cw = that.containerSize.width;
7791              width = ( that._hasScroll ( ce, "left" ) ? ce.scrollWidth : cw );
7792              height = ( that._hasScroll ( ce ) ? ce.scrollHeight : ch ) ;
7793  
7794              that.parentData = {
7795                  element: ce,
7796                  left: co.left,
7797                  top: co.top,
7798                  width: width,
7799                  height: height
7800              };
7801          }
7802      },
7803  
7804      resize: function( event ) {
7805          var woset, hoset, isParent, isOffsetRelative,
7806              that = $( this ).resizable( "instance" ),
7807              o = that.options,
7808              co = that.containerOffset,
7809              cp = that.position,
7810              pRatio = that._aspectRatio || event.shiftKey,
7811              cop = {
7812                  top: 0,
7813                  left: 0
7814              },
7815              ce = that.containerElement,
7816              continueResize = true;
7817  
7818          if ( ce[ 0 ] !== document && ( /static/ ).test( ce.css( "position" ) ) ) {
7819              cop = co;
7820          }
7821  
7822          if ( cp.left < ( that._helper ? co.left : 0 ) ) {
7823              that.size.width = that.size.width +
7824                  ( that._helper ?
7825                      ( that.position.left - co.left ) :
7826                      ( that.position.left - cop.left ) );
7827  
7828              if ( pRatio ) {
7829                  that.size.height = that.size.width / that.aspectRatio;
7830                  continueResize = false;
7831              }
7832              that.position.left = o.helper ? co.left : 0;
7833          }
7834  
7835          if ( cp.top < ( that._helper ? co.top : 0 ) ) {
7836              that.size.height = that.size.height +
7837                  ( that._helper ?
7838                      ( that.position.top - co.top ) :
7839                      that.position.top );
7840  
7841              if ( pRatio ) {
7842                  that.size.width = that.size.height * that.aspectRatio;
7843                  continueResize = false;
7844              }
7845              that.position.top = that._helper ? co.top : 0;
7846          }
7847  
7848          isParent = that.containerElement.get( 0 ) === that.element.parent().get( 0 );
7849          isOffsetRelative = /relative|absolute/.test( that.containerElement.css( "position" ) );
7850  
7851          if ( isParent && isOffsetRelative ) {
7852              that.offset.left = that.parentData.left + that.position.left;
7853              that.offset.top = that.parentData.top + that.position.top;
7854          } else {
7855              that.offset.left = that.element.offset().left;
7856              that.offset.top = that.element.offset().top;
7857          }
7858  
7859          woset = Math.abs( that.sizeDiff.width +
7860              (that._helper ?
7861                  that.offset.left - cop.left :
7862                  (that.offset.left - co.left)) );
7863  
7864          hoset = Math.abs( that.sizeDiff.height +
7865              (that._helper ?
7866                  that.offset.top - cop.top :
7867                  (that.offset.top - co.top)) );
7868  
7869          if ( woset + that.size.width >= that.parentData.width ) {
7870              that.size.width = that.parentData.width - woset;
7871              if ( pRatio ) {
7872                  that.size.height = that.size.width / that.aspectRatio;
7873                  continueResize = false;
7874              }
7875          }
7876  
7877          if ( hoset + that.size.height >= that.parentData.height ) {
7878              that.size.height = that.parentData.height - hoset;
7879              if ( pRatio ) {
7880                  that.size.width = that.size.height * that.aspectRatio;
7881                  continueResize = false;
7882              }
7883          }
7884  
7885          if ( !continueResize ) {
7886              that.position.left = that.prevPosition.left;
7887              that.position.top = that.prevPosition.top;
7888              that.size.width = that.prevSize.width;
7889              that.size.height = that.prevSize.height;
7890          }
7891      },
7892  
7893      stop: function() {
7894          var that = $( this ).resizable( "instance" ),
7895              o = that.options,
7896              co = that.containerOffset,
7897              cop = that.containerPosition,
7898              ce = that.containerElement,
7899              helper = $( that.helper ),
7900              ho = helper.offset(),
7901              w = helper.outerWidth() - that.sizeDiff.width,
7902              h = helper.outerHeight() - that.sizeDiff.height;
7903  
7904          if ( that._helper && !o.animate && ( /relative/ ).test( ce.css( "position" ) ) ) {
7905              $( this ).css({
7906                  left: ho.left - cop.left - co.left,
7907                  width: w,
7908                  height: h
7909              });
7910          }
7911  
7912          if ( that._helper && !o.animate && ( /static/ ).test( ce.css( "position" ) ) ) {
7913              $( this ).css({
7914                  left: ho.left - cop.left - co.left,
7915                  width: w,
7916                  height: h
7917              });
7918          }
7919      }
7920  });
7921  
7922  $.ui.plugin.add("resizable", "alsoResize", {
7923  
7924      start: function() {
7925          var that = $(this).resizable( "instance" ),
7926              o = that.options;
7927  
7928          $(o.alsoResize).each(function() {
7929              var el = $(this);
7930              el.data("ui-resizable-alsoresize", {
7931                  width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
7932                  left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10)
7933              });
7934          });
7935      },
7936  
7937      resize: function(event, ui) {
7938          var that = $(this).resizable( "instance" ),
7939              o = that.options,
7940              os = that.originalSize,
7941              op = that.originalPosition,
7942              delta = {
7943                  height: (that.size.height - os.height) || 0,
7944                  width: (that.size.width - os.width) || 0,
7945                  top: (that.position.top - op.top) || 0,
7946                  left: (that.position.left - op.left) || 0
7947              };
7948  
7949              $(o.alsoResize).each(function() {
7950                  var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
7951                      css = el.parents(ui.originalElement[0]).length ?
7952                              [ "width", "height" ] :
7953                              [ "width", "height", "top", "left" ];
7954  
7955                  $.each(css, function(i, prop) {
7956                      var sum = (start[prop] || 0) + (delta[prop] || 0);
7957                      if (sum && sum >= 0) {
7958                          style[prop] = sum || null;
7959                      }
7960                  });
7961  
7962                  el.css(style);
7963              });
7964      },
7965  
7966      stop: function() {
7967          $(this).removeData("resizable-alsoresize");
7968      }
7969  });
7970  
7971  $.ui.plugin.add("resizable", "ghost", {
7972  
7973      start: function() {
7974  
7975          var that = $(this).resizable( "instance" ), o = that.options, cs = that.size;
7976  
7977          that.ghost = that.originalElement.clone();
7978          that.ghost
7979              .css({
7980                  opacity: 0.25,
7981                  display: "block",
7982                  position: "relative",
7983                  height: cs.height,
7984                  width: cs.width,
7985                  margin: 0,
7986                  left: 0,
7987                  top: 0
7988              })
7989              .addClass("ui-resizable-ghost")
7990              .addClass(typeof o.ghost === "string" ? o.ghost : "");
7991  
7992          that.ghost.appendTo(that.helper);
7993  
7994      },
7995  
7996      resize: function() {
7997          var that = $(this).resizable( "instance" );
7998          if (that.ghost) {
7999              that.ghost.css({
8000                  position: "relative",
8001                  height: that.size.height,
8002                  width: that.size.width
8003              });
8004          }
8005      },
8006  
8007      stop: function() {
8008          var that = $(this).resizable( "instance" );
8009          if (that.ghost && that.helper) {
8010              that.helper.get(0).removeChild(that.ghost.get(0));
8011          }
8012      }
8013  
8014  });
8015  
8016  $.ui.plugin.add("resizable", "grid", {
8017  
8018      resize: function() {
8019          var outerDimensions,
8020              that = $(this).resizable( "instance" ),
8021              o = that.options,
8022              cs = that.size,
8023              os = that.originalSize,
8024              op = that.originalPosition,
8025              a = that.axis,
8026              grid = typeof o.grid === "number" ? [ o.grid, o.grid ] : o.grid,
8027              gridX = (grid[0] || 1),
8028              gridY = (grid[1] || 1),
8029              ox = Math.round((cs.width - os.width) / gridX) * gridX,
8030              oy = Math.round((cs.height - os.height) / gridY) * gridY,
8031              newWidth = os.width + ox,
8032              newHeight = os.height + oy,
8033              isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
8034              isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
8035              isMinWidth = o.minWidth && (o.minWidth > newWidth),
8036              isMinHeight = o.minHeight && (o.minHeight > newHeight);
8037  
8038          o.grid = grid;
8039  
8040          if (isMinWidth) {
8041              newWidth += gridX;
8042          }
8043          if (isMinHeight) {
8044              newHeight += gridY;
8045          }
8046          if (isMaxWidth) {
8047              newWidth -= gridX;
8048          }
8049          if (isMaxHeight) {
8050              newHeight -= gridY;
8051          }
8052  
8053          if (/^(se|s|e)$/.test(a)) {
8054              that.size.width = newWidth;
8055              that.size.height = newHeight;
8056          } else if (/^(ne)$/.test(a)) {
8057              that.size.width = newWidth;
8058              that.size.height = newHeight;
8059              that.position.top = op.top - oy;
8060          } else if (/^(sw)$/.test(a)) {
8061              that.size.width = newWidth;
8062              that.size.height = newHeight;
8063              that.position.left = op.left - ox;
8064          } else {
8065              if ( newHeight - gridY <= 0 || newWidth - gridX <= 0) {
8066                  outerDimensions = that._getPaddingPlusBorderDimensions( this );
8067              }
8068  
8069              if ( newHeight - gridY > 0 ) {
8070                  that.size.height = newHeight;
8071                  that.position.top = op.top - oy;
8072              } else {
8073                  newHeight = gridY - outerDimensions.height;
8074                  that.size.height = newHeight;
8075                  that.position.top = op.top + os.height - newHeight;
8076              }
8077              if ( newWidth - gridX > 0 ) {
8078                  that.size.width = newWidth;
8079                  that.position.left = op.left - ox;
8080              } else {
8081                  newWidth = gridX - outerDimensions.width;
8082                  that.size.width = newWidth;
8083                  that.position.left = op.left + os.width - newWidth;
8084              }
8085          }
8086      }
8087  
8088  });
8089  
8090  var resizable = $.ui.resizable;
8091  
8092  
8093  /*!
8094   * jQuery UI Dialog 1.11.4
8095   * http://jqueryui.com
8096   *
8097   * Copyright jQuery Foundation and other contributors
8098   * Released under the MIT license.
8099   * http://jquery.org/license
8100   *
8101   * http://api.jqueryui.com/dialog/
8102   */
8103  
8104  
8105  var dialog = $.widget( "ui.dialog", {
8106      version: "1.11.4",
8107      options: {
8108          appendTo: "body",
8109          autoOpen: true,
8110          buttons: [],
8111          closeOnEscape: true,
8112          closeText: "Close",
8113          dialogClass: "",
8114          draggable: true,
8115          hide: null,
8116          height: "auto",
8117          maxHeight: null,
8118          maxWidth: null,
8119          minHeight: 150,
8120          minWidth: 150,
8121          modal: false,
8122          position: {
8123              my: "center",
8124              at: "center",
8125              of: window,
8126              collision: "fit",
8127              // Ensure the titlebar is always visible
8128              using: function( pos ) {
8129                  var topOffset = $( this ).css( pos ).offset().top;
8130                  if ( topOffset < 0 ) {
8131                      $( this ).css( "top", pos.top - topOffset );
8132                  }
8133              }
8134          },
8135          resizable: true,
8136          show: null,
8137          title: null,
8138          width: 300,
8139  
8140          // callbacks
8141          beforeClose: null,
8142          close: null,
8143          drag: null,
8144          dragStart: null,
8145          dragStop: null,
8146          focus: null,
8147          open: null,
8148          resize: null,
8149          resizeStart: null,
8150          resizeStop: null
8151      },
8152  
8153      sizeRelatedOptions: {
8154          buttons: true,
8155          height: true,
8156          maxHeight: true,
8157          maxWidth: true,
8158          minHeight: true,
8159          minWidth: true,
8160          width: true
8161      },
8162  
8163      resizableRelatedOptions: {
8164          maxHeight: true,
8165          maxWidth: true,
8166          minHeight: true,
8167          minWidth: true
8168      },
8169  
8170      _create: function() {
8171          this.originalCss = {
8172              display: this.element[ 0 ].style.display,
8173              width: this.element[ 0 ].style.width,
8174              minHeight: this.element[ 0 ].style.minHeight,
8175              maxHeight: this.element[ 0 ].style.maxHeight,
8176              height: this.element[ 0 ].style.height
8177          };
8178          this.originalPosition = {
8179              parent: this.element.parent(),
8180              index: this.element.parent().children().index( this.element )
8181          };
8182          this.originalTitle = this.element.attr( "title" );
8183          this.options.title = this.options.title || this.originalTitle;
8184  
8185          this._createWrapper();
8186  
8187          this.element
8188              .show()
8189              .removeAttr( "title" )
8190              .addClass( "ui-dialog-content ui-widget-content" )
8191              .appendTo( this.uiDialog );
8192  
8193          this._createTitlebar();
8194          this._createButtonPane();
8195  
8196          if ( this.options.draggable && $.fn.draggable ) {
8197              this._makeDraggable();
8198          }
8199          if ( this.options.resizable && $.fn.resizable ) {
8200              this._makeResizable();
8201          }
8202  
8203          this._isOpen = false;
8204  
8205          this._trackFocus();
8206      },
8207  
8208      _init: function() {
8209          if ( this.options.autoOpen ) {
8210              this.open();
8211          }
8212      },
8213  
8214      _appendTo: function() {
8215          var element = this.options.appendTo;
8216          if ( element && (element.jquery || element.nodeType) ) {
8217              return $( element );
8218          }
8219          return this.document.find( element || "body" ).eq( 0 );
8220      },
8221  
8222      _destroy: function() {
8223          var next,
8224              originalPosition = this.originalPosition;
8225  
8226          this._untrackInstance();
8227          this._destroyOverlay();
8228  
8229          this.element
8230              .removeUniqueId()
8231              .removeClass( "ui-dialog-content ui-widget-content" )
8232              .css( this.originalCss )
8233              // Without detaching first, the following becomes really slow
8234              .detach();
8235  
8236          this.uiDialog.stop( true, true ).remove();
8237  
8238          if ( this.originalTitle ) {
8239              this.element.attr( "title", this.originalTitle );
8240          }
8241  
8242          next = originalPosition.parent.children().eq( originalPosition.index );
8243          // Don't try to place the dialog next to itself (#8613)
8244          if ( next.length && next[ 0 ] !== this.element[ 0 ] ) {
8245              next.before( this.element );
8246          } else {
8247              originalPosition.parent.append( this.element );
8248          }
8249      },
8250  
8251      widget: function() {
8252          return this.uiDialog;
8253      },
8254  
8255      disable: $.noop,
8256      enable: $.noop,
8257  
8258      close: function( event ) {
8259          var activeElement,
8260              that = this;
8261  
8262          if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {
8263              return;
8264          }
8265  
8266          this._isOpen = false;
8267          this._focusedElement = null;
8268          this._destroyOverlay();
8269          this._untrackInstance();
8270  
8271          if ( !this.opener.filter( ":focusable" ).focus().length ) {
8272  
8273              // support: IE9
8274              // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
8275              try {
8276                  activeElement = this.document[ 0 ].activeElement;
8277  
8278                  // Support: IE9, IE10
8279                  // If the <body> is blurred, IE will switch windows, see #4520
8280                  if ( activeElement && activeElement.nodeName.toLowerCase() !== "body" ) {
8281  
8282                      // Hiding a focused element doesn't trigger blur in WebKit
8283                      // so in case we have nothing to focus on, explicitly blur the active element
8284                      // https://bugs.webkit.org/show_bug.cgi?id=47182
8285                      $( activeElement ).blur();
8286                  }
8287              } catch ( error ) {}
8288          }
8289  
8290          this._hide( this.uiDialog, this.options.hide, function() {
8291              that._trigger( "close", event );
8292          });
8293      },
8294  
8295      isOpen: function() {
8296          return this._isOpen;
8297      },
8298  
8299      moveToTop: function() {
8300          this._moveToTop();
8301      },
8302  
8303      _moveToTop: function( event, silent ) {
8304          var moved = false,
8305              zIndices = this.uiDialog.siblings( ".ui-front:visible" ).map(function() {
8306                  return +$( this ).css( "z-index" );
8307              }).get(),
8308              zIndexMax = Math.max.apply( null, zIndices );
8309  
8310          if ( zIndexMax >= +this.uiDialog.css( "z-index" ) ) {
8311              this.uiDialog.css( "z-index", zIndexMax + 1 );
8312              moved = true;
8313          }
8314  
8315          if ( moved && !silent ) {
8316              this._trigger( "focus", event );
8317          }
8318          return moved;
8319      },
8320  
8321      open: function() {
8322          var that = this;
8323          if ( this._isOpen ) {
8324              if ( this._moveToTop() ) {
8325                  this._focusTabbable();
8326              }
8327              return;
8328          }
8329  
8330          this._isOpen = true;
8331          this.opener = $( this.document[ 0 ].activeElement );
8332  
8333          this._size();
8334          this._position();
8335          this._createOverlay();
8336          this._moveToTop( null, true );
8337  
8338          // Ensure the overlay is moved to the top with the dialog, but only when
8339          // opening. The overlay shouldn't move after the dialog is open so that
8340          // modeless dialogs opened after the modal dialog stack properly.
8341          if ( this.overlay ) {
8342              this.overlay.css( "z-index", this.uiDialog.css( "z-index" ) - 1 );
8343          }
8344  
8345          this._show( this.uiDialog, this.options.show, function() {
8346              that._focusTabbable();
8347              that._trigger( "focus" );
8348          });
8349  
8350          // Track the dialog immediately upon openening in case a focus event
8351          // somehow occurs outside of the dialog before an element inside the
8352          // dialog is focused (#10152)
8353          this._makeFocusTarget();
8354  
8355          this._trigger( "open" );
8356      },
8357  
8358      _focusTabbable: function() {
8359          // Set focus to the first match:
8360          // 1. An element that was focused previously
8361          // 2. First element inside the dialog matching [autofocus]
8362          // 3. Tabbable element inside the content element
8363          // 4. Tabbable element inside the buttonpane
8364          // 5. The close button
8365          // 6. The dialog itself
8366          var hasFocus = this._focusedElement;
8367          if ( !hasFocus ) {
8368              hasFocus = this.element.find( "[autofocus]" );
8369          }
8370          if ( !hasFocus.length ) {
8371              hasFocus = this.element.find( ":tabbable" );
8372          }
8373          if ( !hasFocus.length ) {
8374              hasFocus = this.uiDialogButtonPane.find( ":tabbable" );
8375          }
8376          if ( !hasFocus.length ) {
8377              hasFocus = this.uiDialogTitlebarClose.filter( ":tabbable" );
8378          }
8379          if ( !hasFocus.length ) {
8380              hasFocus = this.uiDialog;
8381          }
8382          hasFocus.eq( 0 ).focus();
8383      },
8384  
8385      _keepFocus: function( event ) {
8386  		function checkFocus() {
8387              var activeElement = this.document[0].activeElement,
8388                  isActive = this.uiDialog[0] === activeElement ||
8389                      $.contains( this.uiDialog[0], activeElement );
8390              if ( !isActive ) {
8391                  this._focusTabbable();
8392              }
8393          }
8394          event.preventDefault();
8395          checkFocus.call( this );
8396          // support: IE
8397          // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
8398          // so we check again later
8399          this._delay( checkFocus );
8400      },
8401  
8402      _createWrapper: function() {
8403          this.uiDialog = $("<div>")
8404              .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
8405                  this.options.dialogClass )
8406              .hide()
8407              .attr({
8408                  // Setting tabIndex makes the div focusable
8409                  tabIndex: -1,
8410                  role: "dialog"
8411              })
8412              .appendTo( this._appendTo() );
8413  
8414          this._on( this.uiDialog, {
8415              keydown: function( event ) {
8416                  if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
8417                          event.keyCode === $.ui.keyCode.ESCAPE ) {
8418                      event.preventDefault();
8419                      this.close( event );
8420                      return;
8421                  }
8422  
8423                  // prevent tabbing out of dialogs
8424                  if ( event.keyCode !== $.ui.keyCode.TAB || event.isDefaultPrevented() ) {
8425                      return;
8426                  }
8427                  var tabbables = this.uiDialog.find( ":tabbable" ),
8428                      first = tabbables.filter( ":first" ),
8429                      last = tabbables.filter( ":last" );
8430  
8431                  if ( ( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey ) {
8432                      this._delay(function() {
8433                          first.focus();
8434                      });
8435                      event.preventDefault();
8436                  } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) {
8437                      this._delay(function() {
8438                          last.focus();
8439                      });
8440                      event.preventDefault();
8441                  }
8442              },
8443              mousedown: function( event ) {
8444                  if ( this._moveToTop( event ) ) {
8445                      this._focusTabbable();
8446                  }
8447              }
8448          });
8449  
8450          // We assume that any existing aria-describedby attribute means
8451          // that the dialog content is marked up properly
8452          // otherwise we brute force the content as the description
8453          if ( !this.element.find( "[aria-describedby]" ).length ) {
8454              this.uiDialog.attr({
8455                  "aria-describedby": this.element.uniqueId().attr( "id" )
8456              });
8457          }
8458      },
8459  
8460      _createTitlebar: function() {
8461          var uiDialogTitle;
8462  
8463          this.uiDialogTitlebar = $( "<div>" )
8464              .addClass( "ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix" )
8465              .prependTo( this.uiDialog );
8466          this._on( this.uiDialogTitlebar, {
8467              mousedown: function( event ) {
8468                  // Don't prevent click on close button (#8838)
8469                  // Focusing a dialog that is partially scrolled out of view
8470                  // causes the browser to scroll it into view, preventing the click event
8471                  if ( !$( event.target ).closest( ".ui-dialog-titlebar-close" ) ) {
8472                      // Dialog isn't getting focus when dragging (#8063)
8473                      this.uiDialog.focus();
8474                  }
8475              }
8476          });
8477  
8478          // support: IE
8479          // Use type="button" to prevent enter keypresses in textboxes from closing the
8480          // dialog in IE (#9312)
8481          this.uiDialogTitlebarClose = $( "<button type='button'></button>" )
8482              .button({
8483                  label: this.options.closeText,
8484                  icons: {
8485                      primary: "ui-icon-closethick"
8486                  },
8487                  text: false
8488              })
8489              .addClass( "ui-dialog-titlebar-close" )
8490              .appendTo( this.uiDialogTitlebar );
8491          this._on( this.uiDialogTitlebarClose, {
8492              click: function( event ) {
8493                  event.preventDefault();
8494                  this.close( event );
8495              }
8496          });
8497  
8498          uiDialogTitle = $( "<span>" )
8499              .uniqueId()
8500              .addClass( "ui-dialog-title" )
8501              .prependTo( this.uiDialogTitlebar );
8502          this._title( uiDialogTitle );
8503  
8504          this.uiDialog.attr({
8505              "aria-labelledby": uiDialogTitle.attr( "id" )
8506          });
8507      },
8508  
8509      _title: function( title ) {
8510          if ( !this.options.title ) {
8511              title.html( "&#160;" );
8512          }
8513          title.text( this.options.title );
8514      },
8515  
8516      _createButtonPane: function() {
8517          this.uiDialogButtonPane = $( "<div>" )
8518              .addClass( "ui-dialog-buttonpane ui-widget-content ui-helper-clearfix" );
8519  
8520          this.uiButtonSet = $( "<div>" )
8521              .addClass( "ui-dialog-buttonset" )
8522              .appendTo( this.uiDialogButtonPane );
8523  
8524          this._createButtons();
8525      },
8526  
8527      _createButtons: function() {
8528          var that = this,
8529              buttons = this.options.buttons;
8530  
8531          // if we already have a button pane, remove it
8532          this.uiDialogButtonPane.remove();
8533          this.uiButtonSet.empty();
8534  
8535          if ( $.isEmptyObject( buttons ) || ($.isArray( buttons ) && !buttons.length) ) {
8536              this.uiDialog.removeClass( "ui-dialog-buttons" );
8537              return;
8538          }
8539  
8540          $.each( buttons, function( name, props ) {
8541              var click, buttonOptions;
8542              props = $.isFunction( props ) ?
8543                  { click: props, text: name } :
8544                  props;
8545              // Default to a non-submitting button
8546              props = $.extend( { type: "button" }, props );
8547              // Change the context for the click callback to be the main element
8548              click = props.click;
8549              props.click = function() {
8550                  click.apply( that.element[ 0 ], arguments );
8551              };
8552              buttonOptions = {
8553                  icons: props.icons,
8554                  text: props.showText
8555              };
8556              delete props.icons;
8557              delete props.showText;
8558              $( "<button></button>", props )
8559                  .button( buttonOptions )
8560                  .appendTo( that.uiButtonSet );
8561          });
8562          this.uiDialog.addClass( "ui-dialog-buttons" );
8563          this.uiDialogButtonPane.appendTo( this.uiDialog );
8564      },
8565  
8566      _makeDraggable: function() {
8567          var that = this,
8568              options = this.options;
8569  
8570  		function filteredUi( ui ) {
8571              return {
8572                  position: ui.position,
8573                  offset: ui.offset
8574              };
8575          }
8576  
8577          this.uiDialog.draggable({
8578              cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
8579              handle: ".ui-dialog-titlebar",
8580              containment: "document",
8581              start: function( event, ui ) {
8582                  $( this ).addClass( "ui-dialog-dragging" );
8583                  that._blockFrames();
8584                  that._trigger( "dragStart", event, filteredUi( ui ) );
8585              },
8586              drag: function( event, ui ) {
8587                  that._trigger( "drag", event, filteredUi( ui ) );
8588              },
8589              stop: function( event, ui ) {
8590                  var left = ui.offset.left - that.document.scrollLeft(),
8591                      top = ui.offset.top - that.document.scrollTop();
8592  
8593                  options.position = {
8594                      my: "left top",
8595                      at: "left" + (left >= 0 ? "+" : "") + left + " " +
8596                          "top" + (top >= 0 ? "+" : "") + top,
8597                      of: that.window
8598                  };
8599                  $( this ).removeClass( "ui-dialog-dragging" );
8600                  that._unblockFrames();
8601                  that._trigger( "dragStop", event, filteredUi( ui ) );
8602              }
8603          });
8604      },
8605  
8606      _makeResizable: function() {
8607          var that = this,
8608              options = this.options,
8609              handles = options.resizable,
8610              // .ui-resizable has position: relative defined in the stylesheet
8611              // but dialogs have to use absolute or fixed positioning
8612              position = this.uiDialog.css("position"),
8613              resizeHandles = typeof handles === "string" ?
8614                  handles    :
8615                  "n,e,s,w,se,sw,ne,nw";
8616  
8617  		function filteredUi( ui ) {
8618              return {
8619                  originalPosition: ui.originalPosition,
8620                  originalSize: ui.originalSize,
8621                  position: ui.position,
8622                  size: ui.size
8623              };
8624          }
8625  
8626          this.uiDialog.resizable({
8627              cancel: ".ui-dialog-content",
8628              containment: "document",
8629              alsoResize: this.element,
8630              maxWidth: options.maxWidth,
8631              maxHeight: options.maxHeight,
8632              minWidth: options.minWidth,
8633              minHeight: this._minHeight(),
8634              handles: resizeHandles,
8635              start: function( event, ui ) {
8636                  $( this ).addClass( "ui-dialog-resizing" );
8637                  that._blockFrames();
8638                  that._trigger( "resizeStart", event, filteredUi( ui ) );
8639              },
8640              resize: function( event, ui ) {
8641                  that._trigger( "resize", event, filteredUi( ui ) );
8642              },
8643              stop: function( event, ui ) {
8644                  var offset = that.uiDialog.offset(),
8645                      left = offset.left - that.document.scrollLeft(),
8646                      top = offset.top - that.document.scrollTop();
8647  
8648                  options.height = that.uiDialog.height();
8649                  options.width = that.uiDialog.width();
8650                  options.position = {
8651                      my: "left top",
8652                      at: "left" + (left >= 0 ? "+" : "") + left + " " +
8653                          "top" + (top >= 0 ? "+" : "") + top,
8654                      of: that.window
8655                  };
8656                  $( this ).removeClass( "ui-dialog-resizing" );
8657                  that._unblockFrames();
8658                  that._trigger( "resizeStop", event, filteredUi( ui ) );
8659              }
8660          })
8661          .css( "position", position );
8662      },
8663  
8664      _trackFocus: function() {
8665          this._on( this.widget(), {
8666              focusin: function( event ) {
8667                  this._makeFocusTarget();
8668                  this._focusedElement = $( event.target );
8669              }
8670          });
8671      },
8672  
8673      _makeFocusTarget: function() {
8674          this._untrackInstance();
8675          this._trackingInstances().unshift( this );
8676      },
8677  
8678      _untrackInstance: function() {
8679          var instances = this._trackingInstances(),
8680              exists = $.inArray( this, instances );
8681          if ( exists !== -1 ) {
8682              instances.splice( exists, 1 );
8683          }
8684      },
8685  
8686      _trackingInstances: function() {
8687          var instances = this.document.data( "ui-dialog-instances" );
8688          if ( !instances ) {
8689              instances = [];
8690              this.document.data( "ui-dialog-instances", instances );
8691          }
8692          return instances;
8693      },
8694  
8695      _minHeight: function() {
8696          var options = this.options;
8697  
8698          return options.height === "auto" ?
8699              options.minHeight :
8700              Math.min( options.minHeight, options.height );
8701      },
8702  
8703      _position: function() {
8704          // Need to show the dialog to get the actual offset in the position plugin
8705          var isVisible = this.uiDialog.is( ":visible" );
8706          if ( !isVisible ) {
8707              this.uiDialog.show();
8708          }
8709          this.uiDialog.position( this.options.position );
8710          if ( !isVisible ) {
8711              this.uiDialog.hide();
8712          }
8713      },
8714  
8715      _setOptions: function( options ) {
8716          var that = this,
8717              resize = false,
8718              resizableOptions = {};
8719  
8720          $.each( options, function( key, value ) {
8721              that._setOption( key, value );
8722  
8723              if ( key in that.sizeRelatedOptions ) {
8724                  resize = true;
8725              }
8726              if ( key in that.resizableRelatedOptions ) {
8727                  resizableOptions[ key ] = value;
8728              }
8729          });
8730  
8731          if ( resize ) {
8732              this._size();
8733              this._position();
8734          }
8735          if ( this.uiDialog.is( ":data(ui-resizable)" ) ) {
8736              this.uiDialog.resizable( "option", resizableOptions );
8737          }
8738      },
8739  
8740      _setOption: function( key, value ) {
8741          var isDraggable, isResizable,
8742              uiDialog = this.uiDialog;
8743  
8744          if ( key === "dialogClass" ) {
8745              uiDialog
8746                  .removeClass( this.options.dialogClass )
8747                  .addClass( value );
8748          }
8749  
8750          if ( key === "disabled" ) {
8751              return;
8752          }
8753  
8754          this._super( key, value );
8755  
8756          if ( key === "appendTo" ) {
8757              this.uiDialog.appendTo( this._appendTo() );
8758          }
8759  
8760          if ( key === "buttons" ) {
8761              this._createButtons();
8762          }
8763  
8764          if ( key === "closeText" ) {
8765              this.uiDialogTitlebarClose.button({
8766                  // Ensure that we always pass a string
8767                  label: "" + value
8768              });
8769          }
8770  
8771          if ( key === "draggable" ) {
8772              isDraggable = uiDialog.is( ":data(ui-draggable)" );
8773              if ( isDraggable && !value ) {
8774                  uiDialog.draggable( "destroy" );
8775              }
8776  
8777              if ( !isDraggable && value ) {
8778                  this._makeDraggable();
8779              }
8780          }
8781  
8782          if ( key === "position" ) {
8783              this._position();
8784          }
8785  
8786          if ( key === "resizable" ) {
8787              // currently resizable, becoming non-resizable
8788              isResizable = uiDialog.is( ":data(ui-resizable)" );
8789              if ( isResizable && !value ) {
8790                  uiDialog.resizable( "destroy" );
8791              }
8792  
8793              // currently resizable, changing handles
8794              if ( isResizable && typeof value === "string" ) {
8795                  uiDialog.resizable( "option", "handles", value );
8796              }
8797  
8798              // currently non-resizable, becoming resizable
8799              if ( !isResizable && value !== false ) {
8800                  this._makeResizable();
8801              }
8802          }
8803  
8804          if ( key === "title" ) {
8805              this._title( this.uiDialogTitlebar.find( ".ui-dialog-title" ) );
8806          }
8807      },
8808  
8809      _size: function() {
8810          // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
8811          // divs will both have width and height set, so we need to reset them
8812          var nonContentHeight, minContentHeight, maxContentHeight,
8813              options = this.options;
8814  
8815          // Reset content sizing
8816          this.element.show().css({
8817              width: "auto",
8818              minHeight: 0,
8819              maxHeight: "none",
8820              height: 0
8821          });
8822  
8823          if ( options.minWidth > options.width ) {
8824              options.width = options.minWidth;
8825          }
8826  
8827          // reset wrapper sizing
8828          // determine the height of all the non-content elements
8829          nonContentHeight = this.uiDialog.css({
8830                  height: "auto",
8831                  width: options.width
8832              })
8833              .outerHeight();
8834          minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
8835          maxContentHeight = typeof options.maxHeight === "number" ?
8836              Math.max( 0, options.maxHeight - nonContentHeight ) :
8837              "none";
8838  
8839          if ( options.height === "auto" ) {
8840              this.element.css({
8841                  minHeight: minContentHeight,
8842                  maxHeight: maxContentHeight,
8843                  height: "auto"
8844              });
8845          } else {
8846              this.element.height( Math.max( 0, options.height - nonContentHeight ) );
8847          }
8848  
8849          if ( this.uiDialog.is( ":data(ui-resizable)" ) ) {
8850              this.uiDialog.resizable( "option", "minHeight", this._minHeight() );
8851          }
8852      },
8853  
8854      _blockFrames: function() {
8855          this.iframeBlocks = this.document.find( "iframe" ).map(function() {
8856              var iframe = $( this );
8857  
8858              return $( "<div>" )
8859                  .css({
8860                      position: "absolute",
8861                      width: iframe.outerWidth(),
8862                      height: iframe.outerHeight()
8863                  })
8864                  .appendTo( iframe.parent() )
8865                  .offset( iframe.offset() )[0];
8866          });
8867      },
8868  
8869      _unblockFrames: function() {
8870          if ( this.iframeBlocks ) {
8871              this.iframeBlocks.remove();
8872              delete this.iframeBlocks;
8873          }
8874      },
8875  
8876      _allowInteraction: function( event ) {
8877          if ( $( event.target ).closest( ".ui-dialog" ).length ) {
8878              return true;
8879          }
8880  
8881          // TODO: Remove hack when datepicker implements
8882          // the .ui-front logic (#8989)
8883          return !!$( event.target ).closest( ".ui-datepicker" ).length;
8884      },
8885  
8886      _createOverlay: function() {
8887          if ( !this.options.modal ) {
8888              return;
8889          }
8890  
8891          // We use a delay in case the overlay is created from an
8892          // event that we're going to be cancelling (#2804)
8893          var isOpening = true;
8894          this._delay(function() {
8895              isOpening = false;
8896          });
8897  
8898          if ( !this.document.data( "ui-dialog-overlays" ) ) {
8899  
8900              // Prevent use of anchors and inputs
8901              // Using _on() for an event handler shared across many instances is
8902              // safe because the dialogs stack and must be closed in reverse order
8903              this._on( this.document, {
8904                  focusin: function( event ) {
8905                      if ( isOpening ) {
8906                          return;
8907                      }
8908  
8909                      if ( !this._allowInteraction( event ) ) {
8910                          event.preventDefault();
8911                          this._trackingInstances()[ 0 ]._focusTabbable();
8912                      }
8913                  }
8914              });
8915          }
8916  
8917          this.overlay = $( "<div>" )
8918              .addClass( "ui-widget-overlay ui-front" )
8919              .appendTo( this._appendTo() );
8920          this._on( this.overlay, {
8921              mousedown: "_keepFocus"
8922          });
8923          this.document.data( "ui-dialog-overlays",
8924              (this.document.data( "ui-dialog-overlays" ) || 0) + 1 );
8925      },
8926  
8927      _destroyOverlay: function() {
8928          if ( !this.options.modal ) {
8929              return;
8930          }
8931  
8932          if ( this.overlay ) {
8933              var overlays = this.document.data( "ui-dialog-overlays" ) - 1;
8934  
8935              if ( !overlays ) {
8936                  this.document
8937                      .unbind( "focusin" )
8938                      .removeData( "ui-dialog-overlays" );
8939              } else {
8940                  this.document.data( "ui-dialog-overlays", overlays );
8941              }
8942  
8943              this.overlay.remove();
8944              this.overlay = null;
8945          }
8946      }
8947  });
8948  
8949  
8950  /*!
8951   * jQuery UI Droppable 1.11.4
8952   * http://jqueryui.com
8953   *
8954   * Copyright jQuery Foundation and other contributors
8955   * Released under the MIT license.
8956   * http://jquery.org/license
8957   *
8958   * http://api.jqueryui.com/droppable/
8959   */
8960  
8961  
8962  $.widget( "ui.droppable", {
8963      version: "1.11.4",
8964      widgetEventPrefix: "drop",
8965      options: {
8966          accept: "*",
8967          activeClass: false,
8968          addClasses: true,
8969          greedy: false,
8970          hoverClass: false,
8971          scope: "default",
8972          tolerance: "intersect",
8973  
8974          // callbacks
8975          activate: null,
8976          deactivate: null,
8977          drop: null,
8978          out: null,
8979          over: null
8980      },
8981      _create: function() {
8982  
8983          var proportions,
8984              o = this.options,
8985              accept = o.accept;
8986  
8987          this.isover = false;
8988          this.isout = true;
8989  
8990          this.accept = $.isFunction( accept ) ? accept : function( d ) {
8991              return d.is( accept );
8992          };
8993  
8994          this.proportions = function( /* valueToWrite */ ) {
8995              if ( arguments.length ) {
8996                  // Store the droppable's proportions
8997                  proportions = arguments[ 0 ];
8998              } else {
8999                  // Retrieve or derive the droppable's proportions
9000                  return proportions ?
9001                      proportions :
9002                      proportions = {
9003                          width: this.element[ 0 ].offsetWidth,
9004                          height: this.element[ 0 ].offsetHeight
9005                      };
9006              }
9007          };
9008  
9009          this._addToManager( o.scope );
9010  
9011          o.addClasses && this.element.addClass( "ui-droppable" );
9012  
9013      },
9014  
9015      _addToManager: function( scope ) {
9016          // Add the reference and positions to the manager
9017          $.ui.ddmanager.droppables[ scope ] = $.ui.ddmanager.droppables[ scope ] || [];
9018          $.ui.ddmanager.droppables[ scope ].push( this );
9019      },
9020  
9021      _splice: function( drop ) {
9022          var i = 0;
9023          for ( ; i < drop.length; i++ ) {
9024              if ( drop[ i ] === this ) {
9025                  drop.splice( i, 1 );
9026              }
9027          }
9028      },
9029  
9030      _destroy: function() {
9031          var drop = $.ui.ddmanager.droppables[ this.options.scope ];
9032  
9033          this._splice( drop );
9034  
9035          this.element.removeClass( "ui-droppable ui-droppable-disabled" );
9036      },
9037  
9038      _setOption: function( key, value ) {
9039  
9040          if ( key === "accept" ) {
9041              this.accept = $.isFunction( value ) ? value : function( d ) {
9042                  return d.is( value );
9043              };
9044          } else if ( key === "scope" ) {
9045              var drop = $.ui.ddmanager.droppables[ this.options.scope ];
9046  
9047              this._splice( drop );
9048              this._addToManager( value );
9049          }
9050  
9051          this._super( key, value );
9052      },
9053  
9054      _activate: function( event ) {
9055          var draggable = $.ui.ddmanager.current;
9056          if ( this.options.activeClass ) {
9057              this.element.addClass( this.options.activeClass );
9058          }
9059          if ( draggable ){
9060              this._trigger( "activate", event, this.ui( draggable ) );
9061          }
9062      },
9063  
9064      _deactivate: function( event ) {
9065          var draggable = $.ui.ddmanager.current;
9066          if ( this.options.activeClass ) {
9067              this.element.removeClass( this.options.activeClass );
9068          }
9069          if ( draggable ){
9070              this._trigger( "deactivate", event, this.ui( draggable ) );
9071          }
9072      },
9073  
9074      _over: function( event ) {
9075  
9076          var draggable = $.ui.ddmanager.current;
9077  
9078          // Bail if draggable and droppable are same element
9079          if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
9080              return;
9081          }
9082  
9083          if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9084              if ( this.options.hoverClass ) {
9085                  this.element.addClass( this.options.hoverClass );
9086              }
9087              this._trigger( "over", event, this.ui( draggable ) );
9088          }
9089  
9090      },
9091  
9092      _out: function( event ) {
9093  
9094          var draggable = $.ui.ddmanager.current;
9095  
9096          // Bail if draggable and droppable are same element
9097          if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
9098              return;
9099          }
9100  
9101          if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9102              if ( this.options.hoverClass ) {
9103                  this.element.removeClass( this.options.hoverClass );
9104              }
9105              this._trigger( "out", event, this.ui( draggable ) );
9106          }
9107  
9108      },
9109  
9110      _drop: function( event, custom ) {
9111  
9112          var draggable = custom || $.ui.ddmanager.current,
9113              childrenIntersection = false;
9114  
9115          // Bail if draggable and droppable are same element
9116          if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
9117              return false;
9118          }
9119  
9120          this.element.find( ":data(ui-droppable)" ).not( ".ui-draggable-dragging" ).each(function() {
9121              var inst = $( this ).droppable( "instance" );
9122              if (
9123                  inst.options.greedy &&
9124                  !inst.options.disabled &&
9125                  inst.options.scope === draggable.options.scope &&
9126                  inst.accept.call( inst.element[ 0 ], ( draggable.currentItem || draggable.element ) ) &&
9127                  $.ui.intersect( draggable, $.extend( inst, { offset: inst.element.offset() } ), inst.options.tolerance, event )
9128              ) { childrenIntersection = true; return false; }
9129          });
9130          if ( childrenIntersection ) {
9131              return false;
9132          }
9133  
9134          if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9135              if ( this.options.activeClass ) {
9136                  this.element.removeClass( this.options.activeClass );
9137              }
9138              if ( this.options.hoverClass ) {
9139                  this.element.removeClass( this.options.hoverClass );
9140              }
9141              this._trigger( "drop", event, this.ui( draggable ) );
9142              return this.element;
9143          }
9144  
9145          return false;
9146  
9147      },
9148  
9149      ui: function( c ) {
9150          return {
9151              draggable: ( c.currentItem || c.element ),
9152              helper: c.helper,
9153              position: c.position,
9154              offset: c.positionAbs
9155          };
9156      }
9157  
9158  });
9159  
9160  $.ui.intersect = (function() {
9161  	function isOverAxis( x, reference, size ) {
9162          return ( x >= reference ) && ( x < ( reference + size ) );
9163      }
9164  
9165      return function( draggable, droppable, toleranceMode, event ) {
9166  
9167          if ( !droppable.offset ) {
9168              return false;
9169          }
9170  
9171          var x1 = ( draggable.positionAbs || draggable.position.absolute ).left + draggable.margins.left,
9172              y1 = ( draggable.positionAbs || draggable.position.absolute ).top + draggable.margins.top,
9173              x2 = x1 + draggable.helperProportions.width,
9174              y2 = y1 + draggable.helperProportions.height,
9175              l = droppable.offset.left,
9176              t = droppable.offset.top,
9177              r = l + droppable.proportions().width,
9178              b = t + droppable.proportions().height;
9179  
9180          switch ( toleranceMode ) {
9181          case "fit":
9182              return ( l <= x1 && x2 <= r && t <= y1 && y2 <= b );
9183          case "intersect":
9184              return ( l < x1 + ( draggable.helperProportions.width / 2 ) && // Right Half
9185                  x2 - ( draggable.helperProportions.width / 2 ) < r && // Left Half
9186                  t < y1 + ( draggable.helperProportions.height / 2 ) && // Bottom Half
9187                  y2 - ( draggable.helperProportions.height / 2 ) < b ); // Top Half
9188          case "pointer":
9189              return isOverAxis( event.pageY, t, droppable.proportions().height ) && isOverAxis( event.pageX, l, droppable.proportions().width );
9190          case "touch":
9191              return (
9192                  ( y1 >= t && y1 <= b ) || // Top edge touching
9193                  ( y2 >= t && y2 <= b ) || // Bottom edge touching
9194                  ( y1 < t && y2 > b ) // Surrounded vertically
9195              ) && (
9196                  ( x1 >= l && x1 <= r ) || // Left edge touching
9197                  ( x2 >= l && x2 <= r ) || // Right edge touching
9198                  ( x1 < l && x2 > r ) // Surrounded horizontally
9199              );
9200          default:
9201              return false;
9202          }
9203      };
9204  })();
9205  
9206  /*
9207      This manager tracks offsets of draggables and droppables
9208  */
9209  $.ui.ddmanager = {
9210      current: null,
9211      droppables: { "default": [] },
9212      prepareOffsets: function( t, event ) {
9213  
9214          var i, j,
9215              m = $.ui.ddmanager.droppables[ t.options.scope ] || [],
9216              type = event ? event.type : null, // workaround for #2317
9217              list = ( t.currentItem || t.element ).find( ":data(ui-droppable)" ).addBack();
9218  
9219          droppablesLoop: for ( i = 0; i < m.length; i++ ) {
9220  
9221              // No disabled and non-accepted
9222              if ( m[ i ].options.disabled || ( t && !m[ i ].accept.call( m[ i ].element[ 0 ], ( t.currentItem || t.element ) ) ) ) {
9223                  continue;
9224              }
9225  
9226              // Filter out elements in the current dragged item
9227              for ( j = 0; j < list.length; j++ ) {
9228                  if ( list[ j ] === m[ i ].element[ 0 ] ) {
9229                      m[ i ].proportions().height = 0;
9230                      continue droppablesLoop;
9231                  }
9232              }
9233  
9234              m[ i ].visible = m[ i ].element.css( "display" ) !== "none";
9235              if ( !m[ i ].visible ) {
9236                  continue;
9237              }
9238  
9239              // Activate the droppable if used directly from draggables
9240              if ( type === "mousedown" ) {
9241                  m[ i ]._activate.call( m[ i ], event );
9242              }
9243  
9244              m[ i ].offset = m[ i ].element.offset();
9245              m[ i ].proportions({ width: m[ i ].element[ 0 ].offsetWidth, height: m[ i ].element[ 0 ].offsetHeight });
9246  
9247          }
9248  
9249      },
9250      drop: function( draggable, event ) {
9251  
9252          var dropped = false;
9253          // Create a copy of the droppables in case the list changes during the drop (#9116)
9254          $.each( ( $.ui.ddmanager.droppables[ draggable.options.scope ] || [] ).slice(), function() {
9255  
9256              if ( !this.options ) {
9257                  return;
9258              }
9259              if ( !this.options.disabled && this.visible && $.ui.intersect( draggable, this, this.options.tolerance, event ) ) {
9260                  dropped = this._drop.call( this, event ) || dropped;
9261              }
9262  
9263              if ( !this.options.disabled && this.visible && this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9264                  this.isout = true;
9265                  this.isover = false;
9266                  this._deactivate.call( this, event );
9267              }
9268  
9269          });
9270          return dropped;
9271  
9272      },
9273      dragStart: function( draggable, event ) {
9274          // Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
9275          draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
9276              if ( !draggable.options.refreshPositions ) {
9277                  $.ui.ddmanager.prepareOffsets( draggable, event );
9278              }
9279          });
9280      },
9281      drag: function( draggable, event ) {
9282  
9283          // If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
9284          if ( draggable.options.refreshPositions ) {
9285              $.ui.ddmanager.prepareOffsets( draggable, event );
9286          }
9287  
9288          // Run through all droppables and check their positions based on specific tolerance options
9289          $.each( $.ui.ddmanager.droppables[ draggable.options.scope ] || [], function() {
9290  
9291              if ( this.options.disabled || this.greedyChild || !this.visible ) {
9292                  return;
9293              }
9294  
9295              var parentInstance, scope, parent,
9296                  intersects = $.ui.intersect( draggable, this, this.options.tolerance, event ),
9297                  c = !intersects && this.isover ? "isout" : ( intersects && !this.isover ? "isover" : null );
9298              if ( !c ) {
9299                  return;
9300              }
9301  
9302              if ( this.options.greedy ) {
9303                  // find droppable parents with same scope
9304                  scope = this.options.scope;
9305                  parent = this.element.parents( ":data(ui-droppable)" ).filter(function() {
9306                      return $( this ).droppable( "instance" ).options.scope === scope;
9307                  });
9308  
9309                  if ( parent.length ) {
9310                      parentInstance = $( parent[ 0 ] ).droppable( "instance" );
9311                      parentInstance.greedyChild = ( c === "isover" );
9312                  }
9313              }
9314  
9315              // we just moved into a greedy child
9316              if ( parentInstance && c === "isover" ) {
9317                  parentInstance.isover = false;
9318                  parentInstance.isout = true;
9319                  parentInstance._out.call( parentInstance, event );
9320              }
9321  
9322              this[ c ] = true;
9323              this[c === "isout" ? "isover" : "isout"] = false;
9324              this[c === "isover" ? "_over" : "_out"].call( this, event );
9325  
9326              // we just moved out of a greedy child
9327              if ( parentInstance && c === "isout" ) {
9328                  parentInstance.isout = false;
9329                  parentInstance.isover = true;
9330                  parentInstance._over.call( parentInstance, event );
9331              }
9332          });
9333  
9334      },
9335      dragStop: function( draggable, event ) {
9336          draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
9337          // Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
9338          if ( !draggable.options.refreshPositions ) {
9339              $.ui.ddmanager.prepareOffsets( draggable, event );
9340          }
9341      }
9342  };
9343  
9344  var droppable = $.ui.droppable;
9345  
9346  
9347  /*!
9348   * jQuery UI Effects 1.11.4
9349   * http://jqueryui.com
9350   *
9351   * Copyright jQuery Foundation and other contributors
9352   * Released under the MIT license.
9353   * http://jquery.org/license
9354   *
9355   * http://api.jqueryui.com/category/effects-core/
9356   */
9357  
9358  
9359  var dataSpace = "ui-effects-",
9360  
9361      // Create a local jQuery because jQuery Color relies on it and the
9362      // global may not exist with AMD and a custom build (#10199)
9363      jQuery = $;
9364  
9365  $.effects = {
9366      effect: {}
9367  };
9368  
9369  /*!
9370   * jQuery Color Animations v2.1.2
9371   * https://github.com/jquery/jquery-color
9372   *
9373   * Copyright 2014 jQuery Foundation and other contributors
9374   * Released under the MIT license.
9375   * http://jquery.org/license
9376   *
9377   * Date: Wed Jan 16 08:47:09 2013 -0600
9378   */
9379  (function( jQuery, undefined ) {
9380  
9381      var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
9382  
9383      // plusequals test for += 100 -= 100
9384      rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
9385      // a set of RE's that can match strings and generate color tuples.
9386      stringParsers = [ {
9387              re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
9388              parse: function( execResult ) {
9389                  return [
9390                      execResult[ 1 ],
9391                      execResult[ 2 ],
9392                      execResult[ 3 ],
9393                      execResult[ 4 ]
9394                  ];
9395              }
9396          }, {
9397              re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
9398              parse: function( execResult ) {
9399                  return [
9400                      execResult[ 1 ] * 2.55,
9401                      execResult[ 2 ] * 2.55,
9402                      execResult[ 3 ] * 2.55,
9403                      execResult[ 4 ]
9404                  ];
9405              }
9406          }, {
9407              // this regex ignores A-F because it's compared against an already lowercased string
9408              re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
9409              parse: function( execResult ) {
9410                  return [
9411                      parseInt( execResult[ 1 ], 16 ),
9412                      parseInt( execResult[ 2 ], 16 ),
9413                      parseInt( execResult[ 3 ], 16 )
9414                  ];
9415              }
9416          }, {
9417              // this regex ignores A-F because it's compared against an already lowercased string
9418              re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
9419              parse: function( execResult ) {
9420                  return [
9421                      parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
9422                      parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
9423                      parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
9424                  ];
9425              }
9426          }, {
9427              re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
9428              space: "hsla",
9429              parse: function( execResult ) {
9430                  return [
9431                      execResult[ 1 ],
9432                      execResult[ 2 ] / 100,
9433                      execResult[ 3 ] / 100,
9434                      execResult[ 4 ]
9435                  ];
9436              }
9437          } ],
9438  
9439      // jQuery.Color( )
9440      color = jQuery.Color = function( color, green, blue, alpha ) {
9441          return new jQuery.Color.fn.parse( color, green, blue, alpha );
9442      },
9443      spaces = {
9444          rgba: {
9445              props: {
9446                  red: {
9447                      idx: 0,
9448                      type: "byte"
9449                  },
9450                  green: {
9451                      idx: 1,
9452                      type: "byte"
9453                  },
9454                  blue: {
9455                      idx: 2,
9456                      type: "byte"
9457                  }
9458              }
9459          },
9460  
9461          hsla: {
9462              props: {
9463                  hue: {
9464                      idx: 0,
9465                      type: "degrees"
9466                  },
9467                  saturation: {
9468                      idx: 1,
9469                      type: "percent"
9470                  },
9471                  lightness: {
9472                      idx: 2,
9473                      type: "percent"
9474                  }
9475              }
9476          }
9477      },
9478      propTypes = {
9479          "byte": {
9480              floor: true,
9481              max: 255
9482          },
9483          "percent": {
9484              max: 1
9485          },
9486          "degrees": {
9487              mod: 360,
9488              floor: true
9489          }
9490      },
9491      support = color.support = {},
9492  
9493      // element for support tests
9494      supportElem = jQuery( "<p>" )[ 0 ],
9495  
9496      // colors = jQuery.Color.names
9497      colors,
9498  
9499      // local aliases of functions called often
9500      each = jQuery.each;
9501  
9502  // determine rgba support immediately
9503  supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
9504  support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
9505  
9506  // define cache name and alpha properties
9507  // for rgba and hsla spaces
9508  each( spaces, function( spaceName, space ) {
9509      space.cache = "_" + spaceName;
9510      space.props.alpha = {
9511          idx: 3,
9512          type: "percent",
9513          def: 1
9514      };
9515  });
9516  
9517  function clamp( value, prop, allowEmpty ) {
9518      var type = propTypes[ prop.type ] || {};
9519  
9520      if ( value == null ) {
9521          return (allowEmpty || !prop.def) ? null : prop.def;
9522      }
9523  
9524      // ~~ is an short way of doing floor for positive numbers
9525      value = type.floor ? ~~value : parseFloat( value );
9526  
9527      // IE will pass in empty strings as value for alpha,
9528      // which will hit this case
9529      if ( isNaN( value ) ) {
9530          return prop.def;
9531      }
9532  
9533      if ( type.mod ) {
9534          // we add mod before modding to make sure that negatives values
9535          // get converted properly: -10 -> 350
9536          return (value + type.mod) % type.mod;
9537      }
9538  
9539      // for now all property types without mod have min and max
9540      return 0 > value ? 0 : type.max < value ? type.max : value;
9541  }
9542  
9543  function stringParse( string ) {
9544      var inst = color(),
9545          rgba = inst._rgba = [];
9546  
9547      string = string.toLowerCase();
9548  
9549      each( stringParsers, function( i, parser ) {
9550          var parsed,
9551              match = parser.re.exec( string ),
9552              values = match && parser.parse( match ),
9553              spaceName = parser.space || "rgba";
9554  
9555          if ( values ) {
9556              parsed = inst[ spaceName ]( values );
9557  
9558              // if this was an rgba parse the assignment might happen twice
9559              // oh well....
9560              inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
9561              rgba = inst._rgba = parsed._rgba;
9562  
9563              // exit each( stringParsers ) here because we matched
9564              return false;
9565          }
9566      });
9567  
9568      // Found a stringParser that handled it
9569      if ( rgba.length ) {
9570  
9571          // if this came from a parsed string, force "transparent" when alpha is 0
9572          // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
9573          if ( rgba.join() === "0,0,0,0" ) {
9574              jQuery.extend( rgba, colors.transparent );
9575          }
9576          return inst;
9577      }
9578  
9579      // named colors
9580      return colors[ string ];
9581  }
9582  
9583  color.fn = jQuery.extend( color.prototype, {
9584      parse: function( red, green, blue, alpha ) {
9585          if ( red === undefined ) {
9586              this._rgba = [ null, null, null, null ];
9587              return this;
9588          }
9589          if ( red.jquery || red.nodeType ) {
9590              red = jQuery( red ).css( green );
9591              green = undefined;
9592          }
9593  
9594          var inst = this,
9595              type = jQuery.type( red ),
9596              rgba = this._rgba = [];
9597  
9598          // more than 1 argument specified - assume ( red, green, blue, alpha )
9599          if ( green !== undefined ) {
9600              red = [ red, green, blue, alpha ];
9601              type = "array";
9602          }
9603  
9604          if ( type === "string" ) {
9605              return this.parse( stringParse( red ) || colors._default );
9606          }
9607  
9608          if ( type === "array" ) {
9609              each( spaces.rgba.props, function( key, prop ) {
9610                  rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
9611              });
9612              return this;
9613          }
9614  
9615          if ( type === "object" ) {
9616              if ( red instanceof color ) {
9617                  each( spaces, function( spaceName, space ) {
9618                      if ( red[ space.cache ] ) {
9619                          inst[ space.cache ] = red[ space.cache ].slice();
9620                      }
9621                  });
9622              } else {
9623                  each( spaces, function( spaceName, space ) {
9624                      var cache = space.cache;
9625                      each( space.props, function( key, prop ) {
9626  
9627                          // if the cache doesn't exist, and we know how to convert
9628                          if ( !inst[ cache ] && space.to ) {
9629  
9630                              // if the value was null, we don't need to copy it
9631                              // if the key was alpha, we don't need to copy it either
9632                              if ( key === "alpha" || red[ key ] == null ) {
9633                                  return;
9634                              }
9635                              inst[ cache ] = space.to( inst._rgba );
9636                          }
9637  
9638                          // this is the only case where we allow nulls for ALL properties.
9639                          // call clamp with alwaysAllowEmpty
9640                          inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
9641                      });
9642  
9643                      // everything defined but alpha?
9644                      if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
9645                          // use the default of 1
9646                          inst[ cache ][ 3 ] = 1;
9647                          if ( space.from ) {
9648                              inst._rgba = space.from( inst[ cache ] );
9649                          }
9650                      }
9651                  });
9652              }
9653              return this;
9654          }
9655      },
9656      is: function( compare ) {
9657          var is = color( compare ),
9658              same = true,
9659              inst = this;
9660  
9661          each( spaces, function( _, space ) {
9662              var localCache,
9663                  isCache = is[ space.cache ];
9664              if (isCache) {
9665                  localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
9666                  each( space.props, function( _, prop ) {
9667                      if ( isCache[ prop.idx ] != null ) {
9668                          same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
9669                          return same;
9670                      }
9671                  });
9672              }
9673              return same;
9674          });
9675          return same;
9676      },
9677      _space: function() {
9678          var used = [],
9679              inst = this;
9680          each( spaces, function( spaceName, space ) {
9681              if ( inst[ space.cache ] ) {
9682                  used.push( spaceName );
9683              }
9684          });
9685          return used.pop();
9686      },
9687      transition: function( other, distance ) {
9688          var end = color( other ),
9689              spaceName = end._space(),
9690              space = spaces[ spaceName ],
9691              startColor = this.alpha() === 0 ? color( "transparent" ) : this,
9692              start = startColor[ space.cache ] || space.to( startColor._rgba ),
9693              result = start.slice();
9694  
9695          end = end[ space.cache ];
9696          each( space.props, function( key, prop ) {
9697              var index = prop.idx,
9698                  startValue = start[ index ],
9699                  endValue = end[ index ],
9700                  type = propTypes[ prop.type ] || {};
9701  
9702              // if null, don't override start value
9703              if ( endValue === null ) {
9704                  return;
9705              }
9706              // if null - use end
9707              if ( startValue === null ) {
9708                  result[ index ] = endValue;
9709              } else {
9710                  if ( type.mod ) {
9711                      if ( endValue - startValue > type.mod / 2 ) {
9712                          startValue += type.mod;
9713                      } else if ( startValue - endValue > type.mod / 2 ) {
9714                          startValue -= type.mod;
9715                      }
9716                  }
9717                  result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
9718              }
9719          });
9720          return this[ spaceName ]( result );
9721      },
9722      blend: function( opaque ) {
9723          // if we are already opaque - return ourself
9724          if ( this._rgba[ 3 ] === 1 ) {
9725              return this;
9726          }
9727  
9728          var rgb = this._rgba.slice(),
9729              a = rgb.pop(),
9730              blend = color( opaque )._rgba;
9731  
9732          return color( jQuery.map( rgb, function( v, i ) {
9733              return ( 1 - a ) * blend[ i ] + a * v;
9734          }));
9735      },
9736      toRgbaString: function() {
9737          var prefix = "rgba(",
9738              rgba = jQuery.map( this._rgba, function( v, i ) {
9739                  return v == null ? ( i > 2 ? 1 : 0 ) : v;
9740              });
9741  
9742          if ( rgba[ 3 ] === 1 ) {
9743              rgba.pop();
9744              prefix = "rgb(";
9745          }
9746  
9747          return prefix + rgba.join() + ")";
9748      },
9749      toHslaString: function() {
9750          var prefix = "hsla(",
9751              hsla = jQuery.map( this.hsla(), function( v, i ) {
9752                  if ( v == null ) {
9753                      v = i > 2 ? 1 : 0;
9754                  }
9755  
9756                  // catch 1 and 2
9757                  if ( i && i < 3 ) {
9758                      v = Math.round( v * 100 ) + "%";
9759                  }
9760                  return v;
9761              });
9762  
9763          if ( hsla[ 3 ] === 1 ) {
9764              hsla.pop();
9765              prefix = "hsl(";
9766          }
9767          return prefix + hsla.join() + ")";
9768      },
9769      toHexString: function( includeAlpha ) {
9770          var rgba = this._rgba.slice(),
9771              alpha = rgba.pop();
9772  
9773          if ( includeAlpha ) {
9774              rgba.push( ~~( alpha * 255 ) );
9775          }
9776  
9777          return "#" + jQuery.map( rgba, function( v ) {
9778  
9779              // default to 0 when nulls exist
9780              v = ( v || 0 ).toString( 16 );
9781              return v.length === 1 ? "0" + v : v;
9782          }).join("");
9783      },
9784      toString: function() {
9785          return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
9786      }
9787  });
9788  color.fn.parse.prototype = color.fn;
9789  
9790  // hsla conversions adapted from:
9791  // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
9792  
9793  function hue2rgb( p, q, h ) {
9794      h = ( h + 1 ) % 1;
9795      if ( h * 6 < 1 ) {
9796          return p + ( q - p ) * h * 6;
9797      }
9798      if ( h * 2 < 1) {
9799          return q;
9800      }
9801      if ( h * 3 < 2 ) {
9802          return p + ( q - p ) * ( ( 2 / 3 ) - h ) * 6;
9803      }
9804      return p;
9805  }
9806  
9807  spaces.hsla.to = function( rgba ) {
9808      if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
9809          return [ null, null, null, rgba[ 3 ] ];
9810      }
9811      var r = rgba[ 0 ] / 255,
9812          g = rgba[ 1 ] / 255,
9813          b = rgba[ 2 ] / 255,
9814          a = rgba[ 3 ],
9815          max = Math.max( r, g, b ),
9816          min = Math.min( r, g, b ),
9817          diff = max - min,
9818          add = max + min,
9819          l = add * 0.5,
9820          h, s;
9821  
9822      if ( min === max ) {
9823          h = 0;
9824      } else if ( r === max ) {
9825          h = ( 60 * ( g - b ) / diff ) + 360;
9826      } else if ( g === max ) {
9827          h = ( 60 * ( b - r ) / diff ) + 120;
9828      } else {
9829          h = ( 60 * ( r - g ) / diff ) + 240;
9830      }
9831  
9832      // chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
9833      // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
9834      if ( diff === 0 ) {
9835          s = 0;
9836      } else if ( l <= 0.5 ) {
9837          s = diff / add;
9838      } else {
9839          s = diff / ( 2 - add );
9840      }
9841      return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
9842  };
9843  
9844  spaces.hsla.from = function( hsla ) {
9845      if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
9846          return [ null, null, null, hsla[ 3 ] ];
9847      }
9848      var h = hsla[ 0 ] / 360,
9849          s = hsla[ 1 ],
9850          l = hsla[ 2 ],
9851          a = hsla[ 3 ],
9852          q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
9853          p = 2 * l - q;
9854  
9855      return [
9856          Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
9857          Math.round( hue2rgb( p, q, h ) * 255 ),
9858          Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
9859          a
9860      ];
9861  };
9862  
9863  each( spaces, function( spaceName, space ) {
9864      var props = space.props,
9865          cache = space.cache,
9866          to = space.to,
9867          from = space.from;
9868  
9869      // makes rgba() and hsla()
9870      color.fn[ spaceName ] = function( value ) {
9871  
9872          // generate a cache for this space if it doesn't exist
9873          if ( to && !this[ cache ] ) {
9874              this[ cache ] = to( this._rgba );
9875          }
9876          if ( value === undefined ) {
9877              return this[ cache ].slice();
9878          }
9879  
9880          var ret,
9881              type = jQuery.type( value ),
9882              arr = ( type === "array" || type === "object" ) ? value : arguments,
9883              local = this[ cache ].slice();
9884  
9885          each( props, function( key, prop ) {
9886              var val = arr[ type === "object" ? key : prop.idx ];
9887              if ( val == null ) {
9888                  val = local[ prop.idx ];
9889              }
9890              local[ prop.idx ] = clamp( val, prop );
9891          });
9892  
9893          if ( from ) {
9894              ret = color( from( local ) );
9895              ret[ cache ] = local;
9896              return ret;
9897          } else {
9898              return color( local );
9899          }
9900      };
9901  
9902      // makes red() green() blue() alpha() hue() saturation() lightness()
9903      each( props, function( key, prop ) {
9904          // alpha is included in more than one space
9905          if ( color.fn[ key ] ) {
9906              return;
9907          }
9908          color.fn[ key ] = function( value ) {
9909              var vtype = jQuery.type( value ),
9910                  fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
9911                  local = this[ fn ](),
9912                  cur = local[ prop.idx ],
9913                  match;
9914  
9915              if ( vtype === "undefined" ) {
9916                  return cur;
9917              }
9918  
9919              if ( vtype === "function" ) {
9920                  value = value.call( this, cur );
9921                  vtype = jQuery.type( value );
9922              }
9923              if ( value == null && prop.empty ) {
9924                  return this;
9925              }
9926              if ( vtype === "string" ) {
9927                  match = rplusequals.exec( value );
9928                  if ( match ) {
9929                      value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
9930                  }
9931              }
9932              local[ prop.idx ] = value;
9933              return this[ fn ]( local );
9934          };
9935      });
9936  });
9937  
9938  // add cssHook and .fx.step function for each named hook.
9939  // accept a space separated string of properties
9940  color.hook = function( hook ) {
9941      var hooks = hook.split( " " );
9942      each( hooks, function( i, hook ) {
9943          jQuery.cssHooks[ hook ] = {
9944              set: function( elem, value ) {
9945                  var parsed, curElem,
9946                      backgroundColor = "";
9947  
9948                  if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
9949                      value = color( parsed || value );
9950                      if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
9951                          curElem = hook === "backgroundColor" ? elem.parentNode : elem;
9952                          while (
9953                              (backgroundColor === "" || backgroundColor === "transparent") &&
9954                              curElem && curElem.style
9955                          ) {
9956                              try {
9957                                  backgroundColor = jQuery.css( curElem, "backgroundColor" );
9958                                  curElem = curElem.parentNode;
9959                              } catch ( e ) {
9960                              }
9961                          }
9962  
9963                          value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
9964                              backgroundColor :
9965                              "_default" );
9966                      }
9967  
9968                      value = value.toRgbaString();
9969                  }
9970                  try {
9971                      elem.style[ hook ] = value;
9972                  } catch ( e ) {
9973                      // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
9974                  }
9975              }
9976          };
9977          jQuery.fx.step[ hook ] = function( fx ) {
9978              if ( !fx.colorInit ) {
9979                  fx.start = color( fx.elem, hook );
9980                  fx.end = color( fx.end );
9981                  fx.colorInit = true;
9982              }
9983              jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
9984          };
9985      });
9986  
9987  };
9988  
9989  color.hook( stepHooks );
9990  
9991  jQuery.cssHooks.borderColor = {
9992      expand: function( value ) {
9993          var expanded = {};
9994  
9995          each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
9996              expanded[ "border" + part + "Color" ] = value;
9997          });
9998          return expanded;
9999      }
10000  };
10001  
10002  // Basic color names only.
10003  // Usage of any of the other color names requires adding yourself or including
10004  // jquery.color.svg-names.js.
10005  colors = jQuery.Color.names = {
10006      // 4.1. Basic color keywords
10007      aqua: "#00ffff",
10008      black: "#000000",
10009      blue: "#0000ff",
10010      fuchsia: "#ff00ff",
10011      gray: "#808080",
10012      green: "#008000",
10013      lime: "#00ff00",
10014      maroon: "#800000",
10015      navy: "#000080",
10016      olive: "#808000",
10017      purple: "#800080",
10018      red: "#ff0000",
10019      silver: "#c0c0c0",
10020      teal: "#008080",
10021      white: "#ffffff",
10022      yellow: "#ffff00",
10023  
10024      // 4.2.3. "transparent" color keyword
10025      transparent: [ null, null, null, 0 ],
10026  
10027      _default: "#ffffff"
10028  };
10029  
10030  })( jQuery );
10031  
10032  /******************************************************************************/
10033  /****************************** CLASS ANIMATIONS ******************************/
10034  /******************************************************************************/
10035  (function() {
10036  
10037  var classAnimationActions = [ "add", "remove", "toggle" ],
10038      shorthandStyles = {
10039          border: 1,
10040          borderBottom: 1,
10041          borderColor: 1,
10042          borderLeft: 1,
10043          borderRight: 1,
10044          borderTop: 1,
10045          borderWidth: 1,
10046          margin: 1,
10047          padding: 1
10048      };
10049  
10050  $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
10051      $.fx.step[ prop ] = function( fx ) {
10052          if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
10053              jQuery.style( fx.elem, prop, fx.end );
10054              fx.setAttr = true;
10055          }
10056      };
10057  });
10058  
10059  function getElementStyles( elem ) {
10060      var key, len,
10061          style = elem.ownerDocument.defaultView ?
10062              elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
10063              elem.currentStyle,
10064          styles = {};
10065  
10066      if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
10067          len = style.length;
10068          while ( len-- ) {
10069              key = style[ len ];
10070              if ( typeof style[ key ] === "string" ) {
10071                  styles[ $.camelCase( key ) ] = style[ key ];
10072              }
10073          }
10074      // support: Opera, IE <9
10075      } else {
10076          for ( key in style ) {
10077              if ( typeof style[ key ] === "string" ) {
10078                  styles[ key ] = style[ key ];
10079              }
10080          }
10081      }
10082  
10083      return styles;
10084  }
10085  
10086  function styleDifference( oldStyle, newStyle ) {
10087      var diff = {},
10088          name, value;
10089  
10090      for ( name in newStyle ) {
10091          value = newStyle[ name ];
10092          if ( oldStyle[ name ] !== value ) {
10093              if ( !shorthandStyles[ name ] ) {
10094                  if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
10095                      diff[ name ] = value;
10096                  }
10097              }
10098          }
10099      }
10100  
10101      return diff;
10102  }
10103  
10104  // support: jQuery <1.8
10105  if ( !$.fn.addBack ) {
10106      $.fn.addBack = function( selector ) {
10107          return this.add( selector == null ?
10108              this.prevObject : this.prevObject.filter( selector )
10109          );
10110      };
10111  }
10112  
10113  $.effects.animateClass = function( value, duration, easing, callback ) {
10114      var o = $.speed( duration, easing, callback );
10115  
10116      return this.queue( function() {
10117          var animated = $( this ),
10118              baseClass = animated.attr( "class" ) || "",
10119              applyClassChange,
10120              allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
10121  
10122          // map the animated objects to store the original styles.
10123          allAnimations = allAnimations.map(function() {
10124              var el = $( this );
10125              return {
10126                  el: el,
10127                  start: getElementStyles( this )
10128              };
10129          });
10130  
10131          // apply class change
10132          applyClassChange = function() {
10133              $.each( classAnimationActions, function(i, action) {
10134                  if ( value[ action ] ) {
10135                      animated[ action + "Class" ]( value[ action ] );
10136                  }
10137              });
10138          };
10139          applyClassChange();
10140  
10141          // map all animated objects again - calculate new styles and diff
10142          allAnimations = allAnimations.map(function() {
10143              this.end = getElementStyles( this.el[ 0 ] );
10144              this.diff = styleDifference( this.start, this.end );
10145              return this;
10146          });
10147  
10148          // apply original class
10149          animated.attr( "class", baseClass );
10150  
10151          // map all animated objects again - this time collecting a promise
10152          allAnimations = allAnimations.map(function() {
10153              var styleInfo = this,
10154                  dfd = $.Deferred(),
10155                  opts = $.extend({}, o, {
10156                      queue: false,
10157                      complete: function() {
10158                          dfd.resolve( styleInfo );
10159                      }
10160                  });
10161  
10162              this.el.animate( this.diff, opts );
10163              return dfd.promise();
10164          });
10165  
10166          // once all animations have completed:
10167          $.when.apply( $, allAnimations.get() ).done(function() {
10168  
10169              // set the final class
10170              applyClassChange();
10171  
10172              // for each animated element,
10173              // clear all css properties that were animated
10174              $.each( arguments, function() {
10175                  var el = this.el;
10176                  $.each( this.diff, function(key) {
10177                      el.css( key, "" );
10178                  });
10179              });
10180  
10181              // this is guarnteed to be there if you use jQuery.speed()
10182              // it also handles dequeuing the next anim...
10183              o.complete.call( animated[ 0 ] );
10184          });
10185      });
10186  };
10187  
10188  $.fn.extend({
10189      addClass: (function( orig ) {
10190          return function( classNames, speed, easing, callback ) {
10191              return speed ?
10192                  $.effects.animateClass.call( this,
10193                      { add: classNames }, speed, easing, callback ) :
10194                  orig.apply( this, arguments );
10195          };
10196      })( $.fn.addClass ),
10197  
10198      removeClass: (function( orig ) {
10199          return function( classNames, speed, easing, callback ) {
10200              return arguments.length > 1 ?
10201                  $.effects.animateClass.call( this,
10202                      { remove: classNames }, speed, easing, callback ) :
10203                  orig.apply( this, arguments );
10204          };
10205      })( $.fn.removeClass ),
10206  
10207      toggleClass: (function( orig ) {
10208          return function( classNames, force, speed, easing, callback ) {
10209              if ( typeof force === "boolean" || force === undefined ) {
10210                  if ( !speed ) {
10211                      // without speed parameter
10212                      return orig.apply( this, arguments );
10213                  } else {
10214                      return $.effects.animateClass.call( this,
10215                          (force ? { add: classNames } : { remove: classNames }),
10216                          speed, easing, callback );
10217                  }
10218              } else {
10219                  // without force parameter
10220                  return $.effects.animateClass.call( this,
10221                      { toggle: classNames }, force, speed, easing );
10222              }
10223          };
10224      })( $.fn.toggleClass ),
10225  
10226      switchClass: function( remove, add, speed, easing, callback) {
10227          return $.effects.animateClass.call( this, {
10228              add: add,
10229              remove: remove
10230          }, speed, easing, callback );
10231      }
10232  });
10233  
10234  })();
10235  
10236  /******************************************************************************/
10237  /*********************************** EFFECTS **********************************/
10238  /******************************************************************************/
10239  
10240  (function() {
10241  
10242  $.extend( $.effects, {
10243      version: "1.11.4",
10244  
10245      // Saves a set of properties in a data storage
10246      save: function( element, set ) {
10247          for ( var i = 0; i < set.length; i++ ) {
10248              if ( set[ i ] !== null ) {
10249                  element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
10250              }
10251          }
10252      },
10253  
10254      // Restores a set of previously saved properties from a data storage
10255      restore: function( element, set ) {
10256          var val, i;
10257          for ( i = 0; i < set.length; i++ ) {
10258              if ( set[ i ] !== null ) {
10259                  val = element.data( dataSpace + set[ i ] );
10260                  // support: jQuery 1.6.2
10261                  // http://bugs.jquery.com/ticket/9917
10262                  // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
10263                  // We can't differentiate between "" and 0 here, so we just assume
10264                  // empty string since it's likely to be a more common value...
10265                  if ( val === undefined ) {
10266                      val = "";
10267                  }
10268                  element.css( set[ i ], val );
10269              }
10270          }
10271      },
10272  
10273      setMode: function( el, mode ) {
10274          if (mode === "toggle") {
10275              mode = el.is( ":hidden" ) ? "show" : "hide";
10276          }
10277          return mode;
10278      },
10279  
10280      // Translates a [top,left] array into a baseline value
10281      // this should be a little more flexible in the future to handle a string & hash
10282      getBaseline: function( origin, original ) {
10283          var y, x;
10284          switch ( origin[ 0 ] ) {
10285              case "top": y = 0; break;
10286              case "middle": y = 0.5; break;
10287              case "bottom": y = 1; break;
10288              default: y = origin[ 0 ] / original.height;
10289          }
10290          switch ( origin[ 1 ] ) {
10291              case "left": x = 0; break;
10292              case "center": x = 0.5; break;
10293              case "right": x = 1; break;
10294              default: x = origin[ 1 ] / original.width;
10295          }
10296          return {
10297              x: x,
10298              y: y
10299          };
10300      },
10301  
10302      // Wraps the element around a wrapper that copies position properties
10303      createWrapper: function( element ) {
10304  
10305          // if the element is already wrapped, return it
10306          if ( element.parent().is( ".ui-effects-wrapper" )) {
10307              return element.parent();
10308          }
10309  
10310          // wrap the element
10311          var props = {
10312                  width: element.outerWidth(true),
10313                  height: element.outerHeight(true),
10314                  "float": element.css( "float" )
10315              },
10316              wrapper = $( "<div></div>" )
10317                  .addClass( "ui-effects-wrapper" )
10318                  .css({
10319                      fontSize: "100%",
10320                      background: "transparent",
10321                      border: "none",
10322                      margin: 0,
10323                      padding: 0
10324                  }),
10325              // Store the size in case width/height are defined in % - Fixes #5245
10326              size = {
10327                  width: element.width(),
10328                  height: element.height()
10329              },
10330              active = document.activeElement;
10331  
10332          // support: Firefox
10333          // Firefox incorrectly exposes anonymous content
10334          // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
10335          try {
10336              active.id;
10337          } catch ( e ) {
10338              active = document.body;
10339          }
10340  
10341          element.wrap( wrapper );
10342  
10343          // Fixes #7595 - Elements lose focus when wrapped.
10344          if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
10345              $( active ).focus();
10346          }
10347  
10348          wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
10349  
10350          // transfer positioning properties to the wrapper
10351          if ( element.css( "position" ) === "static" ) {
10352              wrapper.css({ position: "relative" });
10353              element.css({ position: "relative" });
10354          } else {
10355              $.extend( props, {
10356                  position: element.css( "position" ),
10357                  zIndex: element.css( "z-index" )
10358              });
10359              $.each([ "top", "left", "bottom", "right" ], function(i, pos) {
10360                  props[ pos ] = element.css( pos );
10361                  if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
10362                      props[ pos ] = "auto";
10363                  }
10364              });
10365              element.css({
10366                  position: "relative",
10367                  top: 0,
10368                  left: 0,
10369                  right: "auto",
10370                  bottom: "auto"
10371              });
10372          }
10373          element.css(size);
10374  
10375          return wrapper.css( props ).show();
10376      },
10377  
10378      removeWrapper: function( element ) {
10379          var active = document.activeElement;
10380  
10381          if ( element.parent().is( ".ui-effects-wrapper" ) ) {
10382              element.parent().replaceWith( element );
10383  
10384              // Fixes #7595 - Elements lose focus when wrapped.
10385              if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
10386                  $( active ).focus();
10387              }
10388          }
10389  
10390          return element;
10391      },
10392  
10393      setTransition: function( element, list, factor, value ) {
10394          value = value || {};
10395          $.each( list, function( i, x ) {
10396              var unit = element.cssUnit( x );
10397              if ( unit[ 0 ] > 0 ) {
10398                  value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
10399              }
10400          });
10401          return value;
10402      }
10403  });
10404  
10405  // return an effect options object for the given parameters:
10406  function _normalizeArguments( effect, options, speed, callback ) {
10407  
10408      // allow passing all options as the first parameter
10409      if ( $.isPlainObject( effect ) ) {
10410          options = effect;
10411          effect = effect.effect;
10412      }
10413  
10414      // convert to an object
10415      effect = { effect: effect };
10416  
10417      // catch (effect, null, ...)
10418      if ( options == null ) {
10419          options = {};
10420      }
10421  
10422      // catch (effect, callback)
10423      if ( $.isFunction( options ) ) {
10424          callback = options;
10425          speed = null;
10426          options = {};
10427      }
10428  
10429      // catch (effect, speed, ?)
10430      if ( typeof options === "number" || $.fx.speeds[ options ] ) {
10431          callback = speed;
10432          speed = options;
10433          options = {};
10434      }
10435  
10436      // catch (effect, options, callback)
10437      if ( $.isFunction( speed ) ) {
10438          callback = speed;
10439          speed = null;
10440      }
10441  
10442      // add options to effect
10443      if ( options ) {
10444          $.extend( effect, options );
10445      }
10446  
10447      speed = speed || options.duration;
10448      effect.duration = $.fx.off ? 0 :
10449          typeof speed === "number" ? speed :
10450          speed in $.fx.speeds ? $.fx.speeds[ speed ] :
10451          $.fx.speeds._default;
10452  
10453      effect.complete = callback || options.complete;
10454  
10455      return effect;
10456  }
10457  
10458  function standardAnimationOption( option ) {
10459      // Valid standard speeds (nothing, number, named speed)
10460      if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
10461          return true;
10462      }
10463  
10464      // Invalid strings - treat as "normal" speed
10465      if ( typeof option === "string" && !$.effects.effect[ option ] ) {
10466          return true;
10467      }
10468  
10469      // Complete callback
10470      if ( $.isFunction( option ) ) {
10471          return true;
10472      }
10473  
10474      // Options hash (but not naming an effect)
10475      if ( typeof option === "object" && !option.effect ) {
10476          return true;
10477      }
10478  
10479      // Didn't match any standard API
10480      return false;
10481  }
10482  
10483  $.fn.extend({
10484      effect: function( /* effect, options, speed, callback */ ) {
10485          var args = _normalizeArguments.apply( this, arguments ),
10486              mode = args.mode,
10487              queue = args.queue,
10488              effectMethod = $.effects.effect[ args.effect ];
10489  
10490          if ( $.fx.off || !effectMethod ) {
10491              // delegate to the original method (e.g., .show()) if possible
10492              if ( mode ) {
10493                  return this[ mode ]( args.duration, args.complete );
10494              } else {
10495                  return this.each( function() {
10496                      if ( args.complete ) {
10497                          args.complete.call( this );
10498                      }
10499                  });
10500              }
10501          }
10502  
10503  		function run( next ) {
10504              var elem = $( this ),
10505                  complete = args.complete,
10506                  mode = args.mode;
10507  
10508  			function done() {
10509                  if ( $.isFunction( complete ) ) {
10510                      complete.call( elem[0] );
10511                  }
10512                  if ( $.isFunction( next ) ) {
10513                      next();
10514                  }
10515              }
10516  
10517              // If the element already has the correct final state, delegate to
10518              // the core methods so the internal tracking of "olddisplay" works.
10519              if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
10520                  elem[ mode ]();
10521                  done();
10522              } else {
10523                  effectMethod.call( elem[0], args, done );
10524              }
10525          }
10526  
10527          return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
10528      },
10529  
10530      show: (function( orig ) {
10531          return function( option ) {
10532              if ( standardAnimationOption( option ) ) {
10533                  return orig.apply( this, arguments );
10534              } else {
10535                  var args = _normalizeArguments.apply( this, arguments );
10536                  args.mode = "show";
10537                  return this.effect.call( this, args );
10538              }
10539          };
10540      })( $.fn.show ),
10541  
10542      hide: (function( orig ) {
10543          return function( option ) {
10544              if ( standardAnimationOption( option ) ) {
10545                  return orig.apply( this, arguments );
10546              } else {
10547                  var args = _normalizeArguments.apply( this, arguments );
10548                  args.mode = "hide";
10549                  return this.effect.call( this, args );
10550              }
10551          };
10552      })( $.fn.hide ),
10553  
10554      toggle: (function( orig ) {
10555          return function( option ) {
10556              if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
10557                  return orig.apply( this, arguments );
10558              } else {
10559                  var args = _normalizeArguments.apply( this, arguments );
10560                  args.mode = "toggle";
10561                  return this.effect.call( this, args );
10562              }
10563          };
10564      })( $.fn.toggle ),
10565  
10566      // helper functions
10567      cssUnit: function(key) {
10568          var style = this.css( key ),
10569              val = [];
10570  
10571          $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
10572              if ( style.indexOf( unit ) > 0 ) {
10573                  val = [ parseFloat( style ), unit ];
10574              }
10575          });
10576          return val;
10577      }
10578  });
10579  
10580  })();
10581  
10582  /******************************************************************************/
10583  /*********************************** EASING ***********************************/
10584  /******************************************************************************/
10585  
10586  (function() {
10587  
10588  // based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
10589  
10590  var baseEasings = {};
10591  
10592  $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
10593      baseEasings[ name ] = function( p ) {
10594          return Math.pow( p, i + 2 );
10595      };
10596  });
10597  
10598  $.extend( baseEasings, {
10599      Sine: function( p ) {
10600          return 1 - Math.cos( p * Math.PI / 2 );
10601      },
10602      Circ: function( p ) {
10603          return 1 - Math.sqrt( 1 - p * p );
10604      },
10605      Elastic: function( p ) {
10606          return p === 0 || p === 1 ? p :
10607              -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
10608      },
10609      Back: function( p ) {
10610          return p * p * ( 3 * p - 2 );
10611      },
10612      Bounce: function( p ) {
10613          var pow2,
10614              bounce = 4;
10615  
10616          while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
10617          return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
10618      }
10619  });
10620  
10621  $.each( baseEasings, function( name, easeIn ) {
10622      $.easing[ "easeIn" + name ] = easeIn;
10623      $.easing[ "easeOut" + name ] = function( p ) {
10624          return 1 - easeIn( 1 - p );
10625      };
10626      $.easing[ "easeInOut" + name ] = function( p ) {
10627          return p < 0.5 ?
10628              easeIn( p * 2 ) / 2 :
10629              1 - easeIn( p * -2 + 2 ) / 2;
10630      };
10631  });
10632  
10633  })();
10634  
10635  var effect = $.effects;
10636  
10637  
10638  /*!
10639   * jQuery UI Effects Blind 1.11.4
10640   * http://jqueryui.com
10641   *
10642   * Copyright jQuery Foundation and other contributors
10643   * Released under the MIT license.
10644   * http://jquery.org/license
10645   *
10646   * http://api.jqueryui.com/blind-effect/
10647   */
10648  
10649  
10650  var effectBlind = $.effects.effect.blind = function( o, done ) {
10651      // Create element
10652      var el = $( this ),
10653          rvertical = /up|down|vertical/,
10654          rpositivemotion = /up|left|vertical|horizontal/,
10655          props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10656          mode = $.effects.setMode( el, o.mode || "hide" ),
10657          direction = o.direction || "up",
10658          vertical = rvertical.test( direction ),
10659          ref = vertical ? "height" : "width",
10660          ref2 = vertical ? "top" : "left",
10661          motion = rpositivemotion.test( direction ),
10662          animation = {},
10663          show = mode === "show",
10664          wrapper, distance, margin;
10665  
10666      // if already wrapped, the wrapper's properties are my property. #6245
10667      if ( el.parent().is( ".ui-effects-wrapper" ) ) {
10668          $.effects.save( el.parent(), props );
10669      } else {
10670          $.effects.save( el, props );
10671      }
10672      el.show();
10673      wrapper = $.effects.createWrapper( el ).css({
10674          overflow: "hidden"
10675      });
10676  
10677      distance = wrapper[ ref ]();
10678      margin = parseFloat( wrapper.css( ref2 ) ) || 0;
10679  
10680      animation[ ref ] = show ? distance : 0;
10681      if ( !motion ) {
10682          el
10683              .css( vertical ? "bottom" : "right", 0 )
10684              .css( vertical ? "top" : "left", "auto" )
10685              .css({ position: "absolute" });
10686  
10687          animation[ ref2 ] = show ? margin : distance + margin;
10688      }
10689  
10690      // start at 0 if we are showing
10691      if ( show ) {
10692          wrapper.css( ref, 0 );
10693          if ( !motion ) {
10694              wrapper.css( ref2, margin + distance );
10695          }
10696      }
10697  
10698      // Animate
10699      wrapper.animate( animation, {
10700          duration: o.duration,
10701          easing: o.easing,
10702          queue: false,
10703          complete: function() {
10704              if ( mode === "hide" ) {
10705                  el.hide();
10706              }
10707              $.effects.restore( el, props );
10708              $.effects.removeWrapper( el );
10709              done();
10710          }
10711      });
10712  };
10713  
10714  
10715  /*!
10716   * jQuery UI Effects Bounce 1.11.4
10717   * http://jqueryui.com
10718   *
10719   * Copyright jQuery Foundation and other contributors
10720   * Released under the MIT license.
10721   * http://jquery.org/license
10722   *
10723   * http://api.jqueryui.com/bounce-effect/
10724   */
10725  
10726  
10727  var effectBounce = $.effects.effect.bounce = function( o, done ) {
10728      var el = $( this ),
10729          props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10730  
10731          // defaults:
10732          mode = $.effects.setMode( el, o.mode || "effect" ),
10733          hide = mode === "hide",
10734          show = mode === "show",
10735          direction = o.direction || "up",
10736          distance = o.distance,
10737          times = o.times || 5,
10738  
10739          // number of internal animations
10740          anims = times * 2 + ( show || hide ? 1 : 0 ),
10741          speed = o.duration / anims,
10742          easing = o.easing,
10743  
10744          // utility:
10745          ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
10746          motion = ( direction === "up" || direction === "left" ),
10747          i,
10748          upAnim,
10749          downAnim,
10750  
10751          // we will need to re-assemble the queue to stack our animations in place
10752          queue = el.queue(),
10753          queuelen = queue.length;
10754  
10755      // Avoid touching opacity to prevent clearType and PNG issues in IE
10756      if ( show || hide ) {
10757          props.push( "opacity" );
10758      }
10759  
10760      $.effects.save( el, props );
10761      el.show();
10762      $.effects.createWrapper( el ); // Create Wrapper
10763  
10764      // default distance for the BIGGEST bounce is the outer Distance / 3
10765      if ( !distance ) {
10766          distance = el[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
10767      }
10768  
10769      if ( show ) {
10770          downAnim = { opacity: 1 };
10771          downAnim[ ref ] = 0;
10772  
10773          // if we are showing, force opacity 0 and set the initial position
10774          // then do the "first" animation
10775          el.css( "opacity", 0 )
10776              .css( ref, motion ? -distance * 2 : distance * 2 )
10777              .animate( downAnim, speed, easing );
10778      }
10779  
10780      // start at the smallest distance if we are hiding
10781      if ( hide ) {
10782          distance = distance / Math.pow( 2, times - 1 );
10783      }
10784  
10785      downAnim = {};
10786      downAnim[ ref ] = 0;
10787      // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
10788      for ( i = 0; i < times; i++ ) {
10789          upAnim = {};
10790          upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
10791  
10792          el.animate( upAnim, speed, easing )
10793              .animate( downAnim, speed, easing );
10794  
10795          distance = hide ? distance * 2 : distance / 2;
10796      }
10797  
10798      // Last Bounce when Hiding
10799      if ( hide ) {
10800          upAnim = { opacity: 0 };
10801          upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
10802  
10803          el.animate( upAnim, speed, easing );
10804      }
10805  
10806      el.queue(function() {
10807          if ( hide ) {
10808              el.hide();
10809          }
10810          $.effects.restore( el, props );
10811          $.effects.removeWrapper( el );
10812          done();
10813      });
10814  
10815      // inject all the animations we just queued to be first in line (after "inprogress")
10816      if ( queuelen > 1) {
10817          queue.splice.apply( queue,
10818              [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
10819      }
10820      el.dequeue();
10821  
10822  };
10823  
10824  
10825  /*!
10826   * jQuery UI Effects Clip 1.11.4
10827   * http://jqueryui.com
10828   *
10829   * Copyright jQuery Foundation and other contributors
10830   * Released under the MIT license.
10831   * http://jquery.org/license
10832   *
10833   * http://api.jqueryui.com/clip-effect/
10834   */
10835  
10836  
10837  var effectClip = $.effects.effect.clip = function( o, done ) {
10838      // Create element
10839      var el = $( this ),
10840          props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10841          mode = $.effects.setMode( el, o.mode || "hide" ),
10842          show = mode === "show",
10843          direction = o.direction || "vertical",
10844          vert = direction === "vertical",
10845          size = vert ? "height" : "width",
10846          position = vert ? "top" : "left",
10847          animation = {},
10848          wrapper, animate, distance;
10849  
10850      // Save & Show
10851      $.effects.save( el, props );
10852      el.show();
10853  
10854      // Create Wrapper
10855      wrapper = $.effects.createWrapper( el ).css({
10856          overflow: "hidden"
10857      });
10858      animate = ( el[0].tagName === "IMG" ) ? wrapper : el;
10859      distance = animate[ size ]();
10860  
10861      // Shift
10862      if ( show ) {
10863          animate.css( size, 0 );
10864          animate.css( position, distance / 2 );
10865      }
10866  
10867      // Create Animation Object:
10868      animation[ size ] = show ? distance : 0;
10869      animation[ position ] = show ? 0 : distance / 2;
10870  
10871      // Animate
10872      animate.animate( animation, {
10873          queue: false,
10874          duration: o.duration,
10875          easing: o.easing,
10876          complete: function() {
10877              if ( !show ) {
10878                  el.hide();
10879              }
10880              $.effects.restore( el, props );
10881              $.effects.removeWrapper( el );
10882              done();
10883          }
10884      });
10885  
10886  };
10887  
10888  
10889  /*!
10890   * jQuery UI Effects Drop 1.11.4
10891   * http://jqueryui.com
10892   *
10893   * Copyright jQuery Foundation and other contributors
10894   * Released under the MIT license.
10895   * http://jquery.org/license
10896   *
10897   * http://api.jqueryui.com/drop-effect/
10898   */
10899  
10900  
10901  var effectDrop = $.effects.effect.drop = function( o, done ) {
10902  
10903      var el = $( this ),
10904          props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
10905          mode = $.effects.setMode( el, o.mode || "hide" ),
10906          show = mode === "show",
10907          direction = o.direction || "left",
10908          ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
10909          motion = ( direction === "up" || direction === "left" ) ? "pos" : "neg",
10910          animation = {
10911              opacity: show ? 1 : 0
10912          },
10913          distance;
10914  
10915      // Adjust
10916      $.effects.save( el, props );
10917      el.show();
10918      $.effects.createWrapper( el );
10919  
10920      distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ) / 2;
10921  
10922      if ( show ) {
10923          el
10924              .css( "opacity", 0 )
10925              .css( ref, motion === "pos" ? -distance : distance );
10926      }
10927  
10928      // Animation
10929      animation[ ref ] = ( show ?
10930          ( motion === "pos" ? "+=" : "-=" ) :
10931          ( motion === "pos" ? "-=" : "+=" ) ) +
10932          distance;
10933  
10934      // Animate
10935      el.animate( animation, {
10936          queue: false,
10937          duration: o.duration,
10938          easing: o.easing,
10939          complete: function() {
10940              if ( mode === "hide" ) {
10941                  el.hide();
10942              }
10943              $.effects.restore( el, props );
10944              $.effects.removeWrapper( el );
10945              done();
10946          }
10947      });
10948  };
10949  
10950  
10951  /*!
10952   * jQuery UI Effects Explode 1.11.4
10953   * http://jqueryui.com
10954   *
10955   * Copyright jQuery Foundation and other contributors
10956   * Released under the MIT license.
10957   * http://jquery.org/license
10958   *
10959   * http://api.jqueryui.com/explode-effect/
10960   */
10961  
10962  
10963  var effectExplode = $.effects.effect.explode = function( o, done ) {
10964  
10965      var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3,
10966          cells = rows,
10967          el = $( this ),
10968          mode = $.effects.setMode( el, o.mode || "hide" ),
10969          show = mode === "show",
10970  
10971          // show and then visibility:hidden the element before calculating offset
10972          offset = el.show().css( "visibility", "hidden" ).offset(),
10973  
10974          // width and height of a piece
10975          width = Math.ceil( el.outerWidth() / cells ),
10976          height = Math.ceil( el.outerHeight() / rows ),
10977          pieces = [],
10978  
10979          // loop
10980          i, j, left, top, mx, my;
10981  
10982      // children animate complete:
10983  	function childComplete() {
10984          pieces.push( this );
10985          if ( pieces.length === rows * cells ) {
10986              animComplete();
10987          }
10988      }
10989  
10990      // clone the element for each row and cell.
10991      for ( i = 0; i < rows ; i++ ) { // ===>
10992          top = offset.top + i * height;
10993          my = i - ( rows - 1 ) / 2 ;
10994  
10995          for ( j = 0; j < cells ; j++ ) { // |||
10996              left = offset.left + j * width;
10997              mx = j - ( cells - 1 ) / 2 ;
10998  
10999              // Create a clone of the now hidden main element that will be absolute positioned
11000              // within a wrapper div off the -left and -top equal to size of our pieces
11001              el
11002                  .clone()
11003                  .appendTo( "body" )
11004                  .wrap( "<div></div>" )
11005                  .css({
11006                      position: "absolute",
11007                      visibility: "visible",
11008                      left: -j * width,
11009                      top: -i * height
11010                  })
11011  
11012              // select the wrapper - make it overflow: hidden and absolute positioned based on
11013              // where the original was located +left and +top equal to the size of pieces
11014                  .parent()
11015                  .addClass( "ui-effects-explode" )
11016                  .css({
11017                      position: "absolute",
11018                      overflow: "hidden",
11019                      width: width,
11020                      height: height,
11021                      left: left + ( show ? mx * width : 0 ),
11022                      top: top + ( show ? my * height : 0 ),
11023                      opacity: show ? 0 : 1
11024                  }).animate({
11025                      left: left + ( show ? 0 : mx * width ),
11026                      top: top + ( show ? 0 : my * height ),
11027                      opacity: show ? 1 : 0
11028                  }, o.duration || 500, o.easing, childComplete );
11029          }
11030      }
11031  
11032  	function animComplete() {
11033          el.css({
11034              visibility: "visible"
11035          });
11036          $( pieces ).remove();
11037          if ( !show ) {
11038              el.hide();
11039          }
11040          done();
11041      }
11042  };
11043  
11044  
11045  /*!
11046   * jQuery UI Effects Fade 1.11.4
11047   * http://jqueryui.com
11048   *
11049   * Copyright jQuery Foundation and other contributors
11050   * Released under the MIT license.
11051   * http://jquery.org/license
11052   *
11053   * http://api.jqueryui.com/fade-effect/
11054   */
11055  
11056  
11057  var effectFade = $.effects.effect.fade = function( o, done ) {
11058      var el = $( this ),
11059          mode = $.effects.setMode( el, o.mode || "toggle" );
11060  
11061      el.animate({
11062          opacity: mode
11063      }, {
11064          queue: false,
11065          duration: o.duration,
11066          easing: o.easing,
11067          complete: done
11068      });
11069  };
11070  
11071  
11072  /*!
11073   * jQuery UI Effects Fold 1.11.4
11074   * http://jqueryui.com
11075   *
11076   * Copyright jQuery Foundation and other contributors
11077   * Released under the MIT license.
11078   * http://jquery.org/license
11079   *
11080   * http://api.jqueryui.com/fold-effect/
11081   */
11082  
11083  
11084  var effectFold = $.effects.effect.fold = function( o, done ) {
11085  
11086      // Create element
11087      var el = $( this ),
11088          props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
11089          mode = $.effects.setMode( el, o.mode || "hide" ),
11090          show = mode === "show",
11091          hide = mode === "hide",
11092          size = o.size || 15,
11093          percent = /([0-9]+)%/.exec( size ),
11094          horizFirst = !!o.horizFirst,
11095          widthFirst = show !== horizFirst,
11096          ref = widthFirst ? [ "width", "height" ] : [ "height", "width" ],
11097          duration = o.duration / 2,
11098          wrapper, distance,
11099          animation1 = {},
11100          animation2 = {};
11101  
11102      $.effects.save( el, props );
11103      el.show();
11104  
11105      // Create Wrapper
11106      wrapper = $.effects.createWrapper( el ).css({
11107          overflow: "hidden"
11108      });
11109      distance = widthFirst ?
11110          [ wrapper.width(), wrapper.height() ] :
11111          [ wrapper.height(), wrapper.width() ];
11112  
11113      if ( percent ) {
11114          size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
11115      }
11116      if ( show ) {
11117          wrapper.css( horizFirst ? {
11118              height: 0,
11119              width: size
11120          } : {
11121              height: size,
11122              width: 0
11123          });
11124      }
11125  
11126      // Animation
11127      animation1[ ref[ 0 ] ] = show ? distance[ 0 ] : size;
11128      animation2[ ref[ 1 ] ] = show ? distance[ 1 ] : 0;
11129  
11130      // Animate
11131      wrapper
11132          .animate( animation1, duration, o.easing )
11133          .animate( animation2, duration, o.easing, function() {
11134              if ( hide ) {
11135                  el.hide();
11136              }
11137              $.effects.restore( el, props );
11138              $.effects.removeWrapper( el );
11139              done();
11140          });
11141  
11142  };
11143  
11144  
11145  /*!
11146   * jQuery UI Effects Highlight 1.11.4
11147   * http://jqueryui.com
11148   *
11149   * Copyright jQuery Foundation and other contributors
11150   * Released under the MIT license.
11151   * http://jquery.org/license
11152   *
11153   * http://api.jqueryui.com/highlight-effect/
11154   */
11155  
11156  
11157  var effectHighlight = $.effects.effect.highlight = function( o, done ) {
11158      var elem = $( this ),
11159          props = [ "backgroundImage", "backgroundColor", "opacity" ],
11160          mode = $.effects.setMode( elem, o.mode || "show" ),
11161          animation = {
11162              backgroundColor: elem.css( "backgroundColor" )
11163          };
11164  
11165      if (mode === "hide") {
11166          animation.opacity = 0;
11167      }
11168  
11169      $.effects.save( elem, props );
11170  
11171      elem
11172          .show()
11173          .css({
11174              backgroundImage: "none",
11175              backgroundColor: o.color || "#ffff99"
11176          })
11177          .animate( animation, {
11178              queue: false,
11179              duration: o.duration,
11180              easing: o.easing,
11181              complete: function() {
11182                  if ( mode === "hide" ) {
11183                      elem.hide();
11184                  }
11185                  $.effects.restore( elem, props );
11186                  done();
11187              }
11188          });
11189  };
11190  
11191  
11192  /*!
11193   * jQuery UI Effects Size 1.11.4
11194   * http://jqueryui.com
11195   *
11196   * Copyright jQuery Foundation and other contributors
11197   * Released under the MIT license.
11198   * http://jquery.org/license
11199   *
11200   * http://api.jqueryui.com/size-effect/
11201   */
11202  
11203  
11204  var effectSize = $.effects.effect.size = function( o, done ) {
11205  
11206      // Create element
11207      var original, baseline, factor,
11208          el = $( this ),
11209          props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
11210  
11211          // Always restore
11212          props1 = [ "position", "top", "bottom", "left", "right", "overflow", "opacity" ],
11213  
11214          // Copy for children
11215          props2 = [ "width", "height", "overflow" ],
11216          cProps = [ "fontSize" ],
11217          vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
11218          hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
11219  
11220          // Set options
11221          mode = $.effects.setMode( el, o.mode || "effect" ),
11222          restore = o.restore || mode !== "effect",
11223          scale = o.scale || "both",
11224          origin = o.origin || [ "middle", "center" ],
11225          position = el.css( "position" ),
11226          props = restore ? props0 : props1,
11227          zero = {
11228              height: 0,
11229              width: 0,
11230              outerHeight: 0,
11231              outerWidth: 0
11232          };
11233  
11234      if ( mode === "show" ) {
11235          el.show();
11236      }
11237      original = {
11238          height: el.height(),
11239          width: el.width(),
11240          outerHeight: el.outerHeight(),
11241          outerWidth: el.outerWidth()
11242      };
11243  
11244      if ( o.mode === "toggle" && mode === "show" ) {
11245          el.from = o.to || zero;
11246          el.to = o.from || original;
11247      } else {
11248          el.from = o.from || ( mode === "show" ? zero : original );
11249          el.to = o.to || ( mode === "hide" ? zero : original );
11250      }
11251  
11252      // Set scaling factor
11253      factor = {
11254          from: {
11255              y: el.from.height / original.height,
11256              x: el.from.width / original.width
11257          },
11258          to: {
11259              y: el.to.height / original.height,
11260              x: el.to.width / original.width
11261          }
11262      };
11263  
11264      // Scale the css box
11265      if ( scale === "box" || scale === "both" ) {
11266  
11267          // Vertical props scaling
11268          if ( factor.from.y !== factor.to.y ) {
11269              props = props.concat( vProps );
11270              el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from );
11271              el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to );
11272          }
11273  
11274          // Horizontal props scaling
11275          if ( factor.from.x !== factor.to.x ) {
11276              props = props.concat( hProps );
11277              el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from );
11278              el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to );
11279          }
11280      }
11281  
11282      // Scale the content
11283      if ( scale === "content" || scale === "both" ) {
11284  
11285          // Vertical props scaling
11286          if ( factor.from.y !== factor.to.y ) {
11287              props = props.concat( cProps ).concat( props2 );
11288              el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from );
11289              el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to );
11290          }
11291      }
11292  
11293      $.effects.save( el, props );
11294      el.show();
11295      $.effects.createWrapper( el );
11296      el.css( "overflow", "hidden" ).css( el.from );
11297  
11298      // Adjust
11299      if (origin) { // Calculate baseline shifts
11300          baseline = $.effects.getBaseline( origin, original );
11301          el.from.top = ( original.outerHeight - el.outerHeight() ) * baseline.y;
11302          el.from.left = ( original.outerWidth - el.outerWidth() ) * baseline.x;
11303          el.to.top = ( original.outerHeight - el.to.outerHeight ) * baseline.y;
11304          el.to.left = ( original.outerWidth - el.to.outerWidth ) * baseline.x;
11305      }
11306      el.css( el.from ); // set top & left
11307  
11308      // Animate
11309      if ( scale === "content" || scale === "both" ) { // Scale the children
11310  
11311          // Add margins/font-size
11312          vProps = vProps.concat([ "marginTop", "marginBottom" ]).concat(cProps);
11313          hProps = hProps.concat([ "marginLeft", "marginRight" ]);
11314          props2 = props0.concat(vProps).concat(hProps);
11315  
11316          el.find( "*[width]" ).each( function() {
11317              var child = $( this ),
11318                  c_original = {
11319                      height: child.height(),
11320                      width: child.width(),
11321                      outerHeight: child.outerHeight(),
11322                      outerWidth: child.outerWidth()
11323                  };
11324              if (restore) {
11325                  $.effects.save(child, props2);
11326              }
11327  
11328              child.from = {
11329                  height: c_original.height * factor.from.y,
11330                  width: c_original.width * factor.from.x,
11331                  outerHeight: c_original.outerHeight * factor.from.y,
11332                  outerWidth: c_original.outerWidth * factor.from.x
11333              };
11334              child.to = {
11335                  height: c_original.height * factor.to.y,
11336                  width: c_original.width * factor.to.x,
11337                  outerHeight: c_original.height * factor.to.y,
11338                  outerWidth: c_original.width * factor.to.x
11339              };
11340  
11341              // Vertical props scaling
11342              if ( factor.from.y !== factor.to.y ) {
11343                  child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from );
11344                  child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to );
11345              }
11346  
11347              // Horizontal props scaling
11348              if ( factor.from.x !== factor.to.x ) {
11349                  child.from = $.effects.setTransition( child, hProps, factor.from.x, child.from );
11350                  child.to = $.effects.setTransition( child, hProps, factor.to.x, child.to );
11351              }
11352  
11353              // Animate children
11354              child.css( child.from );
11355              child.animate( child.to, o.duration, o.easing, function() {
11356  
11357                  // Restore children
11358                  if ( restore ) {
11359                      $.effects.restore( child, props2 );
11360                  }
11361              });
11362          });
11363      }
11364  
11365      // Animate
11366      el.animate( el.to, {
11367          queue: false,
11368          duration: o.duration,
11369          easing: o.easing,
11370          complete: function() {
11371              if ( el.to.opacity === 0 ) {
11372                  el.css( "opacity", el.from.opacity );
11373              }
11374              if ( mode === "hide" ) {
11375                  el.hide();
11376              }
11377              $.effects.restore( el, props );
11378              if ( !restore ) {
11379  
11380                  // we need to calculate our new positioning based on the scaling
11381                  if ( position === "static" ) {
11382                      el.css({
11383                          position: "relative",
11384                          top: el.to.top,
11385                          left: el.to.left
11386                      });
11387                  } else {
11388                      $.each([ "top", "left" ], function( idx, pos ) {
11389                          el.css( pos, function( _, str ) {
11390                              var val = parseInt( str, 10 ),
11391                                  toRef = idx ? el.to.left : el.to.top;
11392  
11393                              // if original was "auto", recalculate the new value from wrapper
11394                              if ( str === "auto" ) {
11395                                  return toRef + "px";
11396                              }
11397  
11398                              return val + toRef + "px";
11399                          });
11400                      });
11401                  }
11402              }
11403  
11404              $.effects.removeWrapper( el );
11405              done();
11406          }
11407      });
11408  
11409  };
11410  
11411  
11412  /*!
11413   * jQuery UI Effects Scale 1.11.4
11414   * http://jqueryui.com
11415   *
11416   * Copyright jQuery Foundation and other contributors
11417   * Released under the MIT license.
11418   * http://jquery.org/license
11419   *
11420   * http://api.jqueryui.com/scale-effect/
11421   */
11422  
11423  
11424  var effectScale = $.effects.effect.scale = function( o, done ) {
11425  
11426      // Create element
11427      var el = $( this ),
11428          options = $.extend( true, {}, o ),
11429          mode = $.effects.setMode( el, o.mode || "effect" ),
11430          percent = parseInt( o.percent, 10 ) ||
11431              ( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ),
11432          direction = o.direction || "both",
11433          origin = o.origin,
11434          original = {
11435              height: el.height(),
11436              width: el.width(),
11437              outerHeight: el.outerHeight(),
11438              outerWidth: el.outerWidth()
11439          },
11440          factor = {
11441              y: direction !== "horizontal" ? (percent / 100) : 1,
11442              x: direction !== "vertical" ? (percent / 100) : 1
11443          };
11444  
11445      // We are going to pass this effect to the size effect:
11446      options.effect = "size";
11447      options.queue = false;
11448      options.complete = done;
11449  
11450      // Set default origin and restore for show/hide
11451      if ( mode !== "effect" ) {
11452          options.origin = origin || [ "middle", "center" ];
11453          options.restore = true;
11454      }
11455  
11456      options.from = o.from || ( mode === "show" ? {
11457          height: 0,
11458          width: 0,
11459          outerHeight: 0,
11460          outerWidth: 0
11461      } : original );
11462      options.to = {
11463          height: original.height * factor.y,
11464          width: original.width * factor.x,
11465          outerHeight: original.outerHeight * factor.y,
11466          outerWidth: original.outerWidth * factor.x
11467      };
11468  
11469      // Fade option to support puff
11470      if ( options.fade ) {
11471          if ( mode === "show" ) {
11472              options.from.opacity = 0;
11473              options.to.opacity = 1;
11474          }
11475          if ( mode === "hide" ) {
11476              options.from.opacity = 1;
11477              options.to.opacity = 0;
11478          }
11479      }
11480  
11481      // Animate
11482      el.effect( options );
11483  
11484  };
11485  
11486  
11487  /*!
11488   * jQuery UI Effects Puff 1.11.4
11489   * http://jqueryui.com
11490   *
11491   * Copyright jQuery Foundation and other contributors
11492   * Released under the MIT license.
11493   * http://jquery.org/license
11494   *
11495   * http://api.jqueryui.com/puff-effect/
11496   */
11497  
11498  
11499  var effectPuff = $.effects.effect.puff = function( o, done ) {
11500      var elem = $( this ),
11501          mode = $.effects.setMode( elem, o.mode || "hide" ),
11502          hide = mode === "hide",
11503          percent = parseInt( o.percent, 10 ) || 150,
11504          factor = percent / 100,
11505          original = {
11506              height: elem.height(),
11507              width: elem.width(),
11508              outerHeight: elem.outerHeight(),
11509              outerWidth: elem.outerWidth()
11510          };
11511  
11512      $.extend( o, {
11513          effect: "scale",
11514          queue: false,
11515          fade: true,
11516          mode: mode,
11517          complete: done,
11518          percent: hide ? percent : 100,
11519          from: hide ?
11520              original :
11521              {
11522                  height: original.height * factor,
11523                  width: original.width * factor,
11524                  outerHeight: original.outerHeight * factor,
11525                  outerWidth: original.outerWidth * factor
11526              }
11527      });
11528  
11529      elem.effect( o );
11530  };
11531  
11532  
11533  /*!
11534   * jQuery UI Effects Pulsate 1.11.4
11535   * http://jqueryui.com
11536   *
11537   * Copyright jQuery Foundation and other contributors
11538   * Released under the MIT license.
11539   * http://jquery.org/license
11540   *
11541   * http://api.jqueryui.com/pulsate-effect/
11542   */
11543  
11544  
11545  var effectPulsate = $.effects.effect.pulsate = function( o, done ) {
11546      var elem = $( this ),
11547          mode = $.effects.setMode( elem, o.mode || "show" ),
11548          show = mode === "show",
11549          hide = mode === "hide",
11550          showhide = ( show || mode === "hide" ),
11551  
11552          // showing or hiding leaves of the "last" animation
11553          anims = ( ( o.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
11554          duration = o.duration / anims,
11555          animateTo = 0,
11556          queue = elem.queue(),
11557          queuelen = queue.length,
11558          i;
11559  
11560      if ( show || !elem.is(":visible")) {
11561          elem.css( "opacity", 0 ).show();
11562          animateTo = 1;
11563      }
11564  
11565      // anims - 1 opacity "toggles"
11566      for ( i = 1; i < anims; i++ ) {
11567          elem.animate({
11568              opacity: animateTo
11569          }, duration, o.easing );
11570          animateTo = 1 - animateTo;
11571      }
11572  
11573      elem.animate({
11574          opacity: animateTo
11575      }, duration, o.easing);
11576  
11577      elem.queue(function() {
11578          if ( hide ) {
11579              elem.hide();
11580          }
11581          done();
11582      });
11583  
11584      // We just queued up "anims" animations, we need to put them next in the queue
11585      if ( queuelen > 1 ) {
11586          queue.splice.apply( queue,
11587              [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
11588      }
11589      elem.dequeue();
11590  };
11591  
11592  
11593  /*!
11594   * jQuery UI Effects Shake 1.11.4
11595   * http://jqueryui.com
11596   *
11597   * Copyright jQuery Foundation and other contributors
11598   * Released under the MIT license.
11599   * http://jquery.org/license
11600   *
11601   * http://api.jqueryui.com/shake-effect/
11602   */
11603  
11604  
11605  var effectShake = $.effects.effect.shake = function( o, done ) {
11606  
11607      var el = $( this ),
11608          props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
11609          mode = $.effects.setMode( el, o.mode || "effect" ),
11610          direction = o.direction || "left",
11611          distance = o.distance || 20,
11612          times = o.times || 3,
11613          anims = times * 2 + 1,
11614          speed = Math.round( o.duration / anims ),
11615          ref = (direction === "up" || direction === "down") ? "top" : "left",
11616          positiveMotion = (direction === "up" || direction === "left"),
11617          animation = {},
11618          animation1 = {},
11619          animation2 = {},
11620          i,
11621  
11622          // we will need to re-assemble the queue to stack our animations in place
11623          queue = el.queue(),
11624          queuelen = queue.length;
11625  
11626      $.effects.save( el, props );
11627      el.show();
11628      $.effects.createWrapper( el );
11629  
11630      // Animation
11631      animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
11632      animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
11633      animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
11634  
11635      // Animate
11636      el.animate( animation, speed, o.easing );
11637  
11638      // Shakes
11639      for ( i = 1; i < times; i++ ) {
11640          el.animate( animation1, speed, o.easing ).animate( animation2, speed, o.easing );
11641      }
11642      el
11643          .animate( animation1, speed, o.easing )
11644          .animate( animation, speed / 2, o.easing )
11645          .queue(function() {
11646              if ( mode === "hide" ) {
11647                  el.hide();
11648              }
11649              $.effects.restore( el, props );
11650              $.effects.removeWrapper( el );
11651              done();
11652          });
11653  
11654      // inject all the animations we just queued to be first in line (after "inprogress")
11655      if ( queuelen > 1) {
11656          queue.splice.apply( queue,
11657              [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
11658      }
11659      el.dequeue();
11660  
11661  };
11662  
11663  
11664  /*!
11665   * jQuery UI Effects Slide 1.11.4
11666   * http://jqueryui.com
11667   *
11668   * Copyright jQuery Foundation and other contributors
11669   * Released under the MIT license.
11670   * http://jquery.org/license
11671   *
11672   * http://api.jqueryui.com/slide-effect/
11673   */
11674  
11675  
11676  var effectSlide = $.effects.effect.slide = function( o, done ) {
11677  
11678      // Create element
11679      var el = $( this ),
11680          props = [ "position", "top", "bottom", "left", "right", "width", "height" ],
11681          mode = $.effects.setMode( el, o.mode || "show" ),
11682          show = mode === "show",
11683          direction = o.direction || "left",
11684          ref = (direction === "up" || direction === "down") ? "top" : "left",
11685          positiveMotion = (direction === "up" || direction === "left"),
11686          distance,
11687          animation = {};
11688  
11689      // Adjust
11690      $.effects.save( el, props );
11691      el.show();
11692      distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true );
11693  
11694      $.effects.createWrapper( el ).css({
11695          overflow: "hidden"
11696      });
11697  
11698      if ( show ) {
11699          el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance );
11700      }
11701  
11702      // Animation
11703      animation[ ref ] = ( show ?
11704          ( positiveMotion ? "+=" : "-=") :
11705          ( positiveMotion ? "-=" : "+=")) +
11706          distance;
11707  
11708      // Animate
11709      el.animate( animation, {
11710          queue: false,
11711          duration: o.duration,
11712          easing: o.easing,
11713          complete: function() {
11714              if ( mode === "hide" ) {
11715                  el.hide();
11716              }
11717              $.effects.restore( el, props );
11718              $.effects.removeWrapper( el );
11719              done();
11720          }
11721      });
11722  };
11723  
11724  
11725  /*!
11726   * jQuery UI Effects Transfer 1.11.4
11727   * http://jqueryui.com
11728   *
11729   * Copyright jQuery Foundation and other contributors
11730   * Released under the MIT license.
11731   * http://jquery.org/license
11732   *
11733   * http://api.jqueryui.com/transfer-effect/
11734   */
11735  
11736  
11737  var effectTransfer = $.effects.effect.transfer = function( o, done ) {
11738      var elem = $( this ),
11739          target = $( o.to ),
11740          targetFixed = target.css( "position" ) === "fixed",
11741          body = $("body"),
11742          fixTop = targetFixed ? body.scrollTop() : 0,
11743          fixLeft = targetFixed ? body.scrollLeft() : 0,
11744          endPosition = target.offset(),
11745          animation = {
11746              top: endPosition.top - fixTop,
11747              left: endPosition.left - fixLeft,
11748              height: target.innerHeight(),
11749              width: target.innerWidth()
11750          },
11751          startPosition = elem.offset(),
11752          transfer = $( "<div class='ui-effects-transfer'></div>" )
11753              .appendTo( document.body )
11754              .addClass( o.className )
11755              .css({
11756                  top: startPosition.top - fixTop,
11757                  left: startPosition.left - fixLeft,
11758                  height: elem.innerHeight(),
11759                  width: elem.innerWidth(),
11760                  position: targetFixed ? "fixed" : "absolute"
11761              })
11762              .animate( animation, o.duration, o.easing, function() {
11763                  transfer.remove();
11764                  done();
11765              });
11766  };
11767  
11768  
11769  /*!
11770   * jQuery UI Progressbar 1.11.4
11771   * http://jqueryui.com
11772   *
11773   * Copyright jQuery Foundation and other contributors
11774   * Released under the MIT license.
11775   * http://jquery.org/license
11776   *
11777   * http://api.jqueryui.com/progressbar/
11778   */
11779  
11780  
11781  var progressbar = $.widget( "ui.progressbar", {
11782      version: "1.11.4",
11783      options: {
11784          max: 100,
11785          value: 0,
11786  
11787          change: null,
11788          complete: null
11789      },
11790  
11791      min: 0,
11792  
11793      _create: function() {
11794          // Constrain initial value
11795          this.oldValue = this.options.value = this._constrainedValue();
11796  
11797          this.element
11798              .addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
11799              .attr({
11800                  // Only set static values, aria-valuenow and aria-valuemax are
11801                  // set inside _refreshValue()
11802                  role: "progressbar",
11803                  "aria-valuemin": this.min
11804              });
11805  
11806          this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
11807              .appendTo( this.element );
11808  
11809          this._refreshValue();
11810      },
11811  
11812      _destroy: function() {
11813          this.element
11814              .removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
11815              .removeAttr( "role" )
11816              .removeAttr( "aria-valuemin" )
11817              .removeAttr( "aria-valuemax" )
11818              .removeAttr( "aria-valuenow" );
11819  
11820          this.valueDiv.remove();
11821      },
11822  
11823      value: function( newValue ) {
11824          if ( newValue === undefined ) {
11825              return this.options.value;
11826          }
11827  
11828          this.options.value = this._constrainedValue( newValue );
11829          this._refreshValue();
11830      },
11831  
11832      _constrainedValue: function( newValue ) {
11833          if ( newValue === undefined ) {
11834              newValue = this.options.value;
11835          }
11836  
11837          this.indeterminate = newValue === false;
11838  
11839          // sanitize value
11840          if ( typeof newValue !== "number" ) {
11841              newValue = 0;
11842          }
11843  
11844          return this.indeterminate ? false :
11845              Math.min( this.options.max, Math.max( this.min, newValue ) );
11846      },
11847  
11848      _setOptions: function( options ) {
11849          // Ensure "value" option is set after other values (like max)
11850          var value = options.value;
11851          delete options.value;
11852  
11853          this._super( options );
11854  
11855          this.options.value = this._constrainedValue( value );
11856          this._refreshValue();
11857      },
11858  
11859      _setOption: function( key, value ) {
11860          if ( key === "max" ) {
11861              // Don't allow a max less than min
11862              value = Math.max( this.min, value );
11863          }
11864          if ( key === "disabled" ) {
11865              this.element
11866                  .toggleClass( "ui-state-disabled", !!value )
11867                  .attr( "aria-disabled", value );
11868          }
11869          this._super( key, value );
11870      },
11871  
11872      _percentage: function() {
11873          return this.indeterminate ? 100 : 100 * ( this.options.value - this.min ) / ( this.options.max - this.min );
11874      },
11875  
11876      _refreshValue: function() {
11877          var value = this.options.value,
11878              percentage = this._percentage();
11879  
11880          this.valueDiv
11881              .toggle( this.indeterminate || value > this.min )
11882              .toggleClass( "ui-corner-right", value === this.options.max )
11883              .width( percentage.toFixed(0) + "%" );
11884  
11885          this.element.toggleClass( "ui-progressbar-indeterminate", this.indeterminate );
11886  
11887          if ( this.indeterminate ) {
11888              this.element.removeAttr( "aria-valuenow" );
11889              if ( !this.overlayDiv ) {
11890                  this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv );
11891              }
11892          } else {
11893              this.element.attr({
11894                  "aria-valuemax": this.options.max,
11895                  "aria-valuenow": value
11896              });
11897              if ( this.overlayDiv ) {
11898                  this.overlayDiv.remove();
11899                  this.overlayDiv = null;
11900              }
11901          }
11902  
11903          if ( this.oldValue !== value ) {
11904              this.oldValue = value;
11905              this._trigger( "change" );
11906          }
11907          if ( value === this.options.max ) {
11908              this._trigger( "complete" );
11909          }
11910      }
11911  });
11912  
11913  
11914  /*!
11915   * jQuery UI Selectable 1.11.4
11916   * http://jqueryui.com
11917   *
11918   * Copyright jQuery Foundation and other contributors
11919   * Released under the MIT license.
11920   * http://jquery.org/license
11921   *
11922   * http://api.jqueryui.com/selectable/
11923   */
11924  
11925  
11926  var selectable = $.widget("ui.selectable", $.ui.mouse, {
11927      version: "1.11.4",
11928      options: {
11929          appendTo: "body",
11930          autoRefresh: true,
11931          distance: 0,
11932          filter: "*",
11933          tolerance: "touch",
11934  
11935          // callbacks
11936          selected: null,
11937          selecting: null,
11938          start: null,
11939          stop: null,
11940          unselected: null,
11941          unselecting: null
11942      },
11943      _create: function() {
11944          var selectees,
11945              that = this;
11946  
11947          this.element.addClass("ui-selectable");
11948  
11949          this.dragged = false;
11950  
11951          // cache selectee children based on filter
11952          this.refresh = function() {
11953              selectees = $(that.options.filter, that.element[0]);
11954              selectees.addClass("ui-selectee");
11955              selectees.each(function() {
11956                  var $this = $(this),
11957                      pos = $this.offset();
11958                  $.data(this, "selectable-item", {
11959                      element: this,
11960                      $element: $this,
11961                      left: pos.left,
11962                      top: pos.top,
11963                      right: pos.left + $this.outerWidth(),
11964                      bottom: pos.top + $this.outerHeight(),
11965                      startselected: false,
11966                      selected: $this.hasClass("ui-selected"),
11967                      selecting: $this.hasClass("ui-selecting"),
11968                      unselecting: $this.hasClass("ui-unselecting")
11969                  });
11970              });
11971          };
11972          this.refresh();
11973  
11974          this.selectees = selectees.addClass("ui-selectee");
11975  
11976          this._mouseInit();
11977  
11978          this.helper = $("<div class='ui-selectable-helper'></div>");
11979      },
11980  
11981      _destroy: function() {
11982          this.selectees
11983              .removeClass("ui-selectee")
11984              .removeData("selectable-item");
11985          this.element
11986              .removeClass("ui-selectable ui-selectable-disabled");
11987          this._mouseDestroy();
11988      },
11989  
11990      _mouseStart: function(event) {
11991          var that = this,
11992              options = this.options;
11993  
11994          this.opos = [ event.pageX, event.pageY ];
11995  
11996          if (this.options.disabled) {
11997              return;
11998          }
11999  
12000          this.selectees = $(options.filter, this.element[0]);
12001  
12002          this._trigger("start", event);
12003  
12004          $(options.appendTo).append(this.helper);
12005          // position helper (lasso)
12006          this.helper.css({
12007              "left": event.pageX,
12008              "top": event.pageY,
12009              "width": 0,
12010              "height": 0
12011          });
12012  
12013          if (options.autoRefresh) {
12014              this.refresh();
12015          }
12016  
12017          this.selectees.filter(".ui-selected").each(function() {
12018              var selectee = $.data(this, "selectable-item");
12019              selectee.startselected = true;
12020              if (!event.metaKey && !event.ctrlKey) {
12021                  selectee.$element.removeClass("ui-selected");
12022                  selectee.selected = false;
12023                  selectee.$element.addClass("ui-unselecting");
12024                  selectee.unselecting = true;
12025                  // selectable UNSELECTING callback
12026                  that._trigger("unselecting", event, {
12027                      unselecting: selectee.element
12028                  });
12029              }
12030          });
12031  
12032          $(event.target).parents().addBack().each(function() {
12033              var doSelect,
12034                  selectee = $.data(this, "selectable-item");
12035              if (selectee) {
12036                  doSelect = (!event.metaKey && !event.ctrlKey) || !selectee.$element.hasClass("ui-selected");
12037                  selectee.$element
12038                      .removeClass(doSelect ? "ui-unselecting" : "ui-selected")
12039                      .addClass(doSelect ? "ui-selecting" : "ui-unselecting");
12040                  selectee.unselecting = !doSelect;
12041                  selectee.selecting = doSelect;
12042                  selectee.selected = doSelect;
12043                  // selectable (UN)SELECTING callback
12044                  if (doSelect) {
12045                      that._trigger("selecting", event, {
12046                          selecting: selectee.element
12047                      });
12048                  } else {
12049                      that._trigger("unselecting", event, {
12050                          unselecting: selectee.element
12051                      });
12052                  }
12053                  return false;
12054              }
12055          });
12056  
12057      },
12058  
12059      _mouseDrag: function(event) {
12060  
12061          this.dragged = true;
12062  
12063          if (this.options.disabled) {
12064              return;
12065          }
12066  
12067          var tmp,
12068              that = this,
12069              options = this.options,
12070              x1 = this.opos[0],
12071              y1 = this.opos[1],
12072              x2 = event.pageX,
12073              y2 = event.pageY;
12074  
12075          if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
12076          if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
12077          this.helper.css({ left: x1, top: y1, width: x2 - x1, height: y2 - y1 });
12078  
12079          this.selectees.each(function() {
12080              var selectee = $.data(this, "selectable-item"),
12081                  hit = false;
12082  
12083              //prevent helper from being selected if appendTo: selectable
12084              if (!selectee || selectee.element === that.element[0]) {
12085                  return;
12086              }
12087  
12088              if (options.tolerance === "touch") {
12089                  hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
12090              } else if (options.tolerance === "fit") {
12091                  hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
12092              }
12093  
12094              if (hit) {
12095                  // SELECT
12096                  if (selectee.selected) {
12097                      selectee.$element.removeClass("ui-selected");
12098                      selectee.selected = false;
12099                  }
12100                  if (selectee.unselecting) {
12101                      selectee.$element.removeClass("ui-unselecting");
12102                      selectee.unselecting = false;
12103                  }
12104                  if (!selectee.selecting) {
12105                      selectee.$element.addClass("ui-selecting");
12106                      selectee.selecting = true;
12107                      // selectable SELECTING callback
12108                      that._trigger("selecting", event, {
12109                          selecting: selectee.element
12110                      });
12111                  }
12112              } else {
12113                  // UNSELECT
12114                  if (selectee.selecting) {
12115                      if ((event.metaKey || event.ctrlKey) && selectee.startselected) {
12116                          selectee.$element.removeClass("ui-selecting");
12117                          selectee.selecting = false;
12118                          selectee.$element.addClass("ui-selected");
12119                          selectee.selected = true;
12120                      } else {
12121                          selectee.$element.removeClass("ui-selecting");
12122                          selectee.selecting = false;
12123                          if (selectee.startselected) {
12124                              selectee.$element.addClass("ui-unselecting");
12125                              selectee.unselecting = true;
12126                          }
12127                          // selectable UNSELECTING callback
12128                          that._trigger("unselecting", event, {
12129                              unselecting: selectee.element
12130                          });
12131                      }
12132                  }
12133                  if (selectee.selected) {
12134                      if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
12135                          selectee.$element.removeClass("ui-selected");
12136                          selectee.selected = false;
12137  
12138                          selectee.$element.addClass("ui-unselecting");
12139                          selectee.unselecting = true;
12140                          // selectable UNSELECTING callback
12141                          that._trigger("unselecting", event, {
12142                              unselecting: selectee.element
12143                          });
12144                      }
12145                  }
12146              }
12147          });
12148  
12149          return false;
12150      },
12151  
12152      _mouseStop: function(event) {
12153          var that = this;
12154  
12155          this.dragged = false;
12156  
12157          $(".ui-unselecting", this.element[0]).each(function() {
12158              var selectee = $.data(this, "selectable-item");
12159              selectee.$element.removeClass("ui-unselecting");
12160              selectee.unselecting = false;
12161              selectee.startselected = false;
12162              that._trigger("unselected", event, {
12163                  unselected: selectee.element
12164              });
12165          });
12166          $(".ui-selecting", this.element[0]).each(function() {
12167              var selectee = $.data(this, "selectable-item");
12168              selectee.$element.removeClass("ui-selecting").addClass("ui-selected");
12169              selectee.selecting = false;
12170              selectee.selected = true;
12171              selectee.startselected = true;
12172              that._trigger("selected", event, {
12173                  selected: selectee.element
12174              });
12175          });
12176          this._trigger("stop", event);
12177  
12178          this.helper.remove();
12179  
12180          return false;
12181      }
12182  
12183  });
12184  
12185  
12186  /*!
12187   * jQuery UI Selectmenu 1.11.4
12188   * http://jqueryui.com
12189   *
12190   * Copyright jQuery Foundation and other contributors
12191   * Released under the MIT license.
12192   * http://jquery.org/license
12193   *
12194   * http://api.jqueryui.com/selectmenu
12195   */
12196  
12197  
12198  var selectmenu = $.widget( "ui.selectmenu", {
12199      version: "1.11.4",
12200      defaultElement: "<select>",
12201      options: {
12202          appendTo: null,
12203          disabled: null,
12204          icons: {
12205              button: "ui-icon-triangle-1-s"
12206          },
12207          position: {
12208              my: "left top",
12209              at: "left bottom",
12210              collision: "none"
12211          },
12212          width: null,
12213  
12214          // callbacks
12215          change: null,
12216          close: null,
12217          focus: null,
12218          open: null,
12219          select: null
12220      },
12221  
12222      _create: function() {
12223          var selectmenuId = this.element.uniqueId().attr( "id" );
12224          this.ids = {
12225              element: selectmenuId,
12226              button: selectmenuId + "-button",
12227              menu: selectmenuId + "-menu"
12228          };
12229  
12230          this._drawButton();
12231          this._drawMenu();
12232  
12233          if ( this.options.disabled ) {
12234              this.disable();
12235          }
12236      },
12237  
12238      _drawButton: function() {
12239          var that = this;
12240  
12241          // Associate existing label with the new button
12242          this.label = $( "label[for='" + this.ids.element + "']" ).attr( "for", this.ids.button );
12243          this._on( this.label, {
12244              click: function( event ) {
12245                  this.button.focus();
12246                  event.preventDefault();
12247              }
12248          });
12249  
12250          // Hide original select element
12251          this.element.hide();
12252  
12253          // Create button
12254          this.button = $( "<span>", {
12255              "class": "ui-selectmenu-button ui-widget ui-state-default ui-corner-all",
12256              tabindex: this.options.disabled ? -1 : 0,
12257              id: this.ids.button,
12258              role: "combobox",
12259              "aria-expanded": "false",
12260              "aria-autocomplete": "list",
12261              "aria-owns": this.ids.menu,
12262              "aria-haspopup": "true"
12263          })
12264              .insertAfter( this.element );
12265  
12266          $( "<span>", {
12267              "class": "ui-icon " + this.options.icons.button
12268          })
12269              .prependTo( this.button );
12270  
12271          this.buttonText = $( "<span>", {
12272              "class": "ui-selectmenu-text"
12273          })
12274              .appendTo( this.button );
12275  
12276          this._setText( this.buttonText, this.element.find( "option:selected" ).text() );
12277          this._resizeButton();
12278  
12279          this._on( this.button, this._buttonEvents );
12280          this.button.one( "focusin", function() {
12281  
12282              // Delay rendering the menu items until the button receives focus.
12283              // The menu may have already been rendered via a programmatic open.
12284              if ( !that.menuItems ) {
12285                  that._refreshMenu();
12286              }
12287          });
12288          this._hoverable( this.button );
12289          this._focusable( this.button );
12290      },
12291  
12292      _drawMenu: function() {
12293          var that = this;
12294  
12295          // Create menu
12296          this.menu = $( "<ul>", {
12297              "aria-hidden": "true",
12298              "aria-labelledby": this.ids.button,
12299              id: this.ids.menu
12300          });
12301  
12302          // Wrap menu
12303          this.menuWrap = $( "<div>", {
12304              "class": "ui-selectmenu-menu ui-front"
12305          })
12306              .append( this.menu )
12307              .appendTo( this._appendTo() );
12308  
12309          // Initialize menu widget
12310          this.menuInstance = this.menu
12311              .menu({
12312                  role: "listbox",
12313                  select: function( event, ui ) {
12314                      event.preventDefault();
12315  
12316                      // support: IE8
12317                      // If the item was selected via a click, the text selection
12318                      // will be destroyed in IE
12319                      that._setSelection();
12320  
12321                      that._select( ui.item.data( "ui-selectmenu-item" ), event );
12322                  },
12323                  focus: function( event, ui ) {
12324                      var item = ui.item.data( "ui-selectmenu-item" );
12325  
12326                      // Prevent inital focus from firing and check if its a newly focused item
12327                      if ( that.focusIndex != null && item.index !== that.focusIndex ) {
12328                          that._trigger( "focus", event, { item: item } );
12329                          if ( !that.isOpen ) {
12330                              that._select( item, event );
12331                          }
12332                      }
12333                      that.focusIndex = item.index;
12334  
12335                      that.button.attr( "aria-activedescendant",
12336                          that.menuItems.eq( item.index ).attr( "id" ) );
12337                  }
12338              })
12339              .menu( "instance" );
12340  
12341          // Adjust menu styles to dropdown
12342          this.menu
12343              .addClass( "ui-corner-bottom" )
12344              .removeClass( "ui-corner-all" );
12345  
12346          // Don't close the menu on mouseleave
12347          this.menuInstance._off( this.menu, "mouseleave" );
12348  
12349          // Cancel the menu's collapseAll on document click
12350          this.menuInstance._closeOnDocumentClick = function() {
12351              return false;
12352          };
12353  
12354          // Selects often contain empty items, but never contain dividers
12355          this.menuInstance._isDivider = function() {
12356              return false;
12357          };
12358      },
12359  
12360      refresh: function() {
12361          this._refreshMenu();
12362          this._setText( this.buttonText, this._getSelectedItem().text() );
12363          if ( !this.options.width ) {
12364              this._resizeButton();
12365          }
12366      },
12367  
12368      _refreshMenu: function() {
12369          this.menu.empty();
12370  
12371          var item,
12372              options = this.element.find( "option" );
12373  
12374          if ( !options.length ) {
12375              return;
12376          }
12377  
12378          this._parseOptions( options );
12379          this._renderMenu( this.menu, this.items );
12380  
12381          this.menuInstance.refresh();
12382          this.menuItems = this.menu.find( "li" ).not( ".ui-selectmenu-optgroup" );
12383  
12384          item = this._getSelectedItem();
12385  
12386          // Update the menu to have the correct item focused
12387          this.menuInstance.focus( null, item );
12388          this._setAria( item.data( "ui-selectmenu-item" ) );
12389  
12390          // Set disabled state
12391          this._setOption( "disabled", this.element.prop( "disabled" ) );
12392      },
12393  
12394      open: function( event ) {
12395          if ( this.options.disabled ) {
12396              return;
12397          }
12398  
12399          // If this is the first time the menu is being opened, render the items
12400          if ( !this.menuItems ) {
12401              this._refreshMenu();
12402          } else {
12403  
12404              // Menu clears focus on close, reset focus to selected item
12405              this.menu.find( ".ui-state-focus" ).removeClass( "ui-state-focus" );
12406              this.menuInstance.focus( null, this._getSelectedItem() );
12407          }
12408  
12409          this.isOpen = true;
12410          this._toggleAttr();
12411          this._resizeMenu();
12412          this._position();
12413  
12414          this._on( this.document, this._documentClick );
12415  
12416          this._trigger( "open", event );
12417      },
12418  
12419      _position: function() {
12420          this.menuWrap.position( $.extend( { of: this.button }, this.options.position ) );
12421      },
12422  
12423      close: function( event ) {
12424          if ( !this.isOpen ) {
12425              return;
12426          }
12427  
12428          this.isOpen = false;
12429          this._toggleAttr();
12430  
12431          this.range = null;
12432          this._off( this.document );
12433  
12434          this._trigger( "close", event );
12435      },
12436  
12437      widget: function() {
12438          return this.button;
12439      },
12440  
12441      menuWidget: function() {
12442          return this.menu;
12443      },
12444  
12445      _renderMenu: function( ul, items ) {
12446          var that = this,
12447              currentOptgroup = "";
12448  
12449          $.each( items, function( index, item ) {
12450              if ( item.optgroup !== currentOptgroup ) {
12451                  $( "<li>", {
12452                      "class": "ui-selectmenu-optgroup ui-menu-divider" +
12453                          ( item.element.parent( "optgroup" ).prop( "disabled" ) ?
12454                              " ui-state-disabled" :
12455                              "" ),
12456                      text: item.optgroup
12457                  })
12458                      .appendTo( ul );
12459  
12460                  currentOptgroup = item.optgroup;
12461              }
12462  
12463              that._renderItemData( ul, item );
12464          });
12465      },
12466  
12467      _renderItemData: function( ul, item ) {
12468          return this._renderItem( ul, item ).data( "ui-selectmenu-item", item );
12469      },
12470  
12471      _renderItem: function( ul, item ) {
12472          var li = $( "<li>" );
12473  
12474          if ( item.disabled ) {
12475              li.addClass( "ui-state-disabled" );
12476          }
12477          this._setText( li, item.label );
12478  
12479          return li.appendTo( ul );
12480      },
12481  
12482      _setText: function( element, value ) {
12483          if ( value ) {
12484              element.text( value );
12485          } else {
12486              element.html( "&#160;" );
12487          }
12488      },
12489  
12490      _move: function( direction, event ) {
12491          var item, next,
12492              filter = ".ui-menu-item";
12493  
12494          if ( this.isOpen ) {
12495              item = this.menuItems.eq( this.focusIndex );
12496          } else {
12497              item = this.menuItems.eq( this.element[ 0 ].selectedIndex );
12498              filter += ":not(.ui-state-disabled)";
12499          }
12500  
12501          if ( direction === "first" || direction === "last" ) {
12502              next = item[ direction === "first" ? "prevAll" : "nextAll" ]( filter ).eq( -1 );
12503          } else {
12504              next = item[ direction + "All" ]( filter ).eq( 0 );
12505          }
12506  
12507          if ( next.length ) {
12508              this.menuInstance.focus( event, next );
12509          }
12510      },
12511  
12512      _getSelectedItem: function() {
12513          return this.menuItems.eq( this.element[ 0 ].selectedIndex );
12514      },
12515  
12516      _toggle: function( event ) {
12517          this[ this.isOpen ? "close" : "open" ]( event );
12518      },
12519  
12520      _setSelection: function() {
12521          var selection;
12522  
12523          if ( !this.range ) {
12524              return;
12525          }
12526  
12527          if ( window.getSelection ) {
12528              selection = window.getSelection();
12529              selection.removeAllRanges();
12530              selection.addRange( this.range );
12531  
12532          // support: IE8
12533          } else {
12534              this.range.select();
12535          }
12536  
12537          // support: IE
12538          // Setting the text selection kills the button focus in IE, but
12539          // restoring the focus doesn't kill the selection.
12540          this.button.focus();
12541      },
12542  
12543      _documentClick: {
12544          mousedown: function( event ) {
12545              if ( !this.isOpen ) {
12546                  return;
12547              }
12548  
12549              if ( !$( event.target ).closest( ".ui-selectmenu-menu, #" + this.ids.button ).length ) {
12550                  this.close( event );
12551              }
12552          }
12553      },
12554  
12555      _buttonEvents: {
12556  
12557          // Prevent text selection from being reset when interacting with the selectmenu (#10144)
12558          mousedown: function() {
12559              var selection;
12560  
12561              if ( window.getSelection ) {
12562                  selection = window.getSelection();
12563                  if ( selection.rangeCount ) {
12564                      this.range = selection.getRangeAt( 0 );
12565                  }
12566  
12567              // support: IE8
12568              } else {
12569                  this.range = document.selection.createRange();
12570              }
12571          },
12572  
12573          click: function( event ) {
12574              this._setSelection();
12575              this._toggle( event );
12576          },
12577  
12578          keydown: function( event ) {
12579              var preventDefault = true;
12580              switch ( event.keyCode ) {
12581                  case $.ui.keyCode.TAB:
12582                  case $.ui.keyCode.ESCAPE:
12583                      this.close( event );
12584                      preventDefault = false;
12585                      break;
12586                  case $.ui.keyCode.ENTER:
12587                      if ( this.isOpen ) {
12588                          this._selectFocusedItem( event );
12589                      }
12590                      break;
12591                  case $.ui.keyCode.UP:
12592                      if ( event.altKey ) {
12593                          this._toggle( event );
12594                      } else {
12595                          this._move( "prev", event );
12596                      }
12597                      break;
12598                  case $.ui.keyCode.DOWN:
12599                      if ( event.altKey ) {
12600                          this._toggle( event );
12601                      } else {
12602                          this._move( "next", event );
12603                      }
12604                      break;
12605                  case $.ui.keyCode.SPACE:
12606                      if ( this.isOpen ) {
12607                          this._selectFocusedItem( event );
12608                      } else {
12609                          this._toggle( event );
12610                      }
12611                      break;
12612                  case $.ui.keyCode.LEFT:
12613                      this._move( "prev", event );
12614                      break;
12615                  case $.ui.keyCode.RIGHT:
12616                      this._move( "next", event );
12617                      break;
12618                  case $.ui.keyCode.HOME:
12619                  case $.ui.keyCode.PAGE_UP:
12620                      this._move( "first", event );
12621                      break;
12622                  case $.ui.keyCode.END:
12623                  case $.ui.keyCode.PAGE_DOWN:
12624                      this._move( "last", event );
12625                      break;
12626                  default:
12627                      this.menu.trigger( event );
12628                      preventDefault = false;
12629              }
12630  
12631              if ( preventDefault ) {
12632                  event.preventDefault();
12633              }
12634          }
12635      },
12636  
12637      _selectFocusedItem: function( event ) {
12638          var item = this.menuItems.eq( this.focusIndex );
12639          if ( !item.hasClass( "ui-state-disabled" ) ) {
12640              this._select( item.data( "ui-selectmenu-item" ), event );
12641          }
12642      },
12643  
12644      _select: function( item, event ) {
12645          var oldIndex = this.element[ 0 ].selectedIndex;
12646  
12647          // Change native select element
12648          this.element[ 0 ].selectedIndex = item.index;
12649          this._setText( this.buttonText, item.label );
12650          this._setAria( item );
12651          this._trigger( "select", event, { item: item } );
12652  
12653          if ( item.index !== oldIndex ) {
12654              this._trigger( "change", event, { item: item } );
12655          }
12656  
12657          this.close( event );
12658      },
12659  
12660      _setAria: function( item ) {
12661          var id = this.menuItems.eq( item.index ).attr( "id" );
12662  
12663          this.button.attr({
12664              "aria-labelledby": id,
12665              "aria-activedescendant": id
12666          });
12667          this.menu.attr( "aria-activedescendant", id );
12668      },
12669  
12670      _setOption: function( key, value ) {
12671          if ( key === "icons" ) {
12672              this.button.find( "span.ui-icon" )
12673                  .removeClass( this.options.icons.button )
12674                  .addClass( value.button );
12675          }
12676  
12677          this._super( key, value );
12678  
12679          if ( key === "appendTo" ) {
12680              this.menuWrap.appendTo( this._appendTo() );
12681          }
12682  
12683          if ( key === "disabled" ) {
12684              this.menuInstance.option( "disabled", value );
12685              this.button
12686                  .toggleClass( "ui-state-disabled", value )
12687                  .attr( "aria-disabled", value );
12688  
12689              this.element.prop( "disabled", value );
12690              if ( value ) {
12691                  this.button.attr( "tabindex", -1 );
12692                  this.close();
12693              } else {
12694                  this.button.attr( "tabindex", 0 );
12695              }
12696          }
12697  
12698          if ( key === "width" ) {
12699              this._resizeButton();
12700          }
12701      },
12702  
12703      _appendTo: function() {
12704          var element = this.options.appendTo;
12705  
12706          if ( element ) {
12707              element = element.jquery || element.nodeType ?
12708                  $( element ) :
12709                  this.document.find( element ).eq( 0 );
12710          }
12711  
12712          if ( !element || !element[ 0 ] ) {
12713              element = this.element.closest( ".ui-front" );
12714          }
12715  
12716          if ( !element.length ) {
12717              element = this.document[ 0 ].body;
12718          }
12719  
12720          return element;
12721      },
12722  
12723      _toggleAttr: function() {
12724          this.button
12725              .toggleClass( "ui-corner-top", this.isOpen )
12726              .toggleClass( "ui-corner-all", !this.isOpen )
12727              .attr( "aria-expanded", this.isOpen );
12728          this.menuWrap.toggleClass( "ui-selectmenu-open", this.isOpen );
12729          this.menu.attr( "aria-hidden", !this.isOpen );
12730      },
12731  
12732      _resizeButton: function() {
12733          var width = this.options.width;
12734  
12735          if ( !width ) {
12736              width = this.element.show().outerWidth();
12737              this.element.hide();
12738          }
12739  
12740          this.button.outerWidth( width );
12741      },
12742  
12743      _resizeMenu: function() {
12744          this.menu.outerWidth( Math.max(
12745              this.button.outerWidth(),
12746  
12747              // support: IE10
12748              // IE10 wraps long text (possibly a rounding bug)
12749              // so we add 1px to avoid the wrapping
12750              this.menu.width( "" ).outerWidth() + 1
12751          ) );
12752      },
12753  
12754      _getCreateOptions: function() {
12755          return { disabled: this.element.prop( "disabled" ) };
12756      },
12757  
12758      _parseOptions: function( options ) {
12759          var data = [];
12760          options.each(function( index, item ) {
12761              var option = $( item ),
12762                  optgroup = option.parent( "optgroup" );
12763              data.push({
12764                  element: option,
12765                  index: index,
12766                  value: option.val(),
12767                  label: option.text(),
12768                  optgroup: optgroup.attr( "label" ) || "",
12769                  disabled: optgroup.prop( "disabled" ) || option.prop( "disabled" )
12770              });
12771          });
12772          this.items = data;
12773      },
12774  
12775      _destroy: function() {
12776          this.menuWrap.remove();
12777          this.button.remove();
12778          this.element.show();
12779          this.element.removeUniqueId();
12780          this.label.attr( "for", this.ids.element );
12781      }
12782  });
12783  
12784  
12785  /*!
12786   * jQuery UI Slider 1.11.4
12787   * http://jqueryui.com
12788   *
12789   * Copyright jQuery Foundation and other contributors
12790   * Released under the MIT license.
12791   * http://jquery.org/license
12792   *
12793   * http://api.jqueryui.com/slider/
12794   */
12795  
12796  
12797  var slider = $.widget( "ui.slider", $.ui.mouse, {
12798      version: "1.11.4",
12799      widgetEventPrefix: "slide",
12800  
12801      options: {
12802          animate: false,
12803          distance: 0,
12804          max: 100,
12805          min: 0,
12806          orientation: "horizontal",
12807          range: false,
12808          step: 1,
12809          value: 0,
12810          values: null,
12811  
12812          // callbacks
12813          change: null,
12814          slide: null,
12815          start: null,
12816          stop: null
12817      },
12818  
12819      // number of pages in a slider
12820      // (how many times can you page up/down to go through the whole range)
12821      numPages: 5,
12822  
12823      _create: function() {
12824          this._keySliding = false;
12825          this._mouseSliding = false;
12826          this._animateOff = true;
12827          this._handleIndex = null;
12828          this._detectOrientation();
12829          this._mouseInit();
12830          this._calculateNewMax();
12831  
12832          this.element
12833              .addClass( "ui-slider" +
12834                  " ui-slider-" + this.orientation +
12835                  " ui-widget" +
12836                  " ui-widget-content" +
12837                  " ui-corner-all");
12838  
12839          this._refresh();
12840          this._setOption( "disabled", this.options.disabled );
12841  
12842          this._animateOff = false;
12843      },
12844  
12845      _refresh: function() {
12846          this._createRange();
12847          this._createHandles();
12848          this._setupEvents();
12849          this._refreshValue();
12850      },
12851  
12852      _createHandles: function() {
12853          var i, handleCount,
12854              options = this.options,
12855              existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
12856              handle = "<span class='ui-slider-handle ui-state-default ui-corner-all' tabindex='0'></span>",
12857              handles = [];
12858  
12859          handleCount = ( options.values && options.values.length ) || 1;
12860  
12861          if ( existingHandles.length > handleCount ) {
12862              existingHandles.slice( handleCount ).remove();
12863              existingHandles = existingHandles.slice( 0, handleCount );
12864          }
12865  
12866          for ( i = existingHandles.length; i < handleCount; i++ ) {
12867              handles.push( handle );
12868          }
12869  
12870          this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
12871  
12872          this.handle = this.handles.eq( 0 );
12873  
12874          this.handles.each(function( i ) {
12875              $( this ).data( "ui-slider-handle-index", i );
12876          });
12877      },
12878  
12879      _createRange: function() {
12880          var options = this.options,
12881              classes = "";
12882  
12883          if ( options.range ) {
12884              if ( options.range === true ) {
12885                  if ( !options.values ) {
12886                      options.values = [ this._valueMin(), this._valueMin() ];
12887                  } else if ( options.values.length && options.values.length !== 2 ) {
12888                      options.values = [ options.values[0], options.values[0] ];
12889                  } else if ( $.isArray( options.values ) ) {
12890                      options.values = options.values.slice(0);
12891                  }
12892              }
12893  
12894              if ( !this.range || !this.range.length ) {
12895                  this.range = $( "<div></div>" )
12896                      .appendTo( this.element );
12897  
12898                  classes = "ui-slider-range" +
12899                  // note: this isn't the most fittingly semantic framework class for this element,
12900                  // but worked best visually with a variety of themes
12901                  " ui-widget-header ui-corner-all";
12902              } else {
12903                  this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
12904                      // Handle range switching from true to min/max
12905                      .css({
12906                          "left": "",
12907                          "bottom": ""
12908                      });
12909              }
12910  
12911              this.range.addClass( classes +
12912                  ( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
12913          } else {
12914              if ( this.range ) {
12915                  this.range.remove();
12916              }
12917              this.range = null;
12918          }
12919      },
12920  
12921      _setupEvents: function() {
12922          this._off( this.handles );
12923          this._on( this.handles, this._handleEvents );
12924          this._hoverable( this.handles );
12925          this._focusable( this.handles );
12926      },
12927  
12928      _destroy: function() {
12929          this.handles.remove();
12930          if ( this.range ) {
12931              this.range.remove();
12932          }
12933  
12934          this.element
12935              .removeClass( "ui-slider" +
12936                  " ui-slider-horizontal" +
12937                  " ui-slider-vertical" +
12938                  " ui-widget" +
12939                  " ui-widget-content" +
12940                  " ui-corner-all" );
12941  
12942          this._mouseDestroy();
12943      },
12944  
12945      _mouseCapture: function( event ) {
12946          var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
12947              that = this,
12948              o = this.options;
12949  
12950          if ( o.disabled ) {
12951              return false;
12952          }
12953  
12954          this.elementSize = {
12955              width: this.element.outerWidth(),
12956              height: this.element.outerHeight()
12957          };
12958          this.elementOffset = this.element.offset();
12959  
12960          position = { x: event.pageX, y: event.pageY };
12961          normValue = this._normValueFromMouse( position );
12962          distance = this._valueMax() - this._valueMin() + 1;
12963          this.handles.each(function( i ) {
12964              var thisDistance = Math.abs( normValue - that.values(i) );
12965              if (( distance > thisDistance ) ||
12966                  ( distance === thisDistance &&
12967                      (i === that._lastChangedValue || that.values(i) === o.min ))) {
12968                  distance = thisDistance;
12969                  closestHandle = $( this );
12970                  index = i;
12971              }
12972          });
12973  
12974          allowed = this._start( event, index );
12975          if ( allowed === false ) {
12976              return false;
12977          }
12978          this._mouseSliding = true;
12979  
12980          this._handleIndex = index;
12981  
12982          closestHandle
12983              .addClass( "ui-state-active" )
12984              .focus();
12985  
12986          offset = closestHandle.offset();
12987          mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );
12988          this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
12989              left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
12990              top: event.pageY - offset.top -
12991                  ( closestHandle.height() / 2 ) -
12992                  ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
12993                  ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
12994                  ( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
12995          };
12996  
12997          if ( !this.handles.hasClass( "ui-state-hover" ) ) {
12998              this._slide( event, index, normValue );
12999          }
13000          this._animateOff = true;
13001          return true;
13002      },
13003  
13004      _mouseStart: function() {
13005          return true;
13006      },
13007  
13008      _mouseDrag: function( event ) {
13009          var position = { x: event.pageX, y: event.pageY },
13010              normValue = this._normValueFromMouse( position );
13011  
13012          this._slide( event, this._handleIndex, normValue );
13013  
13014          return false;
13015      },
13016  
13017      _mouseStop: function( event ) {
13018          this.handles.removeClass( "ui-state-active" );
13019          this._mouseSliding = false;
13020  
13021          this._stop( event, this._handleIndex );
13022          this._change( event, this._handleIndex );
13023  
13024          this._handleIndex = null;
13025          this._clickOffset = null;
13026          this._animateOff = false;
13027  
13028          return false;
13029      },
13030  
13031      _detectOrientation: function() {
13032          this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
13033      },
13034  
13035      _normValueFromMouse: function( position ) {
13036          var pixelTotal,
13037              pixelMouse,
13038              percentMouse,
13039              valueTotal,
13040              valueMouse;
13041  
13042          if ( this.orientation === "horizontal" ) {
13043              pixelTotal = this.elementSize.width;
13044              pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
13045          } else {
13046              pixelTotal = this.elementSize.height;
13047              pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
13048          }
13049  
13050          percentMouse = ( pixelMouse / pixelTotal );
13051          if ( percentMouse > 1 ) {
13052              percentMouse = 1;
13053          }
13054          if ( percentMouse < 0 ) {
13055              percentMouse = 0;
13056          }
13057          if ( this.orientation === "vertical" ) {
13058              percentMouse = 1 - percentMouse;
13059          }
13060  
13061          valueTotal = this._valueMax() - this._valueMin();
13062          valueMouse = this._valueMin() + percentMouse * valueTotal;
13063  
13064          return this._trimAlignValue( valueMouse );
13065      },
13066  
13067      _start: function( event, index ) {
13068          var uiHash = {
13069              handle: this.handles[ index ],
13070              value: this.value()
13071          };
13072          if ( this.options.values && this.options.values.length ) {
13073              uiHash.value = this.values( index );
13074              uiHash.values = this.values();
13075          }
13076          return this._trigger( "start", event, uiHash );
13077      },
13078  
13079      _slide: function( event, index, newVal ) {
13080          var otherVal,
13081              newValues,
13082              allowed;
13083  
13084          if ( this.options.values && this.options.values.length ) {
13085              otherVal = this.values( index ? 0 : 1 );
13086  
13087              if ( ( this.options.values.length === 2 && this.options.range === true ) &&
13088                      ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
13089                  ) {
13090                  newVal = otherVal;
13091              }
13092  
13093              if ( newVal !== this.values( index ) ) {
13094                  newValues = this.values();
13095                  newValues[ index ] = newVal;
13096                  // A slide can be canceled by returning false from the slide callback
13097                  allowed = this._trigger( "slide", event, {
13098                      handle: this.handles[ index ],
13099                      value: newVal,
13100                      values: newValues
13101                  } );
13102                  otherVal = this.values( index ? 0 : 1 );
13103                  if ( allowed !== false ) {
13104                      this.values( index, newVal );
13105                  }
13106              }
13107          } else {
13108              if ( newVal !== this.value() ) {
13109                  // A slide can be canceled by returning false from the slide callback
13110                  allowed = this._trigger( "slide", event, {
13111                      handle: this.handles[ index ],
13112                      value: newVal
13113                  } );
13114                  if ( allowed !== false ) {
13115                      this.value( newVal );
13116                  }
13117              }
13118          }
13119      },
13120  
13121      _stop: function( event, index ) {
13122          var uiHash = {
13123              handle: this.handles[ index ],
13124              value: this.value()
13125          };
13126          if ( this.options.values && this.options.values.length ) {
13127              uiHash.value = this.values( index );
13128              uiHash.values = this.values();
13129          }
13130  
13131          this._trigger( "stop", event, uiHash );
13132      },
13133  
13134      _change: function( event, index ) {
13135          if ( !this._keySliding && !this._mouseSliding ) {
13136              var uiHash = {
13137                  handle: this.handles[ index ],
13138                  value: this.value()
13139              };
13140              if ( this.options.values && this.options.values.length ) {
13141                  uiHash.value = this.values( index );
13142                  uiHash.values = this.values();
13143              }
13144  
13145              //store the last changed value index for reference when handles overlap
13146              this._lastChangedValue = index;
13147  
13148              this._trigger( "change", event, uiHash );
13149          }
13150      },
13151  
13152      value: function( newValue ) {
13153          if ( arguments.length ) {
13154              this.options.value = this._trimAlignValue( newValue );
13155              this._refreshValue();
13156              this._change( null, 0 );
13157              return;
13158          }
13159  
13160          return this._value();
13161      },
13162  
13163      values: function( index, newValue ) {
13164          var vals,
13165              newValues,
13166              i;
13167  
13168          if ( arguments.length > 1 ) {
13169              this.options.values[ index ] = this._trimAlignValue( newValue );
13170              this._refreshValue();
13171              this._change( null, index );
13172              return;
13173          }
13174  
13175          if ( arguments.length ) {
13176              if ( $.isArray( arguments[ 0 ] ) ) {
13177                  vals = this.options.values;
13178                  newValues = arguments[ 0 ];
13179                  for ( i = 0; i < vals.length; i += 1 ) {
13180                      vals[ i ] = this._trimAlignValue( newValues[ i ] );
13181                      this._change( null, i );
13182                  }
13183                  this._refreshValue();
13184              } else {
13185                  if ( this.options.values && this.options.values.length ) {
13186                      return this._values( index );
13187                  } else {
13188                      return this.value();
13189                  }
13190              }
13191          } else {
13192              return this._values();
13193          }
13194      },
13195  
13196      _setOption: function( key, value ) {
13197          var i,
13198              valsLength = 0;
13199  
13200          if ( key === "range" && this.options.range === true ) {
13201              if ( value === "min" ) {
13202                  this.options.value = this._values( 0 );
13203                  this.options.values = null;
13204              } else if ( value === "max" ) {
13205                  this.options.value = this._values( this.options.values.length - 1 );
13206                  this.options.values = null;
13207              }
13208          }
13209  
13210          if ( $.isArray( this.options.values ) ) {
13211              valsLength = this.options.values.length;
13212          }
13213  
13214          if ( key === "disabled" ) {
13215              this.element.toggleClass( "ui-state-disabled", !!value );
13216          }
13217  
13218          this._super( key, value );
13219  
13220          switch ( key ) {
13221              case "orientation":
13222                  this._detectOrientation();
13223                  this.element
13224                      .removeClass( "ui-slider-horizontal ui-slider-vertical" )
13225                      .addClass( "ui-slider-" + this.orientation );
13226                  this._refreshValue();
13227  
13228                  // Reset positioning from previous orientation
13229                  this.handles.css( value === "horizontal" ? "bottom" : "left", "" );
13230                  break;
13231              case "value":
13232                  this._animateOff = true;
13233                  this._refreshValue();
13234                  this._change( null, 0 );
13235                  this._animateOff = false;
13236                  break;
13237              case "values":
13238                  this._animateOff = true;
13239                  this._refreshValue();
13240                  for ( i = 0; i < valsLength; i += 1 ) {
13241                      this._change( null, i );
13242                  }
13243                  this._animateOff = false;
13244                  break;
13245              case "step":
13246              case "min":
13247              case "max":
13248                  this._animateOff = true;
13249                  this._calculateNewMax();
13250                  this._refreshValue();
13251                  this._animateOff = false;
13252                  break;
13253              case "range":
13254                  this._animateOff = true;
13255                  this._refresh();
13256                  this._animateOff = false;
13257                  break;
13258          }
13259      },
13260  
13261      //internal value getter
13262      // _value() returns value trimmed by min and max, aligned by step
13263      _value: function() {
13264          var val = this.options.value;
13265          val = this._trimAlignValue( val );
13266  
13267          return val;
13268      },
13269  
13270      //internal values getter
13271      // _values() returns array of values trimmed by min and max, aligned by step
13272      // _values( index ) returns single value trimmed by min and max, aligned by step
13273      _values: function( index ) {
13274          var val,
13275              vals,
13276              i;
13277  
13278          if ( arguments.length ) {
13279              val = this.options.values[ index ];
13280              val = this._trimAlignValue( val );
13281  
13282              return val;
13283          } else if ( this.options.values && this.options.values.length ) {
13284              // .slice() creates a copy of the array
13285              // this copy gets trimmed by min and max and then returned
13286              vals = this.options.values.slice();
13287              for ( i = 0; i < vals.length; i += 1) {
13288                  vals[ i ] = this._trimAlignValue( vals[ i ] );
13289              }
13290  
13291              return vals;
13292          } else {
13293              return [];
13294          }
13295      },
13296  
13297      // returns the step-aligned value that val is closest to, between (inclusive) min and max
13298      _trimAlignValue: function( val ) {
13299          if ( val <= this._valueMin() ) {
13300              return this._valueMin();
13301          }
13302          if ( val >= this._valueMax() ) {
13303              return this._valueMax();
13304          }
13305          var step = ( this.options.step > 0 ) ? this.options.step : 1,
13306              valModStep = (val - this._valueMin()) % step,
13307              alignValue = val - valModStep;
13308  
13309          if ( Math.abs(valModStep) * 2 >= step ) {
13310              alignValue += ( valModStep > 0 ) ? step : ( -step );
13311          }
13312  
13313          // Since JavaScript has problems with large floats, round
13314          // the final value to 5 digits after the decimal point (see #4124)
13315          return parseFloat( alignValue.toFixed(5) );
13316      },
13317  
13318      _calculateNewMax: function() {
13319          var max = this.options.max,
13320              min = this._valueMin(),
13321              step = this.options.step,
13322              aboveMin = Math.floor( ( +( max - min ).toFixed( this._precision() ) ) / step ) * step;
13323          max = aboveMin + min;
13324          this.max = parseFloat( max.toFixed( this._precision() ) );
13325      },
13326  
13327      _precision: function() {
13328          var precision = this._precisionOf( this.options.step );
13329          if ( this.options.min !== null ) {
13330              precision = Math.max( precision, this._precisionOf( this.options.min ) );
13331          }
13332          return precision;
13333      },
13334  
13335      _precisionOf: function( num ) {
13336          var str = num.toString(),
13337              decimal = str.indexOf( "." );
13338          return decimal === -1 ? 0 : str.length - decimal - 1;
13339      },
13340  
13341      _valueMin: function() {
13342          return this.options.min;
13343      },
13344  
13345      _valueMax: function() {
13346          return this.max;
13347      },
13348  
13349      _refreshValue: function() {
13350          var lastValPercent, valPercent, value, valueMin, valueMax,
13351              oRange = this.options.range,
13352              o = this.options,
13353              that = this,
13354              animate = ( !this._animateOff ) ? o.animate : false,
13355              _set = {};
13356  
13357          if ( this.options.values && this.options.values.length ) {
13358              this.handles.each(function( i ) {
13359                  valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
13360                  _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
13361                  $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
13362                  if ( that.options.range === true ) {
13363                      if ( that.orientation === "horizontal" ) {
13364                          if ( i === 0 ) {
13365                              that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
13366                          }
13367                          if ( i === 1 ) {
13368                              that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13369                          }
13370                      } else {
13371                          if ( i === 0 ) {
13372                              that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
13373                          }
13374                          if ( i === 1 ) {
13375                              that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13376                          }
13377                      }
13378                  }
13379                  lastValPercent = valPercent;
13380              });
13381          } else {
13382              value = this.value();
13383              valueMin = this._valueMin();
13384              valueMax = this._valueMax();
13385              valPercent = ( valueMax !== valueMin ) ?
13386                      ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
13387                      0;
13388              _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
13389              this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
13390  
13391              if ( oRange === "min" && this.orientation === "horizontal" ) {
13392                  this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
13393              }
13394              if ( oRange === "max" && this.orientation === "horizontal" ) {
13395                  this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13396              }
13397              if ( oRange === "min" && this.orientation === "vertical" ) {
13398                  this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
13399              }
13400              if ( oRange === "max" && this.orientation === "vertical" ) {
13401                  this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13402              }
13403          }
13404      },
13405  
13406      _handleEvents: {
13407          keydown: function( event ) {
13408              var allowed, curVal, newVal, step,
13409                  index = $( event.target ).data( "ui-slider-handle-index" );
13410  
13411              switch ( event.keyCode ) {
13412                  case $.ui.keyCode.HOME:
13413                  case $.ui.keyCode.END:
13414                  case $.ui.keyCode.PAGE_UP:
13415                  case $.ui.keyCode.PAGE_DOWN:
13416                  case $.ui.keyCode.UP:
13417                  case $.ui.keyCode.RIGHT:
13418                  case $.ui.keyCode.DOWN:
13419                  case $.ui.keyCode.LEFT:
13420                      event.preventDefault();
13421                      if ( !this._keySliding ) {
13422                          this._keySliding = true;
13423                          $( event.target ).addClass( "ui-state-active" );
13424                          allowed = this._start( event, index );
13425                          if ( allowed === false ) {
13426                              return;
13427                          }
13428                      }
13429                      break;
13430              }
13431  
13432              step = this.options.step;
13433              if ( this.options.values && this.options.values.length ) {
13434                  curVal = newVal = this.values( index );
13435              } else {
13436                  curVal = newVal = this.value();
13437              }
13438  
13439              switch ( event.keyCode ) {
13440                  case $.ui.keyCode.HOME:
13441                      newVal = this._valueMin();
13442                      break;
13443                  case $.ui.keyCode.END:
13444                      newVal = this._valueMax();
13445                      break;
13446                  case $.ui.keyCode.PAGE_UP:
13447                      newVal = this._trimAlignValue(
13448                          curVal + ( ( this._valueMax() - this._valueMin() ) / this.numPages )
13449                      );
13450                      break;
13451                  case $.ui.keyCode.PAGE_DOWN:
13452                      newVal = this._trimAlignValue(
13453                          curVal - ( (this._valueMax() - this._valueMin()) / this.numPages ) );
13454                      break;
13455                  case $.ui.keyCode.UP:
13456                  case $.ui.keyCode.RIGHT:
13457                      if ( curVal === this._valueMax() ) {
13458                          return;
13459                      }
13460                      newVal = this._trimAlignValue( curVal + step );
13461                      break;
13462                  case $.ui.keyCode.DOWN:
13463                  case $.ui.keyCode.LEFT:
13464                      if ( curVal === this._valueMin() ) {
13465                          return;
13466                      }
13467                      newVal = this._trimAlignValue( curVal - step );
13468                      break;
13469              }
13470  
13471              this._slide( event, index, newVal );
13472          },
13473          keyup: function( event ) {
13474              var index = $( event.target ).data( "ui-slider-handle-index" );
13475  
13476              if ( this._keySliding ) {
13477                  this._keySliding = false;
13478                  this._stop( event, index );
13479                  this._change( event, index );
13480                  $( event.target ).removeClass( "ui-state-active" );
13481              }
13482          }
13483      }
13484  });
13485  
13486  
13487  /*!
13488   * jQuery UI Sortable 1.11.4
13489   * http://jqueryui.com
13490   *
13491   * Copyright jQuery Foundation and other contributors
13492   * Released under the MIT license.
13493   * http://jquery.org/license
13494   *
13495   * http://api.jqueryui.com/sortable/
13496   */
13497  
13498  
13499  var sortable = $.widget("ui.sortable", $.ui.mouse, {
13500      version: "1.11.4",
13501      widgetEventPrefix: "sort",
13502      ready: false,
13503      options: {
13504          appendTo: "parent",
13505          axis: false,
13506          connectWith: false,
13507          containment: false,
13508          cursor: "auto",
13509          cursorAt: false,
13510          dropOnEmpty: true,
13511          forcePlaceholderSize: false,
13512          forceHelperSize: false,
13513          grid: false,
13514          handle: false,
13515          helper: "original",
13516          items: "> *",
13517          opacity: false,
13518          placeholder: false,
13519          revert: false,
13520          scroll: true,
13521          scrollSensitivity: 20,
13522          scrollSpeed: 20,
13523          scope: "default",
13524          tolerance: "intersect",
13525          zIndex: 1000,
13526  
13527          // callbacks
13528          activate: null,
13529          beforeStop: null,
13530          change: null,
13531          deactivate: null,
13532          out: null,
13533          over: null,
13534          receive: null,
13535          remove: null,
13536          sort: null,
13537          start: null,
13538          stop: null,
13539          update: null
13540      },
13541  
13542      _isOverAxis: function( x, reference, size ) {
13543          return ( x >= reference ) && ( x < ( reference + size ) );
13544      },
13545  
13546      _isFloating: function( item ) {
13547          return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
13548      },
13549  
13550      _create: function() {
13551          this.containerCache = {};
13552          this.element.addClass("ui-sortable");
13553  
13554          //Get the items
13555          this.refresh();
13556  
13557          //Let's determine the parent's offset
13558          this.offset = this.element.offset();
13559  
13560          //Initialize mouse events for interaction
13561          this._mouseInit();
13562  
13563          this._setHandleClassName();
13564  
13565          //We're ready to go
13566          this.ready = true;
13567  
13568      },
13569  
13570      _setOption: function( key, value ) {
13571          this._super( key, value );
13572  
13573          if ( key === "handle" ) {
13574              this._setHandleClassName();
13575          }
13576      },
13577  
13578      _setHandleClassName: function() {
13579          this.element.find( ".ui-sortable-handle" ).removeClass( "ui-sortable-handle" );
13580          $.each( this.items, function() {
13581              ( this.instance.options.handle ?
13582                  this.item.find( this.instance.options.handle ) : this.item )
13583                  .addClass( "ui-sortable-handle" );
13584          });
13585      },
13586  
13587      _destroy: function() {
13588          this.element
13589              .removeClass( "ui-sortable ui-sortable-disabled" )
13590              .find( ".ui-sortable-handle" )
13591                  .removeClass( "ui-sortable-handle" );
13592          this._mouseDestroy();
13593  
13594          for ( var i = this.items.length - 1; i >= 0; i-- ) {
13595              this.items[i].item.removeData(this.widgetName + "-item");
13596          }
13597  
13598          return this;
13599      },
13600  
13601      _mouseCapture: function(event, overrideHandle) {
13602          var currentItem = null,
13603              validHandle = false,
13604              that = this;
13605  
13606          if (this.reverting) {
13607              return false;
13608          }
13609  
13610          if(this.options.disabled || this.options.type === "static") {
13611              return false;
13612          }
13613  
13614          //We have to refresh the items data once first
13615          this._refreshItems(event);
13616  
13617          //Find out if the clicked node (or one of its parents) is a actual item in this.items
13618          $(event.target).parents().each(function() {
13619              if($.data(this, that.widgetName + "-item") === that) {
13620                  currentItem = $(this);
13621                  return false;
13622              }
13623          });
13624          if($.data(event.target, that.widgetName + "-item") === that) {
13625              currentItem = $(event.target);
13626          }
13627  
13628          if(!currentItem) {
13629              return false;
13630          }
13631          if(this.options.handle && !overrideHandle) {
13632              $(this.options.handle, currentItem).find("*").addBack().each(function() {
13633                  if(this === event.target) {
13634                      validHandle = true;
13635                  }
13636              });
13637              if(!validHandle) {
13638                  return false;
13639              }
13640          }
13641  
13642          this.currentItem = currentItem;
13643          this._removeCurrentsFromItems();
13644          return true;
13645  
13646      },
13647  
13648      _mouseStart: function(event, overrideHandle, noActivation) {
13649  
13650          var i, body,
13651              o = this.options;
13652  
13653          this.currentContainer = this;
13654  
13655          //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
13656          this.refreshPositions();
13657  
13658          //Create and append the visible helper
13659          this.helper = this._createHelper(event);
13660  
13661          //Cache the helper size
13662          this._cacheHelperProportions();
13663  
13664          /*
13665           * - Position generation -
13666           * This block generates everything position related - it's the core of draggables.
13667           */
13668  
13669          //Cache the margins of the original element
13670          this._cacheMargins();
13671  
13672          //Get the next scrolling parent
13673          this.scrollParent = this.helper.scrollParent();
13674  
13675          //The element's absolute position on the page minus margins
13676          this.offset = this.currentItem.offset();
13677          this.offset = {
13678              top: this.offset.top - this.margins.top,
13679              left: this.offset.left - this.margins.left
13680          };
13681  
13682          $.extend(this.offset, {
13683              click: { //Where the click happened, relative to the element
13684                  left: event.pageX - this.offset.left,
13685                  top: event.pageY - this.offset.top
13686              },
13687              parent: this._getParentOffset(),
13688              relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
13689          });
13690  
13691          // Only after we got the offset, we can change the helper's position to absolute
13692          // TODO: Still need to figure out a way to make relative sorting possible
13693          this.helper.css("position", "absolute");
13694          this.cssPosition = this.helper.css("position");
13695  
13696          //Generate the original position
13697          this.originalPosition = this._generatePosition(event);
13698          this.originalPageX = event.pageX;
13699          this.originalPageY = event.pageY;
13700  
13701          //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
13702          (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
13703  
13704          //Cache the former DOM position
13705          this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
13706  
13707          //If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
13708          if(this.helper[0] !== this.currentItem[0]) {
13709              this.currentItem.hide();
13710          }
13711  
13712          //Create the placeholder
13713          this._createPlaceholder();
13714  
13715          //Set a containment if given in the options
13716          if(o.containment) {
13717              this._setContainment();
13718          }
13719  
13720          if( o.cursor && o.cursor !== "auto" ) { // cursor option
13721              body = this.document.find( "body" );
13722  
13723              // support: IE
13724              this.storedCursor = body.css( "cursor" );
13725              body.css( "cursor", o.cursor );
13726  
13727              this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
13728          }
13729  
13730          if(o.opacity) { // opacity option
13731              if (this.helper.css("opacity")) {
13732                  this._storedOpacity = this.helper.css("opacity");
13733              }
13734              this.helper.css("opacity", o.opacity);
13735          }
13736  
13737          if(o.zIndex) { // zIndex option
13738              if (this.helper.css("zIndex")) {
13739                  this._storedZIndex = this.helper.css("zIndex");
13740              }
13741              this.helper.css("zIndex", o.zIndex);
13742          }
13743  
13744          //Prepare scrolling
13745          if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
13746              this.overflowOffset = this.scrollParent.offset();
13747          }
13748  
13749          //Call callbacks
13750          this._trigger("start", event, this._uiHash());
13751  
13752          //Recache the helper size
13753          if(!this._preserveHelperProportions) {
13754              this._cacheHelperProportions();
13755          }
13756  
13757  
13758          //Post "activate" events to possible containers
13759          if( !noActivation ) {
13760              for ( i = this.containers.length - 1; i >= 0; i-- ) {
13761                  this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
13762              }
13763          }
13764  
13765          //Prepare possible droppables
13766          if($.ui.ddmanager) {
13767              $.ui.ddmanager.current = this;
13768          }
13769  
13770          if ($.ui.ddmanager && !o.dropBehaviour) {
13771              $.ui.ddmanager.prepareOffsets(this, event);
13772          }
13773  
13774          this.dragging = true;
13775  
13776          this.helper.addClass("ui-sortable-helper");
13777          this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
13778          return true;
13779  
13780      },
13781  
13782      _mouseDrag: function(event) {
13783          var i, item, itemElement, intersection,
13784              o = this.options,
13785              scrolled = false;
13786  
13787          //Compute the helpers position
13788          this.position = this._generatePosition(event);
13789          this.positionAbs = this._convertPositionTo("absolute");
13790  
13791          if (!this.lastPositionAbs) {
13792              this.lastPositionAbs = this.positionAbs;
13793          }
13794  
13795          //Do scrolling
13796          if(this.options.scroll) {
13797              if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
13798  
13799                  if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
13800                      this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
13801                  } else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
13802                      this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
13803                  }
13804  
13805                  if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
13806                      this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
13807                  } else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
13808                      this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
13809                  }
13810  
13811              } else {
13812  
13813                  if(event.pageY - this.document.scrollTop() < o.scrollSensitivity) {
13814                      scrolled = this.document.scrollTop(this.document.scrollTop() - o.scrollSpeed);
13815                  } else if(this.window.height() - (event.pageY - this.document.scrollTop()) < o.scrollSensitivity) {
13816                      scrolled = this.document.scrollTop(this.document.scrollTop() + o.scrollSpeed);
13817                  }
13818  
13819                  if(event.pageX - this.document.scrollLeft() < o.scrollSensitivity) {
13820                      scrolled = this.document.scrollLeft(this.document.scrollLeft() - o.scrollSpeed);
13821                  } else if(this.window.width() - (event.pageX - this.document.scrollLeft()) < o.scrollSensitivity) {
13822                      scrolled = this.document.scrollLeft(this.document.scrollLeft() + o.scrollSpeed);
13823                  }
13824  
13825              }
13826  
13827              if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
13828                  $.ui.ddmanager.prepareOffsets(this, event);
13829              }
13830          }
13831  
13832          //Regenerate the absolute position used for position checks
13833          this.positionAbs = this._convertPositionTo("absolute");
13834  
13835          //Set the helper position
13836          if(!this.options.axis || this.options.axis !== "y") {
13837              this.helper[0].style.left = this.position.left+"px";
13838          }
13839          if(!this.options.axis || this.options.axis !== "x") {
13840              this.helper[0].style.top = this.position.top+"px";
13841          }
13842  
13843          //Rearrange
13844          for (i = this.items.length - 1; i >= 0; i--) {
13845  
13846              //Cache variables and intersection, continue if no intersection
13847              item = this.items[i];
13848              itemElement = item.item[0];
13849              intersection = this._intersectsWithPointer(item);
13850              if (!intersection) {
13851                  continue;
13852              }
13853  
13854              // Only put the placeholder inside the current Container, skip all
13855              // items from other containers. This works because when moving
13856              // an item from one container to another the
13857              // currentContainer is switched before the placeholder is moved.
13858              //
13859              // Without this, moving items in "sub-sortables" can cause
13860              // the placeholder to jitter between the outer and inner container.
13861              if (item.instance !== this.currentContainer) {
13862                  continue;
13863              }
13864  
13865              // cannot intersect with itself
13866              // no useless actions that have been done before
13867              // no action if the item moved is the parent of the item checked
13868              if (itemElement !== this.currentItem[0] &&
13869                  this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
13870                  !$.contains(this.placeholder[0], itemElement) &&
13871                  (this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
13872              ) {
13873  
13874                  this.direction = intersection === 1 ? "down" : "up";
13875  
13876                  if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
13877                      this._rearrange(event, item);
13878                  } else {
13879                      break;
13880                  }
13881  
13882                  this._trigger("change", event, this._uiHash());
13883                  break;
13884              }
13885          }
13886  
13887          //Post events to containers
13888          this._contactContainers(event);
13889  
13890          //Interconnect with droppables
13891          if($.ui.ddmanager) {
13892              $.ui.ddmanager.drag(this, event);
13893          }
13894  
13895          //Call callbacks
13896          this._trigger("sort", event, this._uiHash());
13897  
13898          this.lastPositionAbs = this.positionAbs;
13899          return false;
13900  
13901      },
13902  
13903      _mouseStop: function(event, noPropagation) {
13904  
13905          if(!event) {
13906              return;
13907          }
13908  
13909          //If we are using droppables, inform the manager about the drop
13910          if ($.ui.ddmanager && !this.options.dropBehaviour) {
13911              $.ui.ddmanager.drop(this, event);
13912          }
13913  
13914          if(this.options.revert) {
13915              var that = this,
13916                  cur = this.placeholder.offset(),
13917                  axis = this.options.axis,
13918                  animation = {};
13919  
13920              if ( !axis || axis === "x" ) {
13921                  animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollLeft);
13922              }
13923              if ( !axis || axis === "y" ) {
13924                  animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollTop);
13925              }
13926              this.reverting = true;
13927              $(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
13928                  that._clear(event);
13929              });
13930          } else {
13931              this._clear(event, noPropagation);
13932          }
13933  
13934          return false;
13935  
13936      },
13937  
13938      cancel: function() {
13939  
13940          if(this.dragging) {
13941  
13942              this._mouseUp({ target: null });
13943  
13944              if(this.options.helper === "original") {
13945                  this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
13946              } else {
13947                  this.currentItem.show();
13948              }
13949  
13950              //Post deactivating events to containers
13951              for (var i = this.containers.length - 1; i >= 0; i--){
13952                  this.containers[i]._trigger("deactivate", null, this._uiHash(this));
13953                  if(this.containers[i].containerCache.over) {
13954                      this.containers[i]._trigger("out", null, this._uiHash(this));
13955                      this.containers[i].containerCache.over = 0;
13956                  }
13957              }
13958  
13959          }
13960  
13961          if (this.placeholder) {
13962              //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
13963              if(this.placeholder[0].parentNode) {
13964                  this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
13965              }
13966              if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
13967                  this.helper.remove();
13968              }
13969  
13970              $.extend(this, {
13971                  helper: null,
13972                  dragging: false,
13973                  reverting: false,
13974                  _noFinalSort: null
13975              });
13976  
13977              if(this.domPosition.prev) {
13978                  $(this.domPosition.prev).after(this.currentItem);
13979              } else {
13980                  $(this.domPosition.parent).prepend(this.currentItem);
13981              }
13982          }
13983  
13984          return this;
13985  
13986      },
13987  
13988      serialize: function(o) {
13989  
13990          var items = this._getItemsAsjQuery(o && o.connected),
13991              str = [];
13992          o = o || {};
13993  
13994          $(items).each(function() {
13995              var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
13996              if (res) {
13997                  str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
13998              }
13999          });
14000  
14001          if(!str.length && o.key) {
14002              str.push(o.key + "=");
14003          }
14004  
14005          return str.join("&");
14006  
14007      },
14008  
14009      toArray: function(o) {
14010  
14011          var items = this._getItemsAsjQuery(o && o.connected),
14012              ret = [];
14013  
14014          o = o || {};
14015  
14016          items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
14017          return ret;
14018  
14019      },
14020  
14021      /* Be careful with the following core functions */
14022      _intersectsWith: function(item) {
14023  
14024          var x1 = this.positionAbs.left,
14025              x2 = x1 + this.helperProportions.width,
14026              y1 = this.positionAbs.top,
14027              y2 = y1 + this.helperProportions.height,
14028              l = item.left,
14029              r = l + item.width,
14030              t = item.top,
14031              b = t + item.height,
14032              dyClick = this.offset.click.top,
14033              dxClick = this.offset.click.left,
14034              isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
14035              isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
14036              isOverElement = isOverElementHeight && isOverElementWidth;
14037  
14038          if ( this.options.tolerance === "pointer" ||
14039              this.options.forcePointerForContainers ||
14040              (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
14041          ) {
14042              return isOverElement;
14043          } else {
14044  
14045              return (l < x1 + (this.helperProportions.width / 2) && // Right Half
14046                  x2 - (this.helperProportions.width / 2) < r && // Left Half
14047                  t < y1 + (this.helperProportions.height / 2) && // Bottom Half
14048                  y2 - (this.helperProportions.height / 2) < b ); // Top Half
14049  
14050          }
14051      },
14052  
14053      _intersectsWithPointer: function(item) {
14054  
14055          var isOverElementHeight = (this.options.axis === "x") || this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
14056              isOverElementWidth = (this.options.axis === "y") || this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
14057              isOverElement = isOverElementHeight && isOverElementWidth,
14058              verticalDirection = this._getDragVerticalDirection(),
14059              horizontalDirection = this._getDragHorizontalDirection();
14060  
14061          if (!isOverElement) {
14062              return false;
14063          }
14064  
14065          return this.floating ?
14066              ( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
14067              : ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
14068  
14069      },
14070  
14071      _intersectsWithSides: function(item) {
14072  
14073          var isOverBottomHalf = this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
14074              isOverRightHalf = this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
14075              verticalDirection = this._getDragVerticalDirection(),
14076              horizontalDirection = this._getDragHorizontalDirection();
14077  
14078          if (this.floating && horizontalDirection) {
14079              return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
14080          } else {
14081              return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
14082          }
14083  
14084      },
14085  
14086      _getDragVerticalDirection: function() {
14087          var delta = this.positionAbs.top - this.lastPositionAbs.top;
14088          return delta !== 0 && (delta > 0 ? "down" : "up");
14089      },
14090  
14091      _getDragHorizontalDirection: function() {
14092          var delta = this.positionAbs.left - this.lastPositionAbs.left;
14093          return delta !== 0 && (delta > 0 ? "right" : "left");
14094      },
14095  
14096      refresh: function(event) {
14097          this._refreshItems(event);
14098          this._setHandleClassName();
14099          this.refreshPositions();
14100          return this;
14101      },
14102  
14103      _connectWith: function() {
14104          var options = this.options;
14105          return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
14106      },
14107  
14108      _getItemsAsjQuery: function(connected) {
14109  
14110          var i, j, cur, inst,
14111              items = [],
14112              queries = [],
14113              connectWith = this._connectWith();
14114  
14115          if(connectWith && connected) {
14116              for (i = connectWith.length - 1; i >= 0; i--){
14117                  cur = $(connectWith[i], this.document[0]);
14118                  for ( j = cur.length - 1; j >= 0; j--){
14119                      inst = $.data(cur[j], this.widgetFullName);
14120                      if(inst && inst !== this && !inst.options.disabled) {
14121                          queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), inst]);
14122                      }
14123                  }
14124              }
14125          }
14126  
14127          queries.push([$.isFunction(this.options.items) ? this.options.items.call(this.element, null, { options: this.options, item: this.currentItem }) : $(this.options.items, this.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), this]);
14128  
14129  		function addItems() {
14130              items.push( this );
14131          }
14132          for (i = queries.length - 1; i >= 0; i--){
14133              queries[i][0].each( addItems );
14134          }
14135  
14136          return $(items);
14137  
14138      },
14139  
14140      _removeCurrentsFromItems: function() {
14141  
14142          var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
14143  
14144          this.items = $.grep(this.items, function (item) {
14145              for (var j=0; j < list.length; j++) {
14146                  if(list[j] === item.item[0]) {
14147                      return false;
14148                  }
14149              }
14150              return true;
14151          });
14152  
14153      },
14154  
14155      _refreshItems: function(event) {
14156  
14157          this.items = [];
14158          this.containers = [this];
14159  
14160          var i, j, cur, inst, targetData, _queries, item, queriesLength,
14161              items = this.items,
14162              queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
14163              connectWith = this._connectWith();
14164  
14165          if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
14166              for (i = connectWith.length - 1; i >= 0; i--){
14167                  cur = $(connectWith[i], this.document[0]);
14168                  for (j = cur.length - 1; j >= 0; j--){
14169                      inst = $.data(cur[j], this.widgetFullName);
14170                      if(inst && inst !== this && !inst.options.disabled) {
14171                          queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
14172                          this.containers.push(inst);
14173                      }
14174                  }
14175              }
14176          }
14177  
14178          for (i = queries.length - 1; i >= 0; i--) {
14179              targetData = queries[i][1];
14180              _queries = queries[i][0];
14181  
14182              for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
14183                  item = $(_queries[j]);
14184  
14185                  item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
14186  
14187                  items.push({
14188                      item: item,
14189                      instance: targetData,
14190                      width: 0, height: 0,
14191                      left: 0, top: 0
14192                  });
14193              }
14194          }
14195  
14196      },
14197  
14198      refreshPositions: function(fast) {
14199  
14200          // Determine whether items are being displayed horizontally
14201          this.floating = this.items.length ?
14202              this.options.axis === "x" || this._isFloating( this.items[ 0 ].item ) :
14203              false;
14204  
14205          //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
14206          if(this.offsetParent && this.helper) {
14207              this.offset.parent = this._getParentOffset();
14208          }
14209  
14210          var i, item, t, p;
14211  
14212          for (i = this.items.length - 1; i >= 0; i--){
14213              item = this.items[i];
14214  
14215              //We ignore calculating positions of all connected containers when we're not over them
14216              if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
14217                  continue;
14218              }
14219  
14220              t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
14221  
14222              if (!fast) {
14223                  item.width = t.outerWidth();
14224                  item.height = t.outerHeight();
14225              }
14226  
14227              p = t.offset();
14228              item.left = p.left;
14229              item.top = p.top;
14230          }
14231  
14232          if(this.options.custom && this.options.custom.refreshContainers) {
14233              this.options.custom.refreshContainers.call(this);
14234          } else {
14235              for (i = this.containers.length - 1; i >= 0; i--){
14236                  p = this.containers[i].element.offset();
14237                  this.containers[i].containerCache.left = p.left;
14238                  this.containers[i].containerCache.top = p.top;
14239                  this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
14240                  this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
14241              }
14242          }
14243  
14244          return this;
14245      },
14246  
14247      _createPlaceholder: function(that) {
14248          that = that || this;
14249          var className,
14250              o = that.options;
14251  
14252          if(!o.placeholder || o.placeholder.constructor === String) {
14253              className = o.placeholder;
14254              o.placeholder = {
14255                  element: function() {
14256  
14257                      var nodeName = that.currentItem[0].nodeName.toLowerCase(),
14258                          element = $( "<" + nodeName + ">", that.document[0] )
14259                              .addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
14260                              .removeClass("ui-sortable-helper");
14261  
14262                      if ( nodeName === "tbody" ) {
14263                          that._createTrPlaceholder(
14264                              that.currentItem.find( "tr" ).eq( 0 ),
14265                              $( "<tr>", that.document[ 0 ] ).appendTo( element )
14266                          );
14267                      } else if ( nodeName === "tr" ) {
14268                          that._createTrPlaceholder( that.currentItem, element );
14269                      } else if ( nodeName === "img" ) {
14270                          element.attr( "src", that.currentItem.attr( "src" ) );
14271                      }
14272  
14273                      if ( !className ) {
14274                          element.css( "visibility", "hidden" );
14275                      }
14276  
14277                      return element;
14278                  },
14279                  update: function(container, p) {
14280  
14281                      // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
14282                      // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
14283                      if(className && !o.forcePlaceholderSize) {
14284                          return;
14285                      }
14286  
14287                      //If the element doesn't have a actual height by itself (without styles coming from a stylesheet), it receives the inline height from the dragged item
14288                      if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
14289                      if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
14290                  }
14291              };
14292          }
14293  
14294          //Create the placeholder
14295          that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
14296  
14297          //Append it after the actual current item
14298          that.currentItem.after(that.placeholder);
14299  
14300          //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
14301          o.placeholder.update(that, that.placeholder);
14302  
14303      },
14304  
14305      _createTrPlaceholder: function( sourceTr, targetTr ) {
14306          var that = this;
14307  
14308          sourceTr.children().each(function() {
14309              $( "<td>&#160;</td>", that.document[ 0 ] )
14310                  .attr( "colspan", $( this ).attr( "colspan" ) || 1 )
14311                  .appendTo( targetTr );
14312          });
14313      },
14314  
14315      _contactContainers: function(event) {
14316          var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, cur, nearBottom, floating, axis,
14317              innermostContainer = null,
14318              innermostIndex = null;
14319  
14320          // get innermost container that intersects with item
14321          for (i = this.containers.length - 1; i >= 0; i--) {
14322  
14323              // never consider a container that's located within the item itself
14324              if($.contains(this.currentItem[0], this.containers[i].element[0])) {
14325                  continue;
14326              }
14327  
14328              if(this._intersectsWith(this.containers[i].containerCache)) {
14329  
14330                  // if we've already found a container and it's more "inner" than this, then continue
14331                  if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
14332                      continue;
14333                  }
14334  
14335                  innermostContainer = this.containers[i];
14336                  innermostIndex = i;
14337  
14338              } else {
14339                  // container doesn't intersect. trigger "out" event if necessary
14340                  if(this.containers[i].containerCache.over) {
14341                      this.containers[i]._trigger("out", event, this._uiHash(this));
14342                      this.containers[i].containerCache.over = 0;
14343                  }
14344              }
14345  
14346          }
14347  
14348          // if no intersecting containers found, return
14349          if(!innermostContainer) {
14350              return;
14351          }
14352  
14353          // move the item into the container if it's not there already
14354          if(this.containers.length === 1) {
14355              if (!this.containers[innermostIndex].containerCache.over) {
14356                  this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
14357                  this.containers[innermostIndex].containerCache.over = 1;
14358              }
14359          } else {
14360  
14361              //When entering a new container, we will find the item with the least distance and append our item near it
14362              dist = 10000;
14363              itemWithLeastDistance = null;
14364              floating = innermostContainer.floating || this._isFloating(this.currentItem);
14365              posProperty = floating ? "left" : "top";
14366              sizeProperty = floating ? "width" : "height";
14367              axis = floating ? "clientX" : "clientY";
14368  
14369              for (j = this.items.length - 1; j >= 0; j--) {
14370                  if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
14371                      continue;
14372                  }
14373                  if(this.items[j].item[0] === this.currentItem[0]) {
14374                      continue;
14375                  }
14376  
14377                  cur = this.items[j].item.offset()[posProperty];
14378                  nearBottom = false;
14379                  if ( event[ axis ] - cur > this.items[ j ][ sizeProperty ] / 2 ) {
14380                      nearBottom = true;
14381                  }
14382  
14383                  if ( Math.abs( event[ axis ] - cur ) < dist ) {
14384                      dist = Math.abs( event[ axis ] - cur );
14385                      itemWithLeastDistance = this.items[ j ];
14386                      this.direction = nearBottom ? "up": "down";
14387                  }
14388              }
14389  
14390              //Check if dropOnEmpty is enabled
14391              if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
14392                  return;
14393              }
14394  
14395              if(this.currentContainer === this.containers[innermostIndex]) {
14396                  if ( !this.currentContainer.containerCache.over ) {
14397                      this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash() );
14398                      this.currentContainer.containerCache.over = 1;
14399                  }
14400                  return;
14401              }
14402  
14403              itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
14404              this._trigger("change", event, this._uiHash());
14405              this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
14406              this.currentContainer = this.containers[innermostIndex];
14407  
14408              //Update the placeholder
14409              this.options.placeholder.update(this.currentContainer, this.placeholder);
14410  
14411              this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
14412              this.containers[innermostIndex].containerCache.over = 1;
14413          }
14414  
14415  
14416      },
14417  
14418      _createHelper: function(event) {
14419  
14420          var o = this.options,
14421              helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
14422  
14423          //Add the helper to the DOM if that didn't happen already
14424          if(!helper.parents("body").length) {
14425              $(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
14426          }
14427  
14428          if(helper[0] === this.currentItem[0]) {
14429              this._storedCSS = { width: this.currentItem[0].style.width, height: this.currentItem[0].style.height, position: this.currentItem.css("position"), top: this.currentItem.css("top"), left: this.currentItem.css("left") };
14430          }
14431  
14432          if(!helper[0].style.width || o.forceHelperSize) {
14433              helper.width(this.currentItem.width());
14434          }
14435          if(!helper[0].style.height || o.forceHelperSize) {
14436              helper.height(this.currentItem.height());
14437          }
14438  
14439          return helper;
14440  
14441      },
14442  
14443      _adjustOffsetFromHelper: function(obj) {
14444          if (typeof obj === "string") {
14445              obj = obj.split(" ");
14446          }
14447          if ($.isArray(obj)) {
14448              obj = {left: +obj[0], top: +obj[1] || 0};
14449          }
14450          if ("left" in obj) {
14451              this.offset.click.left = obj.left + this.margins.left;
14452          }
14453          if ("right" in obj) {
14454              this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
14455          }
14456          if ("top" in obj) {
14457              this.offset.click.top = obj.top + this.margins.top;
14458          }
14459          if ("bottom" in obj) {
14460              this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
14461          }
14462      },
14463  
14464      _getParentOffset: function() {
14465  
14466  
14467          //Get the offsetParent and cache its position
14468          this.offsetParent = this.helper.offsetParent();
14469          var po = this.offsetParent.offset();
14470  
14471          // This is a special case where we need to modify a offset calculated on start, since the following happened:
14472          // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
14473          // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
14474          //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
14475          if(this.cssPosition === "absolute" && this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) {
14476              po.left += this.scrollParent.scrollLeft();
14477              po.top += this.scrollParent.scrollTop();
14478          }
14479  
14480          // This needs to be actually done for all browsers, since pageX/pageY includes this information
14481          // with an ugly IE fix
14482          if( this.offsetParent[0] === this.document[0].body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
14483              po = { top: 0, left: 0 };
14484          }
14485  
14486          return {
14487              top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
14488              left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
14489          };
14490  
14491      },
14492  
14493      _getRelativeOffset: function() {
14494  
14495          if(this.cssPosition === "relative") {
14496              var p = this.currentItem.position();
14497              return {
14498                  top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
14499                  left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
14500              };
14501          } else {
14502              return { top: 0, left: 0 };
14503          }
14504  
14505      },
14506  
14507      _cacheMargins: function() {
14508          this.margins = {
14509              left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
14510              top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
14511          };
14512      },
14513  
14514      _cacheHelperProportions: function() {
14515          this.helperProportions = {
14516              width: this.helper.outerWidth(),
14517              height: this.helper.outerHeight()
14518          };
14519      },
14520  
14521      _setContainment: function() {
14522  
14523          var ce, co, over,
14524              o = this.options;
14525          if(o.containment === "parent") {
14526              o.containment = this.helper[0].parentNode;
14527          }
14528          if(o.containment === "document" || o.containment === "window") {
14529              this.containment = [
14530                  0 - this.offset.relative.left - this.offset.parent.left,
14531                  0 - this.offset.relative.top - this.offset.parent.top,
14532                  o.containment === "document" ? this.document.width() : this.window.width() - this.helperProportions.width - this.margins.left,
14533                  (o.containment === "document" ? this.document.width() : this.window.height() || this.document[0].body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
14534              ];
14535          }
14536  
14537          if(!(/^(document|window|parent)$/).test(o.containment)) {
14538              ce = $(o.containment)[0];
14539              co = $(o.containment).offset();
14540              over = ($(ce).css("overflow") !== "hidden");
14541  
14542              this.containment = [
14543                  co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
14544                  co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
14545                  co.left+(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left,
14546                  co.top+(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top
14547              ];
14548          }
14549  
14550      },
14551  
14552      _convertPositionTo: function(d, pos) {
14553  
14554          if(!pos) {
14555              pos = this.position;
14556          }
14557          var mod = d === "absolute" ? 1 : -1,
14558              scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
14559              scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
14560  
14561          return {
14562              top: (
14563                  pos.top    +                                                                // The absolute mouse position
14564                  this.offset.relative.top * mod +                                        // Only for relative positioned nodes: Relative offset from element to offset parent
14565                  this.offset.parent.top * mod -                                            // The offsetParent's offset without borders (offset + border)
14566                  ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
14567              ),
14568              left: (
14569                  pos.left +                                                                // The absolute mouse position
14570                  this.offset.relative.left * mod +                                        // Only for relative positioned nodes: Relative offset from element to offset parent
14571                  this.offset.parent.left * mod    -                                        // The offsetParent's offset without borders (offset + border)
14572                  ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
14573              )
14574          };
14575  
14576      },
14577  
14578      _generatePosition: function(event) {
14579  
14580          var top, left,
14581              o = this.options,
14582              pageX = event.pageX,
14583              pageY = event.pageY,
14584              scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
14585  
14586          // This is another very weird special case that only happens for relative elements:
14587          // 1. If the css position is relative
14588          // 2. and the scroll parent is the document or similar to the offset parent
14589          // we have to refresh the relative offset during the scroll so there are no jumps
14590          if(this.cssPosition === "relative" && !(this.scrollParent[0] !== this.document[0] && this.scrollParent[0] !== this.offsetParent[0])) {
14591              this.offset.relative = this._getRelativeOffset();
14592          }
14593  
14594          /*
14595           * - Position constraining -
14596           * Constrain the position to a mix of grid, containment.
14597           */
14598  
14599          if(this.originalPosition) { //If we are not dragging yet, we won't check for options
14600  
14601              if(this.containment) {
14602                  if(event.pageX - this.offset.click.left < this.containment[0]) {
14603                      pageX = this.containment[0] + this.offset.click.left;
14604                  }
14605                  if(event.pageY - this.offset.click.top < this.containment[1]) {
14606                      pageY = this.containment[1] + this.offset.click.top;
14607                  }
14608                  if(event.pageX - this.offset.click.left > this.containment[2]) {
14609                      pageX = this.containment[2] + this.offset.click.left;
14610                  }
14611                  if(event.pageY - this.offset.click.top > this.containment[3]) {
14612                      pageY = this.containment[3] + this.offset.click.top;
14613                  }
14614              }
14615  
14616              if(o.grid) {
14617                  top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
14618                  pageY = this.containment ? ( (top - this.offset.click.top >= this.containment[1] && top - this.offset.click.top <= this.containment[3]) ? top : ((top - this.offset.click.top >= this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
14619  
14620                  left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
14621                  pageX = this.containment ? ( (left - this.offset.click.left >= this.containment[0] && left - this.offset.click.left <= this.containment[2]) ? left : ((left - this.offset.click.left >= this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
14622              }
14623  
14624          }
14625  
14626          return {
14627              top: (
14628                  pageY -                                                                // The absolute mouse position
14629                  this.offset.click.top -                                                    // Click offset (relative to the element)
14630                  this.offset.relative.top    -                                            // Only for relative positioned nodes: Relative offset from element to offset parent
14631                  this.offset.parent.top +                                                // The offsetParent's offset without borders (offset + border)
14632                  ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
14633              ),
14634              left: (
14635                  pageX -                                                                // The absolute mouse position
14636                  this.offset.click.left -                                                // Click offset (relative to the element)
14637                  this.offset.relative.left    -                                            // Only for relative positioned nodes: Relative offset from element to offset parent
14638                  this.offset.parent.left +                                                // The offsetParent's offset without borders (offset + border)
14639                  ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
14640              )
14641          };
14642  
14643      },
14644  
14645      _rearrange: function(event, i, a, hardRefresh) {
14646  
14647          a ? a[0].appendChild(this.placeholder[0]) : i.item[0].parentNode.insertBefore(this.placeholder[0], (this.direction === "down" ? i.item[0] : i.item[0].nextSibling));
14648  
14649          //Various things done here to improve the performance:
14650          // 1. we create a setTimeout, that calls refreshPositions
14651          // 2. on the instance, we have a counter variable, that get's higher after every append
14652          // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
14653          // 4. this lets only the last addition to the timeout stack through
14654          this.counter = this.counter ? ++this.counter : 1;
14655          var counter = this.counter;
14656  
14657          this._delay(function() {
14658              if(counter === this.counter) {
14659                  this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
14660              }
14661          });
14662  
14663      },
14664  
14665      _clear: function(event, noPropagation) {
14666  
14667          this.reverting = false;
14668          // We delay all events that have to be triggered to after the point where the placeholder has been removed and
14669          // everything else normalized again
14670          var i,
14671              delayedTriggers = [];
14672  
14673          // We first have to update the dom position of the actual currentItem
14674          // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
14675          if(!this._noFinalSort && this.currentItem.parent().length) {
14676              this.placeholder.before(this.currentItem);
14677          }
14678          this._noFinalSort = null;
14679  
14680          if(this.helper[0] === this.currentItem[0]) {
14681              for(i in this._storedCSS) {
14682                  if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
14683                      this._storedCSS[i] = "";
14684                  }
14685              }
14686              this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
14687          } else {
14688              this.currentItem.show();
14689          }
14690  
14691          if(this.fromOutside && !noPropagation) {
14692              delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
14693          }
14694          if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
14695              delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
14696          }
14697  
14698          // Check if the items Container has Changed and trigger appropriate
14699          // events.
14700          if (this !== this.currentContainer) {
14701              if(!noPropagation) {
14702                  delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
14703                  delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); };  }).call(this, this.currentContainer));
14704                  delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this));  }; }).call(this, this.currentContainer));
14705              }
14706          }
14707  
14708  
14709          //Post events to containers
14710  		function delayEvent( type, instance, container ) {
14711              return function( event ) {
14712                  container._trigger( type, event, instance._uiHash( instance ) );
14713              };
14714          }
14715          for (i = this.containers.length - 1; i >= 0; i--){
14716              if (!noPropagation) {
14717                  delayedTriggers.push( delayEvent( "deactivate", this, this.containers[ i ] ) );
14718              }
14719              if(this.containers[i].containerCache.over) {
14720                  delayedTriggers.push( delayEvent( "out", this, this.containers[ i ] ) );
14721                  this.containers[i].containerCache.over = 0;
14722              }
14723          }
14724  
14725          //Do what was originally in plugins
14726          if ( this.storedCursor ) {
14727              this.document.find( "body" ).css( "cursor", this.storedCursor );
14728              this.storedStylesheet.remove();
14729          }
14730          if(this._storedOpacity) {
14731              this.helper.css("opacity", this._storedOpacity);
14732          }
14733          if(this._storedZIndex) {
14734              this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
14735          }
14736  
14737          this.dragging = false;
14738  
14739          if(!noPropagation) {
14740              this._trigger("beforeStop", event, this._uiHash());
14741          }
14742  
14743          //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
14744          this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
14745  
14746          if ( !this.cancelHelperRemoval ) {
14747              if ( this.helper[ 0 ] !== this.currentItem[ 0 ] ) {
14748                  this.helper.remove();
14749              }
14750              this.helper = null;
14751          }
14752  
14753          if(!noPropagation) {
14754              for (i=0; i < delayedTriggers.length; i++) {
14755                  delayedTriggers[i].call(this, event);
14756              } //Trigger all delayed events
14757              this._trigger("stop", event, this._uiHash());
14758          }
14759  
14760          this.fromOutside = false;
14761          return !this.cancelHelperRemoval;
14762  
14763      },
14764  
14765      _trigger: function() {
14766          if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
14767              this.cancel();
14768          }
14769      },
14770  
14771      _uiHash: function(_inst) {
14772          var inst = _inst || this;
14773          return {
14774              helper: inst.helper,
14775              placeholder: inst.placeholder || $([]),
14776              position: inst.position,
14777              originalPosition: inst.originalPosition,
14778              offset: inst.positionAbs,
14779              item: inst.currentItem,
14780              sender: _inst ? _inst.element : null
14781          };
14782      }
14783  
14784  });
14785  
14786  
14787  /*!
14788   * jQuery UI Spinner 1.11.4
14789   * http://jqueryui.com
14790   *
14791   * Copyright jQuery Foundation and other contributors
14792   * Released under the MIT license.
14793   * http://jquery.org/license
14794   *
14795   * http://api.jqueryui.com/spinner/
14796   */
14797  
14798  
14799  function spinner_modifier( fn ) {
14800      return function() {
14801          var previous = this.element.val();
14802          fn.apply( this, arguments );
14803          this._refresh();
14804          if ( previous !== this.element.val() ) {
14805              this._trigger( "change" );
14806          }
14807      };
14808  }
14809  
14810  var spinner = $.widget( "ui.spinner", {
14811      version: "1.11.4",
14812      defaultElement: "<input>",
14813      widgetEventPrefix: "spin",
14814      options: {
14815          culture: null,
14816          icons: {
14817              down: "ui-icon-triangle-1-s",
14818              up: "ui-icon-triangle-1-n"
14819          },
14820          incremental: true,
14821          max: null,
14822          min: null,
14823          numberFormat: null,
14824          page: 10,
14825          step: 1,
14826  
14827          change: null,
14828          spin: null,
14829          start: null,
14830          stop: null
14831      },
14832  
14833      _create: function() {
14834          // handle string values that need to be parsed
14835          this._setOption( "max", this.options.max );
14836          this._setOption( "min", this.options.min );
14837          this._setOption( "step", this.options.step );
14838  
14839          // Only format if there is a value, prevents the field from being marked
14840          // as invalid in Firefox, see #9573.
14841          if ( this.value() !== "" ) {
14842              // Format the value, but don't constrain.
14843              this._value( this.element.val(), true );
14844          }
14845  
14846          this._draw();
14847          this._on( this._events );
14848          this._refresh();
14849  
14850          // turning off autocomplete prevents the browser from remembering the
14851          // value when navigating through history, so we re-enable autocomplete
14852          // if the page is unloaded before the widget is destroyed. #7790
14853          this._on( this.window, {
14854              beforeunload: function() {
14855                  this.element.removeAttr( "autocomplete" );
14856              }
14857          });
14858      },
14859  
14860      _getCreateOptions: function() {
14861          var options = {},
14862              element = this.element;
14863  
14864          $.each( [ "min", "max", "step" ], function( i, option ) {
14865              var value = element.attr( option );
14866              if ( value !== undefined && value.length ) {
14867                  options[ option ] = value;
14868              }
14869          });
14870  
14871          return options;
14872      },
14873  
14874      _events: {
14875          keydown: function( event ) {
14876              if ( this._start( event ) && this._keydown( event ) ) {
14877                  event.preventDefault();
14878              }
14879          },
14880          keyup: "_stop",
14881          focus: function() {
14882              this.previous = this.element.val();
14883          },
14884          blur: function( event ) {
14885              if ( this.cancelBlur ) {
14886                  delete this.cancelBlur;
14887                  return;
14888              }
14889  
14890              this._stop();
14891              this._refresh();
14892              if ( this.previous !== this.element.val() ) {
14893                  this._trigger( "change", event );
14894              }
14895          },
14896          mousewheel: function( event, delta ) {
14897              if ( !delta ) {
14898                  return;
14899              }
14900              if ( !this.spinning && !this._start( event ) ) {
14901                  return false;
14902              }
14903  
14904              this._spin( (delta > 0 ? 1 : -1) * this.options.step, event );
14905              clearTimeout( this.mousewheelTimer );
14906              this.mousewheelTimer = this._delay(function() {
14907                  if ( this.spinning ) {
14908                      this._stop( event );
14909                  }
14910              }, 100 );
14911              event.preventDefault();
14912          },
14913          "mousedown .ui-spinner-button": function( event ) {
14914              var previous;
14915  
14916              // We never want the buttons to have focus; whenever the user is
14917              // interacting with the spinner, the focus should be on the input.
14918              // If the input is focused then this.previous is properly set from
14919              // when the input first received focus. If the input is not focused
14920              // then we need to set this.previous based on the value before spinning.
14921              previous = this.element[0] === this.document[0].activeElement ?
14922                  this.previous : this.element.val();
14923  			function checkFocus() {
14924                  var isActive = this.element[0] === this.document[0].activeElement;
14925                  if ( !isActive ) {
14926                      this.element.focus();
14927                      this.previous = previous;
14928                      // support: IE
14929                      // IE sets focus asynchronously, so we need to check if focus
14930                      // moved off of the input because the user clicked on the button.
14931                      this._delay(function() {
14932                          this.previous = previous;
14933                      });
14934                  }
14935              }
14936  
14937              // ensure focus is on (or stays on) the text field
14938              event.preventDefault();
14939              checkFocus.call( this );
14940  
14941              // support: IE
14942              // IE doesn't prevent moving focus even with event.preventDefault()
14943              // so we set a flag to know when we should ignore the blur event
14944              // and check (again) if focus moved off of the input.
14945              this.cancelBlur = true;
14946              this._delay(function() {
14947                  delete this.cancelBlur;
14948                  checkFocus.call( this );
14949              });
14950  
14951              if ( this._start( event ) === false ) {
14952                  return;
14953              }
14954  
14955              this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
14956          },
14957          "mouseup .ui-spinner-button": "_stop",
14958          "mouseenter .ui-spinner-button": function( event ) {
14959              // button will add ui-state-active if mouse was down while mouseleave and kept down
14960              if ( !$( event.currentTarget ).hasClass( "ui-state-active" ) ) {
14961                  return;
14962              }
14963  
14964              if ( this._start( event ) === false ) {
14965                  return false;
14966              }
14967              this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
14968          },
14969          // TODO: do we really want to consider this a stop?
14970          // shouldn't we just stop the repeater and wait until mouseup before
14971          // we trigger the stop event?
14972          "mouseleave .ui-spinner-button": "_stop"
14973      },
14974  
14975      _draw: function() {
14976          var uiSpinner = this.uiSpinner = this.element
14977              .addClass( "ui-spinner-input" )
14978              .attr( "autocomplete", "off" )
14979              .wrap( this._uiSpinnerHtml() )
14980              .parent()
14981                  // add buttons
14982                  .append( this._buttonHtml() );
14983  
14984          this.element.attr( "role", "spinbutton" );
14985  
14986          // button bindings
14987          this.buttons = uiSpinner.find( ".ui-spinner-button" )
14988              .attr( "tabIndex", -1 )
14989              .button()
14990              .removeClass( "ui-corner-all" );
14991  
14992          // IE 6 doesn't understand height: 50% for the buttons
14993          // unless the wrapper has an explicit height
14994          if ( this.buttons.height() > Math.ceil( uiSpinner.height() * 0.5 ) &&
14995                  uiSpinner.height() > 0 ) {
14996              uiSpinner.height( uiSpinner.height() );
14997          }
14998  
14999          // disable spinner if element was already disabled
15000          if ( this.options.disabled ) {
15001              this.disable();
15002          }
15003      },
15004  
15005      _keydown: function( event ) {
15006          var options = this.options,
15007              keyCode = $.ui.keyCode;
15008  
15009          switch ( event.keyCode ) {
15010          case keyCode.UP:
15011              this._repeat( null, 1, event );
15012              return true;
15013          case keyCode.DOWN:
15014              this._repeat( null, -1, event );
15015              return true;
15016          case keyCode.PAGE_UP:
15017              this._repeat( null, options.page, event );
15018              return true;
15019          case keyCode.PAGE_DOWN:
15020              this._repeat( null, -options.page, event );
15021              return true;
15022          }
15023  
15024          return false;
15025      },
15026  
15027      _uiSpinnerHtml: function() {
15028          return "<span class='ui-spinner ui-widget ui-widget-content ui-corner-all'></span>";
15029      },
15030  
15031      _buttonHtml: function() {
15032          return "" +
15033              "<a class='ui-spinner-button ui-spinner-up ui-corner-tr'>" +
15034                  "<span class='ui-icon " + this.options.icons.up + "'>&#9650;</span>" +
15035              "</a>" +
15036              "<a class='ui-spinner-button ui-spinner-down ui-corner-br'>" +
15037                  "<span class='ui-icon " + this.options.icons.down + "'>&#9660;</span>" +
15038              "</a>";
15039      },
15040  
15041      _start: function( event ) {
15042          if ( !this.spinning && this._trigger( "start", event ) === false ) {
15043              return false;
15044          }
15045  
15046          if ( !this.counter ) {
15047              this.counter = 1;
15048          }
15049          this.spinning = true;
15050          return true;
15051      },
15052  
15053      _repeat: function( i, steps, event ) {
15054          i = i || 500;
15055  
15056          clearTimeout( this.timer );
15057          this.timer = this._delay(function() {
15058              this._repeat( 40, steps, event );
15059          }, i );
15060  
15061          this._spin( steps * this.options.step, event );
15062      },
15063  
15064      _spin: function( step, event ) {
15065          var value = this.value() || 0;
15066  
15067          if ( !this.counter ) {
15068              this.counter = 1;
15069          }
15070  
15071          value = this._adjustValue( value + step * this._increment( this.counter ) );
15072  
15073          if ( !this.spinning || this._trigger( "spin", event, { value: value } ) !== false) {
15074              this._value( value );
15075              this.counter++;
15076          }
15077      },
15078  
15079      _increment: function( i ) {
15080          var incremental = this.options.incremental;
15081  
15082          if ( incremental ) {
15083              return $.isFunction( incremental ) ?
15084                  incremental( i ) :
15085                  Math.floor( i * i * i / 50000 - i * i / 500 + 17 * i / 200 + 1 );
15086          }
15087  
15088          return 1;
15089      },
15090  
15091      _precision: function() {
15092          var precision = this._precisionOf( this.options.step );
15093          if ( this.options.min !== null ) {
15094              precision = Math.max( precision, this._precisionOf( this.options.min ) );
15095          }
15096          return precision;
15097      },
15098  
15099      _precisionOf: function( num ) {
15100          var str = num.toString(),
15101              decimal = str.indexOf( "." );
15102          return decimal === -1 ? 0 : str.length - decimal - 1;
15103      },
15104  
15105      _adjustValue: function( value ) {
15106          var base, aboveMin,
15107              options = this.options;
15108  
15109          // make sure we're at a valid step
15110          // - find out where we are relative to the base (min or 0)
15111          base = options.min !== null ? options.min : 0;
15112          aboveMin = value - base;
15113          // - round to the nearest step
15114          aboveMin = Math.round(aboveMin / options.step) * options.step;
15115          // - rounding is based on 0, so adjust back to our base
15116          value = base + aboveMin;
15117  
15118          // fix precision from bad JS floating point math
15119          value = parseFloat( value.toFixed( this._precision() ) );
15120  
15121          // clamp the value
15122          if ( options.max !== null && value > options.max) {
15123              return options.max;
15124          }
15125          if ( options.min !== null && value < options.min ) {
15126              return options.min;
15127          }
15128  
15129          return value;
15130      },
15131  
15132      _stop: function( event ) {
15133          if ( !this.spinning ) {
15134              return;
15135          }
15136  
15137          clearTimeout( this.timer );
15138          clearTimeout( this.mousewheelTimer );
15139          this.counter = 0;
15140          this.spinning = false;
15141          this._trigger( "stop", event );
15142      },
15143  
15144      _setOption: function( key, value ) {
15145          if ( key === "culture" || key === "numberFormat" ) {
15146              var prevValue = this._parse( this.element.val() );
15147              this.options[ key ] = value;
15148              this.element.val( this._format( prevValue ) );
15149              return;
15150          }
15151  
15152          if ( key === "max" || key === "min" || key === "step" ) {
15153              if ( typeof value === "string" ) {
15154                  value = this._parse( value );
15155              }
15156          }
15157          if ( key === "icons" ) {
15158              this.buttons.first().find( ".ui-icon" )
15159                  .removeClass( this.options.icons.up )
15160                  .addClass( value.up );
15161              this.buttons.last().find( ".ui-icon" )
15162                  .removeClass( this.options.icons.down )
15163                  .addClass( value.down );
15164          }
15165  
15166          this._super( key, value );
15167  
15168          if ( key === "disabled" ) {
15169              this.widget().toggleClass( "ui-state-disabled", !!value );
15170              this.element.prop( "disabled", !!value );
15171              this.buttons.button( value ? "disable" : "enable" );
15172          }
15173      },
15174  
15175      _setOptions: spinner_modifier(function( options ) {
15176          this._super( options );
15177      }),
15178  
15179      _parse: function( val ) {
15180          if ( typeof val === "string" && val !== "" ) {
15181              val = window.Globalize && this.options.numberFormat ?
15182                  Globalize.parseFloat( val, 10, this.options.culture ) : +val;
15183          }
15184          return val === "" || isNaN( val ) ? null : val;
15185      },
15186  
15187      _format: function( value ) {
15188          if ( value === "" ) {
15189              return "";
15190          }
15191          return window.Globalize && this.options.numberFormat ?
15192              Globalize.format( value, this.options.numberFormat, this.options.culture ) :
15193              value;
15194      },
15195  
15196      _refresh: function() {
15197          this.element.attr({
15198              "aria-valuemin": this.options.min,
15199              "aria-valuemax": this.options.max,
15200              // TODO: what should we do with values that can't be parsed?
15201              "aria-valuenow": this._parse( this.element.val() )
15202          });
15203      },
15204  
15205      isValid: function() {
15206          var value = this.value();
15207  
15208          // null is invalid
15209          if ( value === null ) {
15210              return false;
15211          }
15212  
15213          // if value gets adjusted, it's invalid
15214          return value === this._adjustValue( value );
15215      },
15216  
15217      // update the value without triggering change
15218      _value: function( value, allowAny ) {
15219          var parsed;
15220          if ( value !== "" ) {
15221              parsed = this._parse( value );
15222              if ( parsed !== null ) {
15223                  if ( !allowAny ) {
15224                      parsed = this._adjustValue( parsed );
15225                  }
15226                  value = this._format( parsed );
15227              }
15228          }
15229          this.element.val( value );
15230          this._refresh();
15231      },
15232  
15233      _destroy: function() {
15234          this.element
15235              .removeClass( "ui-spinner-input" )
15236              .prop( "disabled", false )
15237              .removeAttr( "autocomplete" )
15238              .removeAttr( "role" )
15239              .removeAttr( "aria-valuemin" )
15240              .removeAttr( "aria-valuemax" )
15241              .removeAttr( "aria-valuenow" );
15242          this.uiSpinner.replaceWith( this.element );
15243      },
15244  
15245      stepUp: spinner_modifier(function( steps ) {
15246          this._stepUp( steps );
15247      }),
15248      _stepUp: function( steps ) {
15249          if ( this._start() ) {
15250              this._spin( (steps || 1) * this.options.step );
15251              this._stop();
15252          }
15253      },
15254  
15255      stepDown: spinner_modifier(function( steps ) {
15256          this._stepDown( steps );
15257      }),
15258      _stepDown: function( steps ) {
15259          if ( this._start() ) {
15260              this._spin( (steps || 1) * -this.options.step );
15261              this._stop();
15262          }
15263      },
15264  
15265      pageUp: spinner_modifier(function( pages ) {
15266          this._stepUp( (pages || 1) * this.options.page );
15267      }),
15268  
15269      pageDown: spinner_modifier(function( pages ) {
15270          this._stepDown( (pages || 1) * this.options.page );
15271      }),
15272  
15273      value: function( newVal ) {
15274          if ( !arguments.length ) {
15275              return this._parse( this.element.val() );
15276          }
15277          spinner_modifier( this._value ).call( this, newVal );
15278      },
15279  
15280      widget: function() {
15281          return this.uiSpinner;
15282      }
15283  });
15284  
15285  
15286  /*!
15287   * jQuery UI Tabs 1.11.4
15288   * http://jqueryui.com
15289   *
15290   * Copyright jQuery Foundation and other contributors
15291   * Released under the MIT license.
15292   * http://jquery.org/license
15293   *
15294   * http://api.jqueryui.com/tabs/
15295   */
15296  
15297  
15298  var tabs = $.widget( "ui.tabs", {
15299      version: "1.11.4",
15300      delay: 300,
15301      options: {
15302          active: null,
15303          collapsible: false,
15304          event: "click",
15305          heightStyle: "content",
15306          hide: null,
15307          show: null,
15308  
15309          // callbacks
15310          activate: null,
15311          beforeActivate: null,
15312          beforeLoad: null,
15313          load: null
15314      },
15315  
15316      _isLocal: (function() {
15317          var rhash = /#.*$/;
15318  
15319          return function( anchor ) {
15320              var anchorUrl, locationUrl;
15321  
15322              // support: IE7
15323              // IE7 doesn't normalize the href property when set via script (#9317)
15324              anchor = anchor.cloneNode( false );
15325  
15326              anchorUrl = anchor.href.replace( rhash, "" );
15327              locationUrl = location.href.replace( rhash, "" );
15328  
15329              // decoding may throw an error if the URL isn't UTF-8 (#9518)
15330              try {
15331                  anchorUrl = decodeURIComponent( anchorUrl );
15332              } catch ( error ) {}
15333              try {
15334                  locationUrl = decodeURIComponent( locationUrl );
15335              } catch ( error ) {}
15336  
15337              return anchor.hash.length > 1 && anchorUrl === locationUrl;
15338          };
15339      })(),
15340  
15341      _create: function() {
15342          var that = this,
15343              options = this.options;
15344  
15345          this.running = false;
15346  
15347          this.element
15348              .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
15349              .toggleClass( "ui-tabs-collapsible", options.collapsible );
15350  
15351          this._processTabs();
15352          options.active = this._initialActive();
15353  
15354          // Take disabling tabs via class attribute from HTML
15355          // into account and update option properly.
15356          if ( $.isArray( options.disabled ) ) {
15357              options.disabled = $.unique( options.disabled.concat(
15358                  $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
15359                      return that.tabs.index( li );
15360                  })
15361              ) ).sort();
15362          }
15363  
15364          // check for length avoids error when initializing empty list
15365          if ( this.options.active !== false && this.anchors.length ) {
15366              this.active = this._findActive( options.active );
15367          } else {
15368              this.active = $();
15369          }
15370  
15371          this._refresh();
15372  
15373          if ( this.active.length ) {
15374              this.load( options.active );
15375          }
15376      },
15377  
15378      _initialActive: function() {
15379          var active = this.options.active,
15380              collapsible = this.options.collapsible,
15381              locationHash = location.hash.substring( 1 );
15382  
15383          if ( active === null ) {
15384              // check the fragment identifier in the URL
15385              if ( locationHash ) {
15386                  this.tabs.each(function( i, tab ) {
15387                      if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
15388                          active = i;
15389                          return false;
15390                      }
15391                  });
15392              }
15393  
15394              // check for a tab marked active via a class
15395              if ( active === null ) {
15396                  active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
15397              }
15398  
15399              // no active tab, set to false
15400              if ( active === null || active === -1 ) {
15401                  active = this.tabs.length ? 0 : false;
15402              }
15403          }
15404  
15405          // handle numbers: negative, out of range
15406          if ( active !== false ) {
15407              active = this.tabs.index( this.tabs.eq( active ) );
15408              if ( active === -1 ) {
15409                  active = collapsible ? false : 0;
15410              }
15411          }
15412  
15413          // don't allow collapsible: false and active: false
15414          if ( !collapsible && active === false && this.anchors.length ) {
15415              active = 0;
15416          }
15417  
15418          return active;
15419      },
15420  
15421      _getCreateEventData: function() {
15422          return {
15423              tab: this.active,
15424              panel: !this.active.length ? $() : this._getPanelForTab( this.active )
15425          };
15426      },
15427  
15428      _tabKeydown: function( event ) {
15429          var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
15430              selectedIndex = this.tabs.index( focusedTab ),
15431              goingForward = true;
15432  
15433          if ( this._handlePageNav( event ) ) {
15434              return;
15435          }
15436  
15437          switch ( event.keyCode ) {
15438              case $.ui.keyCode.RIGHT:
15439              case $.ui.keyCode.DOWN:
15440                  selectedIndex++;
15441                  break;
15442              case $.ui.keyCode.UP:
15443              case $.ui.keyCode.LEFT:
15444                  goingForward = false;
15445                  selectedIndex--;
15446                  break;
15447              case $.ui.keyCode.END:
15448                  selectedIndex = this.anchors.length - 1;
15449                  break;
15450              case $.ui.keyCode.HOME:
15451                  selectedIndex = 0;
15452                  break;
15453              case $.ui.keyCode.SPACE:
15454                  // Activate only, no collapsing
15455                  event.preventDefault();
15456                  clearTimeout( this.activating );
15457                  this._activate( selectedIndex );
15458                  return;
15459              case $.ui.keyCode.ENTER:
15460                  // Toggle (cancel delayed activation, allow collapsing)
15461                  event.preventDefault();
15462                  clearTimeout( this.activating );
15463                  // Determine if we should collapse or activate
15464                  this._activate( selectedIndex === this.options.active ? false : selectedIndex );
15465                  return;
15466              default:
15467                  return;
15468          }
15469  
15470          // Focus the appropriate tab, based on which key was pressed
15471          event.preventDefault();
15472          clearTimeout( this.activating );
15473          selectedIndex = this._focusNextTab( selectedIndex, goingForward );
15474  
15475          // Navigating with control/command key will prevent automatic activation
15476          if ( !event.ctrlKey && !event.metaKey ) {
15477  
15478              // Update aria-selected immediately so that AT think the tab is already selected.
15479              // Otherwise AT may confuse the user by stating that they need to activate the tab,
15480              // but the tab will already be activated by the time the announcement finishes.
15481              focusedTab.attr( "aria-selected", "false" );
15482              this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
15483  
15484              this.activating = this._delay(function() {
15485                  this.option( "active", selectedIndex );
15486              }, this.delay );
15487          }
15488      },
15489  
15490      _panelKeydown: function( event ) {
15491          if ( this._handlePageNav( event ) ) {
15492              return;
15493          }
15494  
15495          // Ctrl+up moves focus to the current tab
15496          if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
15497              event.preventDefault();
15498              this.active.focus();
15499          }
15500      },
15501  
15502      // Alt+page up/down moves focus to the previous/next tab (and activates)
15503      _handlePageNav: function( event ) {
15504          if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
15505              this._activate( this._focusNextTab( this.options.active - 1, false ) );
15506              return true;
15507          }
15508          if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
15509              this._activate( this._focusNextTab( this.options.active + 1, true ) );
15510              return true;
15511          }
15512      },
15513  
15514      _findNextTab: function( index, goingForward ) {
15515          var lastTabIndex = this.tabs.length - 1;
15516  
15517  		function constrain() {
15518              if ( index > lastTabIndex ) {
15519                  index = 0;
15520              }
15521              if ( index < 0 ) {
15522                  index = lastTabIndex;
15523              }
15524              return index;
15525          }
15526  
15527          while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
15528              index = goingForward ? index + 1 : index - 1;
15529          }
15530  
15531          return index;
15532      },
15533  
15534      _focusNextTab: function( index, goingForward ) {
15535          index = this._findNextTab( index, goingForward );
15536          this.tabs.eq( index ).focus();
15537          return index;
15538      },
15539  
15540      _setOption: function( key, value ) {
15541          if ( key === "active" ) {
15542              // _activate() will handle invalid values and update this.options
15543              this._activate( value );
15544              return;
15545          }
15546  
15547          if ( key === "disabled" ) {
15548              // don't use the widget factory's disabled handling
15549              this._setupDisabled( value );
15550              return;
15551          }
15552  
15553          this._super( key, value);
15554  
15555          if ( key === "collapsible" ) {
15556              this.element.toggleClass( "ui-tabs-collapsible", value );
15557              // Setting collapsible: false while collapsed; open first panel
15558              if ( !value && this.options.active === false ) {
15559                  this._activate( 0 );
15560              }
15561          }
15562  
15563          if ( key === "event" ) {
15564              this._setupEvents( value );
15565          }
15566  
15567          if ( key === "heightStyle" ) {
15568              this._setupHeightStyle( value );
15569          }
15570      },
15571  
15572      _sanitizeSelector: function( hash ) {
15573          return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
15574      },
15575  
15576      refresh: function() {
15577          var options = this.options,
15578              lis = this.tablist.children( ":has(a[href])" );
15579  
15580          // get disabled tabs from class attribute from HTML
15581          // this will get converted to a boolean if needed in _refresh()
15582          options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
15583              return lis.index( tab );
15584          });
15585  
15586          this._processTabs();
15587  
15588          // was collapsed or no tabs
15589          if ( options.active === false || !this.anchors.length ) {
15590              options.active = false;
15591              this.active = $();
15592          // was active, but active tab is gone
15593          } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
15594              // all remaining tabs are disabled
15595              if ( this.tabs.length === options.disabled.length ) {
15596                  options.active = false;
15597                  this.active = $();
15598              // activate previous tab
15599              } else {
15600                  this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
15601              }
15602          // was active, active tab still exists
15603          } else {
15604              // make sure active index is correct
15605              options.active = this.tabs.index( this.active );
15606          }
15607  
15608          this._refresh();
15609      },
15610  
15611      _refresh: function() {
15612          this._setupDisabled( this.options.disabled );
15613          this._setupEvents( this.options.event );
15614          this._setupHeightStyle( this.options.heightStyle );
15615  
15616          this.tabs.not( this.active ).attr({
15617              "aria-selected": "false",
15618              "aria-expanded": "false",
15619              tabIndex: -1
15620          });
15621          this.panels.not( this._getPanelForTab( this.active ) )
15622              .hide()
15623              .attr({
15624                  "aria-hidden": "true"
15625              });
15626  
15627          // Make sure one tab is in the tab order
15628          if ( !this.active.length ) {
15629              this.tabs.eq( 0 ).attr( "tabIndex", 0 );
15630          } else {
15631              this.active
15632                  .addClass( "ui-tabs-active ui-state-active" )
15633                  .attr({
15634                      "aria-selected": "true",
15635                      "aria-expanded": "true",
15636                      tabIndex: 0
15637                  });
15638              this._getPanelForTab( this.active )
15639                  .show()
15640                  .attr({
15641                      "aria-hidden": "false"
15642                  });
15643          }
15644      },
15645  
15646      _processTabs: function() {
15647          var that = this,
15648              prevTabs = this.tabs,
15649              prevAnchors = this.anchors,
15650              prevPanels = this.panels;
15651  
15652          this.tablist = this._getList()
15653              .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
15654              .attr( "role", "tablist" )
15655  
15656              // Prevent users from focusing disabled tabs via click
15657              .delegate( "> li", "mousedown" + this.eventNamespace, function( event ) {
15658                  if ( $( this ).is( ".ui-state-disabled" ) ) {
15659                      event.preventDefault();
15660                  }
15661              })
15662  
15663              // support: IE <9
15664              // Preventing the default action in mousedown doesn't prevent IE
15665              // from focusing the element, so if the anchor gets focused, blur.
15666              // We don't have to worry about focusing the previously focused
15667              // element since clicking on a non-focusable element should focus
15668              // the body anyway.
15669              .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
15670                  if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
15671                      this.blur();
15672                  }
15673              });
15674  
15675          this.tabs = this.tablist.find( "> li:has(a[href])" )
15676              .addClass( "ui-state-default ui-corner-top" )
15677              .attr({
15678                  role: "tab",
15679                  tabIndex: -1
15680              });
15681  
15682          this.anchors = this.tabs.map(function() {
15683                  return $( "a", this )[ 0 ];
15684              })
15685              .addClass( "ui-tabs-anchor" )
15686              .attr({
15687                  role: "presentation",
15688                  tabIndex: -1
15689              });
15690  
15691          this.panels = $();
15692  
15693          this.anchors.each(function( i, anchor ) {
15694              var selector, panel, panelId,
15695                  anchorId = $( anchor ).uniqueId().attr( "id" ),
15696                  tab = $( anchor ).closest( "li" ),
15697                  originalAriaControls = tab.attr( "aria-controls" );
15698  
15699              // inline tab
15700              if ( that._isLocal( anchor ) ) {
15701                  selector = anchor.hash;
15702                  panelId = selector.substring( 1 );
15703                  panel = that.element.find( that._sanitizeSelector( selector ) );
15704              // remote tab
15705              } else {
15706                  // If the tab doesn't already have aria-controls,
15707                  // generate an id by using a throw-away element
15708                  panelId = tab.attr( "aria-controls" ) || $( {} ).uniqueId()[ 0 ].id;
15709                  selector = "#" + panelId;
15710                  panel = that.element.find( selector );
15711                  if ( !panel.length ) {
15712                      panel = that._createPanel( panelId );
15713                      panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
15714                  }
15715                  panel.attr( "aria-live", "polite" );
15716              }
15717  
15718              if ( panel.length) {
15719                  that.panels = that.panels.add( panel );
15720              }
15721              if ( originalAriaControls ) {
15722                  tab.data( "ui-tabs-aria-controls", originalAriaControls );
15723              }
15724              tab.attr({
15725                  "aria-controls": panelId,
15726                  "aria-labelledby": anchorId
15727              });
15728              panel.attr( "aria-labelledby", anchorId );
15729          });
15730  
15731          this.panels
15732              .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
15733              .attr( "role", "tabpanel" );
15734  
15735          // Avoid memory leaks (#10056)
15736          if ( prevTabs ) {
15737              this._off( prevTabs.not( this.tabs ) );
15738              this._off( prevAnchors.not( this.anchors ) );
15739              this._off( prevPanels.not( this.panels ) );
15740          }
15741      },
15742  
15743      // allow overriding how to find the list for rare usage scenarios (#7715)
15744      _getList: function() {
15745          return this.tablist || this.element.find( "ol,ul" ).eq( 0 );
15746      },
15747  
15748      _createPanel: function( id ) {
15749          return $( "<div>" )
15750              .attr( "id", id )
15751              .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
15752              .data( "ui-tabs-destroy", true );
15753      },
15754  
15755      _setupDisabled: function( disabled ) {
15756          if ( $.isArray( disabled ) ) {
15757              if ( !disabled.length ) {
15758                  disabled = false;
15759              } else if ( disabled.length === this.anchors.length ) {
15760                  disabled = true;
15761              }
15762          }
15763  
15764          // disable tabs
15765          for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
15766              if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
15767                  $( li )
15768                      .addClass( "ui-state-disabled" )
15769                      .attr( "aria-disabled", "true" );
15770              } else {
15771                  $( li )
15772                      .removeClass( "ui-state-disabled" )
15773                      .removeAttr( "aria-disabled" );
15774              }
15775          }
15776  
15777          this.options.disabled = disabled;
15778      },
15779  
15780      _setupEvents: function( event ) {
15781          var events = {};
15782          if ( event ) {
15783              $.each( event.split(" "), function( index, eventName ) {
15784                  events[ eventName ] = "_eventHandler";
15785              });
15786          }
15787  
15788          this._off( this.anchors.add( this.tabs ).add( this.panels ) );
15789          // Always prevent the default action, even when disabled
15790          this._on( true, this.anchors, {
15791              click: function( event ) {
15792                  event.preventDefault();
15793              }
15794          });
15795          this._on( this.anchors, events );
15796          this._on( this.tabs, { keydown: "_tabKeydown" } );
15797          this._on( this.panels, { keydown: "_panelKeydown" } );
15798  
15799          this._focusable( this.tabs );
15800          this._hoverable( this.tabs );
15801      },
15802  
15803      _setupHeightStyle: function( heightStyle ) {
15804          var maxHeight,
15805              parent = this.element.parent();
15806  
15807          if ( heightStyle === "fill" ) {
15808              maxHeight = parent.height();
15809              maxHeight -= this.element.outerHeight() - this.element.height();
15810  
15811              this.element.siblings( ":visible" ).each(function() {
15812                  var elem = $( this ),
15813                      position = elem.css( "position" );
15814  
15815                  if ( position === "absolute" || position === "fixed" ) {
15816                      return;
15817                  }
15818                  maxHeight -= elem.outerHeight( true );
15819              });
15820  
15821              this.element.children().not( this.panels ).each(function() {
15822                  maxHeight -= $( this ).outerHeight( true );
15823              });
15824  
15825              this.panels.each(function() {
15826                  $( this ).height( Math.max( 0, maxHeight -
15827                      $( this ).innerHeight() + $( this ).height() ) );
15828              })
15829              .css( "overflow", "auto" );
15830          } else if ( heightStyle === "auto" ) {
15831              maxHeight = 0;
15832              this.panels.each(function() {
15833                  maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
15834              }).height( maxHeight );
15835          }
15836      },
15837  
15838      _eventHandler: function( event ) {
15839          var options = this.options,
15840              active = this.active,
15841              anchor = $( event.currentTarget ),
15842              tab = anchor.closest( "li" ),
15843              clickedIsActive = tab[ 0 ] === active[ 0 ],
15844              collapsing = clickedIsActive && options.collapsible,
15845              toShow = collapsing ? $() : this._getPanelForTab( tab ),
15846              toHide = !active.length ? $() : this._getPanelForTab( active ),
15847              eventData = {
15848                  oldTab: active,
15849                  oldPanel: toHide,
15850                  newTab: collapsing ? $() : tab,
15851                  newPanel: toShow
15852              };
15853  
15854          event.preventDefault();
15855  
15856          if ( tab.hasClass( "ui-state-disabled" ) ||
15857                  // tab is already loading
15858                  tab.hasClass( "ui-tabs-loading" ) ||
15859                  // can't switch durning an animation
15860                  this.running ||
15861                  // click on active header, but not collapsible
15862                  ( clickedIsActive && !options.collapsible ) ||
15863                  // allow canceling activation
15864                  ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
15865              return;
15866          }
15867  
15868          options.active = collapsing ? false : this.tabs.index( tab );
15869  
15870          this.active = clickedIsActive ? $() : tab;
15871          if ( this.xhr ) {
15872              this.xhr.abort();
15873          }
15874  
15875          if ( !toHide.length && !toShow.length ) {
15876              $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
15877          }
15878  
15879          if ( toShow.length ) {
15880              this.load( this.tabs.index( tab ), event );
15881          }
15882          this._toggle( event, eventData );
15883      },
15884  
15885      // handles show/hide for selecting tabs
15886      _toggle: function( event, eventData ) {
15887          var that = this,
15888              toShow = eventData.newPanel,
15889              toHide = eventData.oldPanel;
15890  
15891          this.running = true;
15892  
15893  		function complete() {
15894              that.running = false;
15895              that._trigger( "activate", event, eventData );
15896          }
15897  
15898  		function show() {
15899              eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
15900  
15901              if ( toShow.length && that.options.show ) {
15902                  that._show( toShow, that.options.show, complete );
15903              } else {
15904                  toShow.show();
15905                  complete();
15906              }
15907          }
15908  
15909          // start out by hiding, then showing, then completing
15910          if ( toHide.length && this.options.hide ) {
15911              this._hide( toHide, this.options.hide, function() {
15912                  eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
15913                  show();
15914              });
15915          } else {
15916              eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
15917              toHide.hide();
15918              show();
15919          }
15920  
15921          toHide.attr( "aria-hidden", "true" );
15922          eventData.oldTab.attr({
15923              "aria-selected": "false",
15924              "aria-expanded": "false"
15925          });
15926          // If we're switching tabs, remove the old tab from the tab order.
15927          // If we're opening from collapsed state, remove the previous tab from the tab order.
15928          // If we're collapsing, then keep the collapsing tab in the tab order.
15929          if ( toShow.length && toHide.length ) {
15930              eventData.oldTab.attr( "tabIndex", -1 );
15931          } else if ( toShow.length ) {
15932              this.tabs.filter(function() {
15933                  return $( this ).attr( "tabIndex" ) === 0;
15934              })
15935              .attr( "tabIndex", -1 );
15936          }
15937  
15938          toShow.attr( "aria-hidden", "false" );
15939          eventData.newTab.attr({
15940              "aria-selected": "true",
15941              "aria-expanded": "true",
15942              tabIndex: 0
15943          });
15944      },
15945  
15946      _activate: function( index ) {
15947          var anchor,
15948              active = this._findActive( index );
15949  
15950          // trying to activate the already active panel
15951          if ( active[ 0 ] === this.active[ 0 ] ) {
15952              return;
15953          }
15954  
15955          // trying to collapse, simulate a click on the current active header
15956          if ( !active.length ) {
15957              active = this.active;
15958          }
15959  
15960          anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
15961          this._eventHandler({
15962              target: anchor,
15963              currentTarget: anchor,
15964              preventDefault: $.noop
15965          });
15966      },
15967  
15968      _findActive: function( index ) {
15969          return index === false ? $() : this.tabs.eq( index );
15970      },
15971  
15972      _getIndex: function( index ) {
15973          // meta-function to give users option to provide a href string instead of a numerical index.
15974          if ( typeof index === "string" ) {
15975              index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
15976          }
15977  
15978          return index;
15979      },
15980  
15981      _destroy: function() {
15982          if ( this.xhr ) {
15983              this.xhr.abort();
15984          }
15985  
15986          this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
15987  
15988          this.tablist
15989              .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
15990              .removeAttr( "role" );
15991  
15992          this.anchors
15993              .removeClass( "ui-tabs-anchor" )
15994              .removeAttr( "role" )
15995              .removeAttr( "tabIndex" )
15996              .removeUniqueId();
15997  
15998          this.tablist.unbind( this.eventNamespace );
15999  
16000          this.tabs.add( this.panels ).each(function() {
16001              if ( $.data( this, "ui-tabs-destroy" ) ) {
16002                  $( this ).remove();
16003              } else {
16004                  $( this )
16005                      .removeClass( "ui-state-default ui-state-active ui-state-disabled " +
16006                          "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
16007                      .removeAttr( "tabIndex" )
16008                      .removeAttr( "aria-live" )
16009                      .removeAttr( "aria-busy" )
16010                      .removeAttr( "aria-selected" )
16011                      .removeAttr( "aria-labelledby" )
16012                      .removeAttr( "aria-hidden" )
16013                      .removeAttr( "aria-expanded" )
16014                      .removeAttr( "role" );
16015              }
16016          });
16017  
16018          this.tabs.each(function() {
16019              var li = $( this ),
16020                  prev = li.data( "ui-tabs-aria-controls" );
16021              if ( prev ) {
16022                  li
16023                      .attr( "aria-controls", prev )
16024                      .removeData( "ui-tabs-aria-controls" );
16025              } else {
16026                  li.removeAttr( "aria-controls" );
16027              }
16028          });
16029  
16030          this.panels.show();
16031  
16032          if ( this.options.heightStyle !== "content" ) {
16033              this.panels.css( "height", "" );
16034          }
16035      },
16036  
16037      enable: function( index ) {
16038          var disabled = this.options.disabled;
16039          if ( disabled === false ) {
16040              return;
16041          }
16042  
16043          if ( index === undefined ) {
16044              disabled = false;
16045          } else {
16046              index = this._getIndex( index );
16047              if ( $.isArray( disabled ) ) {
16048                  disabled = $.map( disabled, function( num ) {
16049                      return num !== index ? num : null;
16050                  });
16051              } else {
16052                  disabled = $.map( this.tabs, function( li, num ) {
16053                      return num !== index ? num : null;
16054                  });
16055              }
16056          }
16057          this._setupDisabled( disabled );
16058      },
16059  
16060      disable: function( index ) {
16061          var disabled = this.options.disabled;
16062          if ( disabled === true ) {
16063              return;
16064          }
16065  
16066          if ( index === undefined ) {
16067              disabled = true;
16068          } else {
16069              index = this._getIndex( index );
16070              if ( $.inArray( index, disabled ) !== -1 ) {
16071                  return;
16072              }
16073              if ( $.isArray( disabled ) ) {
16074                  disabled = $.merge( [ index ], disabled ).sort();
16075              } else {
16076                  disabled = [ index ];
16077              }
16078          }
16079          this._setupDisabled( disabled );
16080      },
16081  
16082      load: function( index, event ) {
16083          index = this._getIndex( index );
16084          var that = this,
16085              tab = this.tabs.eq( index ),
16086              anchor = tab.find( ".ui-tabs-anchor" ),
16087              panel = this._getPanelForTab( tab ),
16088              eventData = {
16089                  tab: tab,
16090                  panel: panel
16091              },
16092              complete = function( jqXHR, status ) {
16093                  if ( status === "abort" ) {
16094                      that.panels.stop( false, true );
16095                  }
16096  
16097                  tab.removeClass( "ui-tabs-loading" );
16098                  panel.removeAttr( "aria-busy" );
16099  
16100                  if ( jqXHR === that.xhr ) {
16101                      delete that.xhr;
16102                  }
16103              };
16104  
16105          // not remote
16106          if ( this._isLocal( anchor[ 0 ] ) ) {
16107              return;
16108          }
16109  
16110          this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
16111  
16112          // support: jQuery <1.8
16113          // jQuery <1.8 returns false if the request is canceled in beforeSend,
16114          // but as of 1.8, $.ajax() always returns a jqXHR object.
16115          if ( this.xhr && this.xhr.statusText !== "canceled" ) {
16116              tab.addClass( "ui-tabs-loading" );
16117              panel.attr( "aria-busy", "true" );
16118  
16119              this.xhr
16120                  .done(function( response, status, jqXHR ) {
16121                      // support: jQuery <1.8
16122                      // http://bugs.jquery.com/ticket/11778
16123                      setTimeout(function() {
16124                          panel.html( response );
16125                          that._trigger( "load", event, eventData );
16126  
16127                          complete( jqXHR, status );
16128                      }, 1 );
16129                  })
16130                  .fail(function( jqXHR, status ) {
16131                      // support: jQuery <1.8
16132                      // http://bugs.jquery.com/ticket/11778
16133                      setTimeout(function() {
16134                          complete( jqXHR, status );
16135                      }, 1 );
16136                  });
16137          }
16138      },
16139  
16140      _ajaxSettings: function( anchor, event, eventData ) {
16141          var that = this;
16142          return {
16143              url: anchor.attr( "href" ),
16144              beforeSend: function( jqXHR, settings ) {
16145                  return that._trigger( "beforeLoad", event,
16146                      $.extend( { jqXHR: jqXHR, ajaxSettings: settings }, eventData ) );
16147              }
16148          };
16149      },
16150  
16151      _getPanelForTab: function( tab ) {
16152          var id = $( tab ).attr( "aria-controls" );
16153          return this.element.find( this._sanitizeSelector( "#" + id ) );
16154      }
16155  });
16156  
16157  
16158  /*!
16159   * jQuery UI Tooltip 1.11.4
16160   * http://jqueryui.com
16161   *
16162   * Copyright jQuery Foundation and other contributors
16163   * Released under the MIT license.
16164   * http://jquery.org/license
16165   *
16166   * http://api.jqueryui.com/tooltip/
16167   */
16168  
16169  
16170  var tooltip = $.widget( "ui.tooltip", {
16171      version: "1.11.4",
16172      options: {
16173          content: function() {
16174              // support: IE<9, Opera in jQuery <1.7
16175              // .text() can't accept undefined, so coerce to a string
16176              var title = $( this ).attr( "title" ) || "";
16177              // Escape title, since we're going from an attribute to raw HTML
16178              return $( "<a>" ).text( title ).html();
16179          },
16180          hide: true,
16181          // Disabled elements have inconsistent behavior across browsers (#8661)
16182          items: "[title]:not([disabled])",
16183          position: {
16184              my: "left top+15",
16185              at: "left bottom",
16186              collision: "flipfit flip"
16187          },
16188          show: true,
16189          tooltipClass: null,
16190          track: false,
16191  
16192          // callbacks
16193          close: null,
16194          open: null
16195      },
16196  
16197      _addDescribedBy: function( elem, id ) {
16198          var describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ );
16199          describedby.push( id );
16200          elem
16201              .data( "ui-tooltip-id", id )
16202              .attr( "aria-describedby", $.trim( describedby.join( " " ) ) );
16203      },
16204  
16205      _removeDescribedBy: function( elem ) {
16206          var id = elem.data( "ui-tooltip-id" ),
16207              describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ ),
16208              index = $.inArray( id, describedby );
16209  
16210          if ( index !== -1 ) {
16211              describedby.splice( index, 1 );
16212          }
16213  
16214          elem.removeData( "ui-tooltip-id" );
16215          describedby = $.trim( describedby.join( " " ) );
16216          if ( describedby ) {
16217              elem.attr( "aria-describedby", describedby );
16218          } else {
16219              elem.removeAttr( "aria-describedby" );
16220          }
16221      },
16222  
16223      _create: function() {
16224          this._on({
16225              mouseover: "open",
16226              focusin: "open"
16227          });
16228  
16229          // IDs of generated tooltips, needed for destroy
16230          this.tooltips = {};
16231  
16232          // IDs of parent tooltips where we removed the title attribute
16233          this.parents = {};
16234  
16235          if ( this.options.disabled ) {
16236              this._disable();
16237          }
16238  
16239          // Append the aria-live region so tooltips announce correctly
16240          this.liveRegion = $( "<div>" )
16241              .attr({
16242                  role: "log",
16243                  "aria-live": "assertive",
16244                  "aria-relevant": "additions"
16245              })
16246              .addClass( "ui-helper-hidden-accessible" )
16247              .appendTo( this.document[ 0 ].body );
16248      },
16249  
16250      _setOption: function( key, value ) {
16251          var that = this;
16252  
16253          if ( key === "disabled" ) {
16254              this[ value ? "_disable" : "_enable" ]();
16255              this.options[ key ] = value;
16256              // disable element style changes
16257              return;
16258          }
16259  
16260          this._super( key, value );
16261  
16262          if ( key === "content" ) {
16263              $.each( this.tooltips, function( id, tooltipData ) {
16264                  that._updateContent( tooltipData.element );
16265              });
16266          }
16267      },
16268  
16269      _disable: function() {
16270          var that = this;
16271  
16272          // close open tooltips
16273          $.each( this.tooltips, function( id, tooltipData ) {
16274              var event = $.Event( "blur" );
16275              event.target = event.currentTarget = tooltipData.element[ 0 ];
16276              that.close( event, true );
16277          });
16278  
16279          // remove title attributes to prevent native tooltips
16280          this.element.find( this.options.items ).addBack().each(function() {
16281              var element = $( this );
16282              if ( element.is( "[title]" ) ) {
16283                  element
16284                      .data( "ui-tooltip-title", element.attr( "title" ) )
16285                      .removeAttr( "title" );
16286              }
16287          });
16288      },
16289  
16290      _enable: function() {
16291          // restore title attributes
16292          this.element.find( this.options.items ).addBack().each(function() {
16293              var element = $( this );
16294              if ( element.data( "ui-tooltip-title" ) ) {
16295                  element.attr( "title", element.data( "ui-tooltip-title" ) );
16296              }
16297          });
16298      },
16299  
16300      open: function( event ) {
16301          var that = this,
16302              target = $( event ? event.target : this.element )
16303                  // we need closest here due to mouseover bubbling,
16304                  // but always pointing at the same event target
16305                  .closest( this.options.items );
16306  
16307          // No element to show a tooltip for or the tooltip is already open
16308          if ( !target.length || target.data( "ui-tooltip-id" ) ) {
16309              return;
16310          }
16311  
16312          if ( target.attr( "title" ) ) {
16313              target.data( "ui-tooltip-title", target.attr( "title" ) );
16314          }
16315  
16316          target.data( "ui-tooltip-open", true );
16317  
16318          // kill parent tooltips, custom or native, for hover
16319          if ( event && event.type === "mouseover" ) {
16320              target.parents().each(function() {
16321                  var parent = $( this ),
16322                      blurEvent;
16323                  if ( parent.data( "ui-tooltip-open" ) ) {
16324                      blurEvent = $.Event( "blur" );
16325                      blurEvent.target = blurEvent.currentTarget = this;
16326                      that.close( blurEvent, true );
16327                  }
16328                  if ( parent.attr( "title" ) ) {
16329                      parent.uniqueId();
16330                      that.parents[ this.id ] = {
16331                          element: this,
16332                          title: parent.attr( "title" )
16333                      };
16334                      parent.attr( "title", "" );
16335                  }
16336              });
16337          }
16338  
16339          this._registerCloseHandlers( event, target );
16340          this._updateContent( target, event );
16341      },
16342  
16343      _updateContent: function( target, event ) {
16344          var content,
16345              contentOption = this.options.content,
16346              that = this,
16347              eventType = event ? event.type : null;
16348  
16349          if ( typeof contentOption === "string" ) {
16350              return this._open( event, target, contentOption );
16351          }
16352  
16353          content = contentOption.call( target[0], function( response ) {
16354  
16355              // IE may instantly serve a cached response for ajax requests
16356              // delay this call to _open so the other call to _open runs first
16357              that._delay(function() {
16358  
16359                  // Ignore async response if tooltip was closed already
16360                  if ( !target.data( "ui-tooltip-open" ) ) {
16361                      return;
16362                  }
16363  
16364                  // jQuery creates a special event for focusin when it doesn't
16365                  // exist natively. To improve performance, the native event
16366                  // object is reused and the type is changed. Therefore, we can't
16367                  // rely on the type being correct after the event finished
16368                  // bubbling, so we set it back to the previous value. (#8740)
16369                  if ( event ) {
16370                      event.type = eventType;
16371                  }
16372                  this._open( event, target, response );
16373              });
16374          });
16375          if ( content ) {
16376              this._open( event, target, content );
16377          }
16378      },
16379  
16380      _open: function( event, target, content ) {
16381          var tooltipData, tooltip, delayedShow, a11yContent,
16382              positionOption = $.extend( {}, this.options.position );
16383  
16384          if ( !content ) {
16385              return;
16386          }
16387  
16388          // Content can be updated multiple times. If the tooltip already
16389          // exists, then just update the content and bail.
16390          tooltipData = this._find( target );
16391          if ( tooltipData ) {
16392              tooltipData.tooltip.find( ".ui-tooltip-content" ).html( content );
16393              return;
16394          }
16395  
16396          // if we have a title, clear it to prevent the native tooltip
16397          // we have to check first to avoid defining a title if none exists
16398          // (we don't want to cause an element to start matching [title])
16399          //
16400          // We use removeAttr only for key events, to allow IE to export the correct
16401          // accessible attributes. For mouse events, set to empty string to avoid
16402          // native tooltip showing up (happens only when removing inside mouseover).
16403          if ( target.is( "[title]" ) ) {
16404              if ( event && event.type === "mouseover" ) {
16405                  target.attr( "title", "" );
16406              } else {
16407                  target.removeAttr( "title" );
16408              }
16409          }
16410  
16411          tooltipData = this._tooltip( target );
16412          tooltip = tooltipData.tooltip;
16413          this._addDescribedBy( target, tooltip.attr( "id" ) );
16414          tooltip.find( ".ui-tooltip-content" ).html( content );
16415  
16416          // Support: Voiceover on OS X, JAWS on IE <= 9
16417          // JAWS announces deletions even when aria-relevant="additions"
16418          // Voiceover will sometimes re-read the entire log region's contents from the beginning
16419          this.liveRegion.children().hide();
16420          if ( content.clone ) {
16421              a11yContent = content.clone();
16422              a11yContent.removeAttr( "id" ).find( "[id]" ).removeAttr( "id" );
16423          } else {
16424              a11yContent = content;
16425          }
16426          $( "<div>" ).html( a11yContent ).appendTo( this.liveRegion );
16427  
16428  		function position( event ) {
16429              positionOption.of = event;
16430              if ( tooltip.is( ":hidden" ) ) {
16431                  return;
16432              }
16433              tooltip.position( positionOption );
16434          }
16435          if ( this.options.track && event && /^mouse/.test( event.type ) ) {
16436              this._on( this.document, {
16437                  mousemove: position
16438              });
16439              // trigger once to override element-relative positioning
16440              position( event );
16441          } else {
16442              tooltip.position( $.extend({
16443                  of: target
16444              }, this.options.position ) );
16445          }
16446  
16447          tooltip.hide();
16448  
16449          this._show( tooltip, this.options.show );
16450          // Handle tracking tooltips that are shown with a delay (#8644). As soon
16451          // as the tooltip is visible, position the tooltip using the most recent
16452          // event.
16453          if ( this.options.show && this.options.show.delay ) {
16454              delayedShow = this.delayedShow = setInterval(function() {
16455                  if ( tooltip.is( ":visible" ) ) {
16456                      position( positionOption.of );
16457                      clearInterval( delayedShow );
16458                  }
16459              }, $.fx.interval );
16460          }
16461  
16462          this._trigger( "open", event, { tooltip: tooltip } );
16463      },
16464  
16465      _registerCloseHandlers: function( event, target ) {
16466          var events = {
16467              keyup: function( event ) {
16468                  if ( event.keyCode === $.ui.keyCode.ESCAPE ) {
16469                      var fakeEvent = $.Event(event);
16470                      fakeEvent.currentTarget = target[0];
16471                      this.close( fakeEvent, true );
16472                  }
16473              }
16474          };
16475  
16476          // Only bind remove handler for delegated targets. Non-delegated
16477          // tooltips will handle this in destroy.
16478          if ( target[ 0 ] !== this.element[ 0 ] ) {
16479              events.remove = function() {
16480                  this._removeTooltip( this._find( target ).tooltip );
16481              };
16482          }
16483  
16484          if ( !event || event.type === "mouseover" ) {
16485              events.mouseleave = "close";
16486          }
16487          if ( !event || event.type === "focusin" ) {
16488              events.focusout = "close";
16489          }
16490          this._on( true, target, events );
16491      },
16492  
16493      close: function( event ) {
16494          var tooltip,
16495              that = this,
16496              target = $( event ? event.currentTarget : this.element ),
16497              tooltipData = this._find( target );
16498  
16499          // The tooltip may already be closed
16500          if ( !tooltipData ) {
16501  
16502              // We set ui-tooltip-open immediately upon open (in open()), but only set the
16503              // additional data once there's actually content to show (in _open()). So even if the
16504              // tooltip doesn't have full data, we always remove ui-tooltip-open in case we're in
16505              // the period between open() and _open().
16506              target.removeData( "ui-tooltip-open" );
16507              return;
16508          }
16509  
16510          tooltip = tooltipData.tooltip;
16511  
16512          // disabling closes the tooltip, so we need to track when we're closing
16513          // to avoid an infinite loop in case the tooltip becomes disabled on close
16514          if ( tooltipData.closing ) {
16515              return;
16516          }
16517  
16518          // Clear the interval for delayed tracking tooltips
16519          clearInterval( this.delayedShow );
16520  
16521          // only set title if we had one before (see comment in _open())
16522          // If the title attribute has changed since open(), don't restore
16523          if ( target.data( "ui-tooltip-title" ) && !target.attr( "title" ) ) {
16524              target.attr( "title", target.data( "ui-tooltip-title" ) );
16525          }
16526  
16527          this._removeDescribedBy( target );
16528  
16529          tooltipData.hiding = true;
16530          tooltip.stop( true );
16531          this._hide( tooltip, this.options.hide, function() {
16532              that._removeTooltip( $( this ) );
16533          });
16534  
16535          target.removeData( "ui-tooltip-open" );
16536          this._off( target, "mouseleave focusout keyup" );
16537  
16538          // Remove 'remove' binding only on delegated targets
16539          if ( target[ 0 ] !== this.element[ 0 ] ) {
16540              this._off( target, "remove" );
16541          }
16542          this._off( this.document, "mousemove" );
16543  
16544          if ( event && event.type === "mouseleave" ) {
16545              $.each( this.parents, function( id, parent ) {
16546                  $( parent.element ).attr( "title", parent.title );
16547                  delete that.parents[ id ];
16548              });
16549          }
16550  
16551          tooltipData.closing = true;
16552          this._trigger( "close", event, { tooltip: tooltip } );
16553          if ( !tooltipData.hiding ) {
16554              tooltipData.closing = false;
16555          }
16556      },
16557  
16558      _tooltip: function( element ) {
16559          var tooltip = $( "<div>" )
16560                  .attr( "role", "tooltip" )
16561                  .addClass( "ui-tooltip ui-widget ui-corner-all ui-widget-content " +
16562                      ( this.options.tooltipClass || "" ) ),
16563              id = tooltip.uniqueId().attr( "id" );
16564  
16565          $( "<div>" )
16566              .addClass( "ui-tooltip-content" )
16567              .appendTo( tooltip );
16568  
16569          tooltip.appendTo( this.document[0].body );
16570  
16571          return this.tooltips[ id ] = {
16572              element: element,
16573              tooltip: tooltip
16574          };
16575      },
16576  
16577      _find: function( target ) {
16578          var id = target.data( "ui-tooltip-id" );
16579          return id ? this.tooltips[ id ] : null;
16580      },
16581  
16582      _removeTooltip: function( tooltip ) {
16583          tooltip.remove();
16584          delete this.tooltips[ tooltip.attr( "id" ) ];
16585      },
16586  
16587      _destroy: function() {
16588          var that = this;
16589  
16590          // close open tooltips
16591          $.each( this.tooltips, function( id, tooltipData ) {
16592              // Delegate to close method to handle common cleanup
16593              var event = $.Event( "blur" ),
16594                  element = tooltipData.element;
16595              event.target = event.currentTarget = element[ 0 ];
16596              that.close( event, true );
16597  
16598              // Remove immediately; destroying an open tooltip doesn't use the
16599              // hide animation
16600              $( "#" + id ).remove();
16601  
16602              // Restore the title
16603              if ( element.data( "ui-tooltip-title" ) ) {
16604                  // If the title attribute has changed since open(), don't restore
16605                  if ( !element.attr( "title" ) ) {
16606                      element.attr( "title", element.data( "ui-tooltip-title" ) );
16607                  }
16608                  element.removeData( "ui-tooltip-title" );
16609              }
16610          });
16611          this.liveRegion.remove();
16612      }
16613  });
16614  
16615  
16616  
16617  }));