luci2/htdocs/luci2/jquery-ui-1.10.3.js

   1 /*! jQuery UI - v1.10.3 - 2013-05-03
   2 * http://jqueryui.com
   3 * Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.sortable.js, jquery.ui.effect.js, jquery.ui.accordion.js, jquery.ui.autocomplete.js, jquery.ui.button.js, jquery.ui.datepicker.js, jquery.ui.dialog.js, jquery.ui.effect-blind.js, jquery.ui.effect-bounce.js, jquery.ui.effect-clip.js, jquery.ui.effect-drop.js, jquery.ui.effect-explode.js, jquery.ui.effect-fade.js, jquery.ui.effect-fold.js, jquery.ui.effect-highlight.js, jquery.ui.effect-pulsate.js, jquery.ui.effect-scale.js, jquery.ui.effect-shake.js, jquery.ui.effect-slide.js, jquery.ui.effect-transfer.js, jquery.ui.menu.js, jquery.ui.position.js, jquery.ui.progressbar.js, jquery.ui.slider.js, jquery.ui.spinner.js, jquery.ui.tabs.js, jquery.ui.tooltip.js
   4 * Copyright 2013 jQuery Foundation and other contributors; Licensed MIT */
   5 (function( $, undefined ) {
   6
   7 var uuid = 0,
   8         runiqueId = /^ui-id-\d+$/;
   9
  10 // $.ui might exist from components with no dependencies, e.g., $.ui.position
  11 $.ui = $.ui || {};
  12
  13 $.extend( $.ui, {
  14         version: "1.10.3",
  15
  16         keyCode: {
  17                 BACKSPACE: 8,
  18                 COMMA: 188,
  19                 DELETE: 46,
  20                 DOWN: 40,
  21                 END: 35,
  22                 ENTER: 13,
  23                 ESCAPE: 27,
  24                 HOME: 36,
  25                 LEFT: 37,
  26                 NUMPAD_ADD: 107,
  27                 NUMPAD_DECIMAL: 110,
  28                 NUMPAD_DIVIDE: 111,
  29                 NUMPAD_ENTER: 108,
  30                 NUMPAD_MULTIPLY: 106,
  31                 NUMPAD_SUBTRACT: 109,
  32                 PAGE_DOWN: 34,
  33                 PAGE_UP: 33,
  34                 PERIOD: 190,
  35                 RIGHT: 39,
  36                 SPACE: 32,
  37                 TAB: 9,
  38                 UP: 38
  39         }
  40 });
  41
  42 // plugins
  43 $.fn.extend({
  44         focus: (function( orig ) {
  45                 return function( delay, fn ) {
  46                         return typeof delay === "number" ?
  47                                 this.each(function() {
  48                                         var elem = this;
  49                                         setTimeout(function() {
  50                                                 $( elem ).focus();
  51                                                 if ( fn ) {
  52                                                         fn.call( elem );
  53                                                 }
  54                                         }, delay );
  55                                 }) :
  56                                 orig.apply( this, arguments );
  57                 };
  58         })( $.fn.focus ),
  59
  60         scrollParent: function() {
  61                 var scrollParent;
  62                 if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
  63                         scrollParent = this.parents().filter(function() {
  64                                 return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
  65                         }).eq(0);
  66                 } else {
  67                         scrollParent = this.parents().filter(function() {
  68                                 return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
  69                         }).eq(0);
  70                 }
  71
  72                 return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
  73         },
  74
  75         zIndex: function( zIndex ) {
  76                 if ( zIndex !== undefined ) {
  77                         return this.css( "zIndex", zIndex );
  78                 }
  79
  80                 if ( this.length ) {
  81                         var elem = $( this[ 0 ] ), position, value;
  82                         while ( elem.length && elem[ 0 ] !== document ) {
  83                                 // Ignore z-index if position is set to a value where z-index is ignored by the browser
  84                                 // This makes behavior of this function consistent across browsers
  85                                 // WebKit always returns auto if the element is positioned
  86                                 position = elem.css( "position" );
  87                                 if ( position === "absolute" || position === "relative" || position === "fixed" ) {
  88                                         // IE returns 0 when zIndex is not specified
  89                                         // other browsers return a string
  90                                         // we ignore the case of nested elements with an explicit value of 0
  91                                         // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
  92                                         value = parseInt( elem.css( "zIndex" ), 10 );
  93                                         if ( !isNaN( value ) && value !== 0 ) {
  94                                                 return value;
  95                                         }
  96                                 }
  97                                 elem = elem.parent();
  98                         }
  99                 }
 100
 101                 return 0;
 102         },
 103
 104         uniqueId: function() {
 105                 return this.each(function() {
 106                         if ( !this.id ) {
 107                                 this.id = "ui-id-" + (++uuid);
 108                         }
 109                 });
 110         },
 111
 112         removeUniqueId: function() {
 113                 return this.each(function() {
 114                         if ( runiqueId.test( this.id ) ) {
 115                                 $( this ).removeAttr( "id" );
 116                         }
 117                 });
 118         }
 119 });
 120
 121 // selectors
 122 function focusable( element, isTabIndexNotNaN ) {
 123         var map, mapName, img,
 124                 nodeName = element.nodeName.toLowerCase();
 125         if ( "area" === nodeName ) {
 126                 map = element.parentNode;
 127                 mapName = map.name;
 128                 if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
 129                         return false;
 130                 }
 131                 img = $( "img[usemap=#" + mapName + "]" )[0];
 132                 return !!img && visible( img );
 133         }
 134         return ( /input|select|textarea|button|object/.test( nodeName ) ?
 135                 !element.disabled :
 136                 "a" === nodeName ?
 137                         element.href || isTabIndexNotNaN :
 138                         isTabIndexNotNaN) &&
 139                 // the element and all of its ancestors must be visible
 140                 visible( element );
 141 }
 142
 143 function visible( element ) {
 144         return $.expr.filters.visible( element ) &&
 145                 !$( element ).parents().addBack().filter(function() {
 146                         return $.css( this, "visibility" ) === "hidden";
 147                 }).length;
 148 }
 149
 150 $.extend( $.expr[ ":" ], {
 151         data: $.expr.createPseudo ?
 152                 $.expr.createPseudo(function( dataName ) {
 153                         return function( elem ) {
 154                                 return !!$.data( elem, dataName );
 155                         };
 156                 }) :
 157                 // support: jQuery <1.8
 158                 function( elem, i, match ) {
 159                         return !!$.data( elem, match[ 3 ] );
 160                 },
 161
 162         focusable: function( element ) {
 163                 return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
 164         },
 165
 166         tabbable: function( element ) {
 167                 var tabIndex = $.attr( element, "tabindex" ),
 168                         isTabIndexNaN = isNaN( tabIndex );
 169                 return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
 170         }
 171 });
 172
 173 // support: jQuery <1.8
 174 if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
 175         $.each( [ "Width", "Height" ], function( i, name ) {
 176                 var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
 177                         type = name.toLowerCase(),
 178                         orig = {
 179                                 innerWidth: $.fn.innerWidth,
 180                                 innerHeight: $.fn.innerHeight,
 181                                 outerWidth: $.fn.outerWidth,
 182                                 outerHeight: $.fn.outerHeight
 183                         };
 184
 185                 function reduce( elem, size, border, margin ) {
 186                         $.each( side, function() {
 187                                 size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
 188                                 if ( border ) {
 189                                         size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
 190                                 }
 191                                 if ( margin ) {
 192                                         size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
 193                                 }
 194                         });
 195                         return size;
 196                 }
 197
 198                 $.fn[ "inner" + name ] = function( size ) {
 199                         if ( size === undefined ) {
 200                                 return orig[ "inner" + name ].call( this );
 201                         }
 202
 203                         return this.each(function() {
 204                                 $( this ).css( type, reduce( this, size ) + "px" );
 205                         });
 206                 };
 207
 208                 $.fn[ "outer" + name] = function( size, margin ) {
 209                         if ( typeof size !== "number" ) {
 210                                 return orig[ "outer" + name ].call( this, size );
 211                         }
 212
 213                         return this.each(function() {
 214                                 $( this).css( type, reduce( this, size, true, margin ) + "px" );
 215                         });
 216                 };
 217         });
 218 }
 219
 220 // support: jQuery <1.8
 221 if ( !$.fn.addBack ) {
 222         $.fn.addBack = function( selector ) {
 223                 return this.add( selector == null ?
 224                         this.prevObject : this.prevObject.filter( selector )
 225                 );
 226         };
 227 }
 228
 229 // support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
 230 if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
 231         $.fn.removeData = (function( removeData ) {
 232                 return function( key ) {
 233                         if ( arguments.length ) {
 234                                 return removeData.call( this, $.camelCase( key ) );
 235                         } else {
 236                                 return removeData.call( this );
 237                         }
 238                 };
 239         })( $.fn.removeData );
 240 }
 241
 242
 243
 244
 245
 246 // deprecated
 247 $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
 248
 249 $.support.selectstart = "onselectstart" in document.createElement( "div" );
 250 $.fn.extend({
 251         disableSelection: function() {
 252                 return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
 253                         ".ui-disableSelection", function( event ) {
 254                                 event.preventDefault();
 255                         });
 256         },
 257
 258         enableSelection: function() {
 259                 return this.unbind( ".ui-disableSelection" );
 260         }
 261 });
 262
 263 $.extend( $.ui, {
 264         // $.ui.plugin is deprecated. Use $.widget() extensions instead.
 265         plugin: {
 266                 add: function( module, option, set ) {
 267                         var i,
 268                                 proto = $.ui[ module ].prototype;
 269                         for ( i in set ) {
 270                                 proto.plugins[ i ] = proto.plugins[ i ] || [];
 271                                 proto.plugins[ i ].push( [ option, set[ i ] ] );
 272                         }
 273                 },
 274                 call: function( instance, name, args ) {
 275                         var i,
 276                                 set = instance.plugins[ name ];
 277                         if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
 278                                 return;
 279                         }
 280
 281                         for ( i = 0; i < set.length; i++ ) {
 282                                 if ( instance.options[ set[ i ][ 0 ] ] ) {
 283                                         set[ i ][ 1 ].apply( instance.element, args );
 284                                 }
 285                         }
 286                 }
 287         },
 288
 289         // only used by resizable
 290         hasScroll: function( el, a ) {
 291
 292                 //If overflow is hidden, the element might have extra content, but the user wants to hide it
 293                 if ( $( el ).css( "overflow" ) === "hidden") {
 294                         return false;
 295                 }
 296
 297                 var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
 298                         has = false;
 299
 300                 if ( el[ scroll ] > 0 ) {
 301                         return true;
 302                 }
 303
 304                 // TODO: determine which cases actually cause this to happen
 305                 // if the element doesn't have the scroll set, see if it's possible to
 306                 // set the scroll
 307                 el[ scroll ] = 1;
 308                 has = ( el[ scroll ] > 0 );
 309                 el[ scroll ] = 0;
 310                 return has;
 311         }
 312 });
 313
 314 })( jQuery );
 315
 316 (function( $, undefined ) {
 317
 318 var uuid = 0,
 319         slice = Array.prototype.slice,
 320         _cleanData = $.cleanData;
 321 $.cleanData = function( elems ) {
 322         for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
 323                 try {
 324                         $( elem ).triggerHandler( "remove" );
 325                 // http://bugs.jquery.com/ticket/8235
 326                 } catch( e ) {}
 327         }
 328         _cleanData( elems );
 329 };
 330
 331 $.widget = function( name, base, prototype ) {
 332         var fullName, existingConstructor, constructor, basePrototype,
 333                 // proxiedPrototype allows the provided prototype to remain unmodified
 334                 // so that it can be used as a mixin for multiple widgets (#8876)
 335                 proxiedPrototype = {},
 336                 namespace = name.split( "." )[ 0 ];
 337
 338         name = name.split( "." )[ 1 ];
 339         fullName = namespace + "-" + name;
 340
 341         if ( !prototype ) {
 342                 prototype = base;
 343                 base = $.Widget;
 344         }
 345
 346         // create selector for plugin
 347         $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
 348                 return !!$.data( elem, fullName );
 349         };
 350
 351         $[ namespace ] = $[ namespace ] || {};
 352         existingConstructor = $[ namespace ][ name ];
 353         constructor = $[ namespace ][ name ] = function( options, element ) {
 354                 // allow instantiation without "new" keyword
 355                 if ( !this._createWidget ) {
 356                         return new constructor( options, element );
 357                 }
 358
 359                 // allow instantiation without initializing for simple inheritance
 360                 // must use "new" keyword (the code above always passes args)
 361                 if ( arguments.length ) {
 362                         this._createWidget( options, element );
 363                 }
 364         };
 365         // extend with the existing constructor to carry over any static properties
 366         $.extend( constructor, existingConstructor, {
 367                 version: prototype.version,
 368                 // copy the object used to create the prototype in case we need to
 369                 // redefine the widget later
 370                 _proto: $.extend( {}, prototype ),
 371                 // track widgets that inherit from this widget in case this widget is
 372                 // redefined after a widget inherits from it
 373                 _childConstructors: []
 374         });
 375
 376         basePrototype = new base();
 377         // we need to make the options hash a property directly on the new instance
 378         // otherwise we'll modify the options hash on the prototype that we're
 379         // inheriting from
 380         basePrototype.options = $.widget.extend( {}, basePrototype.options );
 381         $.each( prototype, function( prop, value ) {
 382                 if ( !$.isFunction( value ) ) {
 383                         proxiedPrototype[ prop ] = value;
 384                         return;
 385                 }
 386                 proxiedPrototype[ prop ] = (function() {
 387                         var _super = function() {
 388                                         return base.prototype[ prop ].apply( this, arguments );
 389                                 },
 390                                 _superApply = function( args ) {
 391                                         return base.prototype[ prop ].apply( this, args );
 392                                 };
 393                         return function() {
 394                                 var __super = this._super,
 395                                         __superApply = this._superApply,
 396                                         returnValue;
 397
 398                                 this._super = _super;
 399                                 this._superApply = _superApply;
 400
 401                                 returnValue = value.apply( this, arguments );
 402
 403                                 this._super = __super;
 404                                 this._superApply = __superApply;
 405
 406                                 return returnValue;
 407                         };
 408                 })();
 409         });
 410         constructor.prototype = $.widget.extend( basePrototype, {
 411                 // TODO: remove support for widgetEventPrefix
 412                 // always use the name + a colon as the prefix, e.g., draggable:start
 413                 // don't prefix for widgets that aren't DOM-based
 414                 widgetEventPrefix: existingConstructor ? basePrototype.widgetEventPrefix : name
 415         }, proxiedPrototype, {
 416                 constructor: constructor,
 417                 namespace: namespace,
 418                 widgetName: name,
 419                 widgetFullName: fullName
 420         });
 421
 422         // If this widget is being redefined then we need to find all widgets that
 423         // are inheriting from it and redefine all of them so that they inherit from
 424         // the new version of this widget. We're essentially trying to replace one
 425         // level in the prototype chain.
 426         if ( existingConstructor ) {
 427                 $.each( existingConstructor._childConstructors, function( i, child ) {
 428                         var childPrototype = child.prototype;
 429
 430                         // redefine the child widget using the same prototype that was
 431                         // originally used, but inherit from the new version of the base
 432                         $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
 433                 });
 434                 // remove the list of existing child constructors from the old constructor
 435                 // so the old child constructors can be garbage collected
 436                 delete existingConstructor._childConstructors;
 437         } else {
 438                 base._childConstructors.push( constructor );
 439         }
 440
 441         $.widget.bridge( name, constructor );
 442 };
 443
 444 $.widget.extend = function( target ) {
 445         var input = slice.call( arguments, 1 ),
 446                 inputIndex = 0,
 447                 inputLength = input.length,
 448                 key,
 449                 value;
 450         for ( ; inputIndex < inputLength; inputIndex++ ) {
 451                 for ( key in input[ inputIndex ] ) {
 452                         value = input[ inputIndex ][ key ];
 453                         if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
 454                                 // Clone objects
 455                                 if ( $.isPlainObject( value ) ) {
 456                                         target[ key ] = $.isPlainObject( target[ key ] ) ?
 457                                                 $.widget.extend( {}, target[ key ], value ) :
 458                                                 // Don't extend strings, arrays, etc. with objects
 459                                                 $.widget.extend( {}, value );
 460                                 // Copy everything else by reference
 461                                 } else {
 462                                         target[ key ] = value;
 463                                 }
 464                         }
 465                 }
 466         }
 467         return target;
 468 };
 469
 470 $.widget.bridge = function( name, object ) {
 471         var fullName = object.prototype.widgetFullName || name;
 472         $.fn[ name ] = function( options ) {
 473                 var isMethodCall = typeof options === "string",
 474                         args = slice.call( arguments, 1 ),
 475                         returnValue = this;
 476
 477                 // allow multiple hashes to be passed on init
 478                 options = !isMethodCall && args.length ?
 479                         $.widget.extend.apply( null, [ options ].concat(args) ) :
 480                         options;
 481
 482                 if ( isMethodCall ) {
 483                         this.each(function() {
 484                                 var methodValue,
 485                                         instance = $.data( this, fullName );
 486                                 if ( !instance ) {
 487                                         return $.error( "cannot call methods on " + name + " prior to initialization; " +
 488                                                 "attempted to call method '" + options + "'" );
 489                                 }
 490                                 if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
 491                                         return $.error( "no such method '" + options + "' for " + name + " widget instance" );
 492                                 }
 493                                 methodValue = instance[ options ].apply( instance, args );
 494                                 if ( methodValue !== instance && methodValue !== undefined ) {
 495                                         returnValue = methodValue && methodValue.jquery ?
 496                                                 returnValue.pushStack( methodValue.get() ) :
 497                                                 methodValue;
 498                                         return false;
 499                                 }
 500                         });
 501                 } else {
 502                         this.each(function() {
 503                                 var instance = $.data( this, fullName );
 504                                 if ( instance ) {
 505                                         instance.option( options || {} )._init();
 506                                 } else {
 507                                         $.data( this, fullName, new object( options, this ) );
 508                                 }
 509                         });
 510                 }
 511
 512                 return returnValue;
 513         };
 514 };
 515
 516 $.Widget = function( /* options, element */ ) {};
 517 $.Widget._childConstructors = [];
 518
 519 $.Widget.prototype = {
 520         widgetName: "widget",
 521         widgetEventPrefix: "",
 522         defaultElement: "<div>",
 523         options: {
 524                 disabled: false,
 525
 526                 // callbacks
 527                 create: null
 528         },
 529         _createWidget: function( options, element ) {
 530                 element = $( element || this.defaultElement || this )[ 0 ];
 531                 this.element = $( element );
 532                 this.uuid = uuid++;
 533                 this.eventNamespace = "." + this.widgetName + this.uuid;
 534                 this.options = $.widget.extend( {},
 535                         this.options,
 536                         this._getCreateOptions(),
 537                         options );
 538
 539                 this.bindings = $();
 540                 this.hoverable = $();
 541                 this.focusable = $();
 542
 543                 if ( element !== this ) {
 544                         $.data( element, this.widgetFullName, this );
 545                         this._on( true, this.element, {
 546                                 remove: function( event ) {
 547                                         if ( event.target === element ) {
 548                                                 this.destroy();
 549                                         }
 550                                 }
 551                         });
 552                         this.document = $( element.style ?
 553                                 // element within the document
 554                                 element.ownerDocument :
 555                                 // element is window or document
 556                                 element.document || element );
 557                         this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
 558                 }
 559
 560                 this._create();
 561                 this._trigger( "create", null, this._getCreateEventData() );
 562                 this._init();
 563         },
 564         _getCreateOptions: $.noop,
 565         _getCreateEventData: $.noop,
 566         _create: $.noop,
 567         _init: $.noop,
 568
 569         destroy: function() {
 570                 this._destroy();
 571                 // we can probably remove the unbind calls in 2.0
 572                 // all event bindings should go through this._on()
 573                 this.element
 574                         .unbind( this.eventNamespace )
 575                         // 1.9 BC for #7810
 576                         // TODO remove dual storage
 577                         .removeData( this.widgetName )
 578                         .removeData( this.widgetFullName )
 579                         // support: jquery <1.6.3
 580                         // http://bugs.jquery.com/ticket/9413
 581                         .removeData( $.camelCase( this.widgetFullName ) );
 582                 this.widget()
 583                         .unbind( this.eventNamespace )
 584                         .removeAttr( "aria-disabled" )
 585                         .removeClass(
 586                                 this.widgetFullName + "-disabled " +
 587                                 "ui-state-disabled" );
 588
 589                 // clean up events and states
 590                 this.bindings.unbind( this.eventNamespace );
 591                 this.hoverable.removeClass( "ui-state-hover" );
 592                 this.focusable.removeClass( "ui-state-focus" );
 593         },
 594         _destroy: $.noop,
 595
 596         widget: function() {
 597                 return this.element;
 598         },
 599
 600         option: function( key, value ) {
 601                 var options = key,
 602                         parts,
 603                         curOption,
 604                         i;
 605
 606                 if ( arguments.length === 0 ) {
 607                         // don't return a reference to the internal hash
 608                         return $.widget.extend( {}, this.options );
 609                 }
 610
 611                 if ( typeof key === "string" ) {
 612                         // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
 613                         options = {};
 614                         parts = key.split( "." );
 615                         key = parts.shift();
 616                         if ( parts.length ) {
 617                                 curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
 618                                 for ( i = 0; i < parts.length - 1; i++ ) {
 619                                         curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
 620                                         curOption = curOption[ parts[ i ] ];
 621                                 }
 622                                 key = parts.pop();
 623                                 if ( value === undefined ) {
 624                                         return curOption[ key ] === undefined ? null : curOption[ key ];
 625                                 }
 626                                 curOption[ key ] = value;
 627                         } else {
 628                                 if ( value === undefined ) {
 629                                         return this.options[ key ] === undefined ? null : this.options[ key ];
 630                                 }
 631                                 options[ key ] = value;
 632                         }
 633                 }
 634
 635                 this._setOptions( options );
 636
 637                 return this;
 638         },
 639         _setOptions: function( options ) {
 640                 var key;
 641
 642                 for ( key in options ) {
 643                         this._setOption( key, options[ key ] );
 644                 }
 645
 646                 return this;
 647         },
 648         _setOption: function( key, value ) {
 649                 this.options[ key ] = value;
 650
 651                 if ( key === "disabled" ) {
 652                         this.widget()
 653                                 .toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
 654                                 .attr( "aria-disabled", value );
 655                         this.hoverable.removeClass( "ui-state-hover" );
 656                         this.focusable.removeClass( "ui-state-focus" );
 657                 }
 658
 659                 return this;
 660         },
 661
 662         enable: function() {
 663                 return this._setOption( "disabled", false );
 664         },
 665         disable: function() {
 666                 return this._setOption( "disabled", true );
 667         },
 668
 669         _on: function( suppressDisabledCheck, element, handlers ) {
 670                 var delegateElement,
 671                         instance = this;
 672
 673                 // no suppressDisabledCheck flag, shuffle arguments
 674                 if ( typeof suppressDisabledCheck !== "boolean" ) {
 675                         handlers = element;
 676                         element = suppressDisabledCheck;
 677                         suppressDisabledCheck = false;
 678                 }
 679
 680                 // no element argument, shuffle and use this.element
 681                 if ( !handlers ) {
 682                         handlers = element;
 683                         element = this.element;
 684                         delegateElement = this.widget();
 685                 } else {
 686                         // accept selectors, DOM elements
 687                         element = delegateElement = $( element );
 688                         this.bindings = this.bindings.add( element );
 689                 }
 690
 691                 $.each( handlers, function( event, handler ) {
 692                         function handlerProxy() {
 693                                 // allow widgets to customize the disabled handling
 694                                 // - disabled as an array instead of boolean
 695                                 // - disabled class as method for disabling individual parts
 696                                 if ( !suppressDisabledCheck &&
 697                                                 ( instance.options.disabled === true ||
 698                                                         $( this ).hasClass( "ui-state-disabled" ) ) ) {
 699                                         return;
 700                                 }
 701                                 return ( typeof handler === "string" ? instance[ handler ] : handler )
 702                                         .apply( instance, arguments );
 703                         }
 704
 705                         // copy the guid so direct unbinding works
 706                         if ( typeof handler !== "string" ) {
 707                                 handlerProxy.guid = handler.guid =
 708                                         handler.guid || handlerProxy.guid || $.guid++;
 709                         }
 710
 711                         var match = event.match( /^(\w+)\s*(.*)$/ ),
 712                                 eventName = match[1] + instance.eventNamespace,
 713                                 selector = match[2];
 714                         if ( selector ) {
 715                                 delegateElement.delegate( selector, eventName, handlerProxy );
 716                         } else {
 717                                 element.bind( eventName, handlerProxy );
 718                         }
 719                 });
 720         },
 721
 722         _off: function( element, eventName ) {
 723                 eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
 724                 element.unbind( eventName ).undelegate( eventName );
 725         },
 726
 727         _delay: function( handler, delay ) {
 728                 function handlerProxy() {
 729                         return ( typeof handler === "string" ? instance[ handler ] : handler )
 730                                 .apply( instance, arguments );
 731                 }
 732                 var instance = this;
 733                 return setTimeout( handlerProxy, delay || 0 );
 734         },
 735
 736         _hoverable: function( element ) {
 737                 this.hoverable = this.hoverable.add( element );
 738                 this._on( element, {
 739                         mouseenter: function( event ) {
 740                                 $( event.currentTarget ).addClass( "ui-state-hover" );
 741                         },
 742                         mouseleave: function( event ) {
 743                                 $( event.currentTarget ).removeClass( "ui-state-hover" );
 744                         }
 745                 });
 746         },
 747
 748         _focusable: function( element ) {
 749                 this.focusable = this.focusable.add( element );
 750                 this._on( element, {
 751                         focusin: function( event ) {
 752                                 $( event.currentTarget ).addClass( "ui-state-focus" );
 753                         },
 754                         focusout: function( event ) {
 755                                 $( event.currentTarget ).removeClass( "ui-state-focus" );
 756                         }
 757                 });
 758         },
 759
 760         _trigger: function( type, event, data ) {
 761                 var prop, orig,
 762                         callback = this.options[ type ];
 763
 764                 data = data || {};
 765                 event = $.Event( event );
 766                 event.type = ( type === this.widgetEventPrefix ?
 767                         type :
 768                         this.widgetEventPrefix + type ).toLowerCase();
 769                 // the original event may come from any element
 770                 // so we need to reset the target on the new event
 771                 event.target = this.element[ 0 ];
 772
 773                 // copy original event properties over to the new event
 774                 orig = event.originalEvent;
 775                 if ( orig ) {
 776                         for ( prop in orig ) {
 777                                 if ( !( prop in event ) ) {
 778                                         event[ prop ] = orig[ prop ];
 779                                 }
 780                         }
 781                 }
 782
 783                 this.element.trigger( event, data );
 784                 return !( $.isFunction( callback ) &&
 785                         callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
 786                         event.isDefaultPrevented() );
 787         }
 788 };
 789
 790 $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
 791         $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
 792                 if ( typeof options === "string" ) {
 793                         options = { effect: options };
 794                 }
 795                 var hasOptions,
 796                         effectName = !options ?
 797                                 method :
 798                                 options === true || typeof options === "number" ?
 799                                         defaultEffect :
 800                                         options.effect || defaultEffect;
 801                 options = options || {};
 802                 if ( typeof options === "number" ) {
 803                         options = { duration: options };
 804                 }
 805                 hasOptions = !$.isEmptyObject( options );
 806                 options.complete = callback;
 807                 if ( options.delay ) {
 808                         element.delay( options.delay );
 809                 }
 810                 if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
 811                         element[ method ]( options );
 812                 } else if ( effectName !== method && element[ effectName ] ) {
 813                         element[ effectName ]( options.duration, options.easing, callback );
 814                 } else {
 815                         element.queue(function( next ) {
 816                                 $( this )[ method ]();
 817                                 if ( callback ) {
 818                                         callback.call( element[ 0 ] );
 819                                 }
 820                                 next();
 821                         });
 822                 }
 823         };
 824 });
 825
 826 })( jQuery );
 827
 828 (function( $, undefined ) {
 829
 830 var mouseHandled = false;
 831 $( document ).mouseup( function() {
 832         mouseHandled = false;
 833 });
 834
 835 $.widget("ui.mouse", {
 836         version: "1.10.3",
 837         options: {
 838                 cancel: "input,textarea,button,select,option",
 839                 distance: 1,
 840                 delay: 0
 841         },
 842         _mouseInit: function() {
 843                 var that = this;
 844
 845                 this.element
 846                         .bind("mousedown."+this.widgetName, function(event) {
 847                                 return that._mouseDown(event);
 848                         })
 849                         .bind("click."+this.widgetName, function(event) {
 850                                 if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
 851                                         $.removeData(event.target, that.widgetName + ".preventClickEvent");
 852                                         event.stopImmediatePropagation();
 853                                         return false;
 854                                 }
 855                         });
 856
 857                 this.started = false;
 858         },
 859
 860         // TODO: make sure destroying one instance of mouse doesn't mess with
 861         // other instances of mouse
 862         _mouseDestroy: function() {
 863                 this.element.unbind("."+this.widgetName);
 864                 if ( this._mouseMoveDelegate ) {
 865                         $(document)
 866                                 .unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
 867                                 .unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
 868                 }
 869         },
 870
 871         _mouseDown: function(event) {
 872                 // don't let more than one widget handle mouseStart
 873                 if( mouseHandled ) { return; }
 874
 875                 // we may have missed mouseup (out of window)
 876                 (this._mouseStarted && this._mouseUp(event));
 877
 878                 this._mouseDownEvent = event;
 879
 880                 var that = this,
 881                         btnIsLeft = (event.which === 1),
 882                         // event.target.nodeName works around a bug in IE 8 with
 883                         // disabled inputs (#7620)
 884                         elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
 885                 if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
 886                         return true;
 887                 }
 888
 889                 this.mouseDelayMet = !this.options.delay;
 890                 if (!this.mouseDelayMet) {
 891                         this._mouseDelayTimer = setTimeout(function() {
 892                                 that.mouseDelayMet = true;
 893                         }, this.options.delay);
 894                 }
 895
 896                 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
 897                         this._mouseStarted = (this._mouseStart(event) !== false);
 898                         if (!this._mouseStarted) {
 899                                 event.preventDefault();
 900                                 return true;
 901                         }
 902                 }
 903
 904                 // Click event may never have fired (Gecko & Opera)
 905                 if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
 906                         $.removeData(event.target, this.widgetName + ".preventClickEvent");
 907                 }
 908
 909                 // these delegates are required to keep context
 910                 this._mouseMoveDelegate = function(event) {
 911                         return that._mouseMove(event);
 912                 };
 913                 this._mouseUpDelegate = function(event) {
 914                         return that._mouseUp(event);
 915                 };
 916                 $(document)
 917                         .bind("mousemove."+this.widgetName, this._mouseMoveDelegate)
 918                         .bind("mouseup."+this.widgetName, this._mouseUpDelegate);
 919
 920                 event.preventDefault();
 921
 922                 mouseHandled = true;
 923                 return true;
 924         },
 925
 926         _mouseMove: function(event) {
 927                 // IE mouseup check - mouseup happened when mouse was out of window
 928                 if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
 929                         return this._mouseUp(event);
 930                 }
 931
 932                 if (this._mouseStarted) {
 933                         this._mouseDrag(event);
 934                         return event.preventDefault();
 935                 }
 936
 937                 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
 938                         this._mouseStarted =
 939                                 (this._mouseStart(this._mouseDownEvent, event) !== false);
 940                         (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
 941                 }
 942
 943                 return !this._mouseStarted;
 944         },
 945
 946         _mouseUp: function(event) {
 947                 $(document)
 948                         .unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
 949                         .unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
 950
 951                 if (this._mouseStarted) {
 952                         this._mouseStarted = false;
 953
 954                         if (event.target === this._mouseDownEvent.target) {
 955                                 $.data(event.target, this.widgetName + ".preventClickEvent", true);
 956                         }
 957
 958                         this._mouseStop(event);
 959                 }
 960
 961                 return false;
 962         },
 963
 964         _mouseDistanceMet: function(event) {
 965                 return (Math.max(
 966                                 Math.abs(this._mouseDownEvent.pageX - event.pageX),
 967                                 Math.abs(this._mouseDownEvent.pageY - event.pageY)
 968                         ) >= this.options.distance
 969                 );
 970         },
 971
 972         _mouseDelayMet: function(/* event */) {
 973                 return this.mouseDelayMet;
 974         },
 975
 976         // These are placeholder methods, to be overriden by extending plugin
 977         _mouseStart: function(/* event */) {},
 978         _mouseDrag: function(/* event */) {},
 979         _mouseStop: function(/* event */) {},
 980         _mouseCapture: function(/* event */) { return true; }
 981 });
 982
 983 })(jQuery);
 984
 985 (function( $, undefined ) {
 986
 987 $.widget("ui.draggable", $.ui.mouse, {
 988         version: "1.10.3",
 989         widgetEventPrefix: "drag",
 990         options: {
 991                 addClasses: true,
 992                 appendTo: "parent",
 993                 axis: false,
 994                 connectToSortable: false,
 995                 containment: false,
 996                 cursor: "auto",
 997                 cursorAt: false,
 998                 grid: false,
 999                 handle: false,
1000                 helper: "original",
1001                 iframeFix: false,
1002                 opacity: false,
1003                 refreshPositions: false,
1004                 revert: false,
1005                 revertDuration: 500,
1006                 scope: "default",
1007                 scroll: true,
1008                 scrollSensitivity: 20,
1009                 scrollSpeed: 20,
1010                 snap: false,
1011                 snapMode: "both",
1012                 snapTolerance: 20,
1013                 stack: false,
1014                 zIndex: false,
1015
1016                 // callbacks
1017                 drag: null,
1018                 start: null,
1019                 stop: null
1020         },
1021         _create: function() {
1022
1023                 if (this.options.helper === "original" && !(/^(?:r|a|f)/).test(this.element.css("position"))) {
1024                         this.element[0].style.position = "relative";
1025                 }
1026                 if (this.options.addClasses){
1027                         this.element.addClass("ui-draggable");
1028                 }
1029                 if (this.options.disabled){
1030                         this.element.addClass("ui-draggable-disabled");
1031                 }
1032
1033                 this._mouseInit();
1034
1035         },
1036
1037         _destroy: function() {
1038                 this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
1039                 this._mouseDestroy();
1040         },
1041
1042         _mouseCapture: function(event) {
1043
1044                 var o = this.options;
1045
1046                 // among others, prevent a drag on a resizable-handle
1047                 if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
1048                         return false;
1049                 }
1050
1051                 //Quit if we're not on a valid handle
1052                 this.handle = this._getHandle(event);
1053                 if (!this.handle) {
1054                         return false;
1055                 }
1056
1057                 $(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {
1058                         $("<div class='ui-draggable-iframeFix' style='background: #fff;'></div>")
1059                         .css({
1060                                 width: this.offsetWidth+"px", height: this.offsetHeight+"px",
1061                                 position: "absolute", opacity: "0.001", zIndex: 1000
1062                         })
1063                         .css($(this).offset())
1064                         .appendTo("body");
1065                 });
1066
1067                 return true;
1068
1069         },
1070
1071         _mouseStart: function(event) {
1072
1073                 var o = this.options;
1074
1075                 //Create and append the visible helper
1076                 this.helper = this._createHelper(event);
1077
1078                 this.helper.addClass("ui-draggable-dragging");
1079
1080                 //Cache the helper size
1081                 this._cacheHelperProportions();
1082
1083                 //If ddmanager is used for droppables, set the global draggable
1084                 if($.ui.ddmanager) {
1085                         $.ui.ddmanager.current = this;
1086                 }
1087
1088                 /*
1089                  * - Position generation -
1090                  * This block generates everything position related - it's the core of draggables.
1091                  */
1092
1093                 //Cache the margins of the original element
1094                 this._cacheMargins();
1095
1096                 //Store the helper's css position
1097                 this.cssPosition = this.helper.css( "position" );
1098                 this.scrollParent = this.helper.scrollParent();
1099                 this.offsetParent = this.helper.offsetParent();
1100                 this.offsetParentCssPosition = this.offsetParent.css( "position" );
1101
1102                 //The element's absolute position on the page minus margins
1103                 this.offset = this.positionAbs = this.element.offset();
1104                 this.offset = {
1105                         top: this.offset.top - this.margins.top,
1106                         left: this.offset.left - this.margins.left
1107                 };
1108
1109                 //Reset scroll cache
1110                 this.offset.scroll = false;
1111
1112                 $.extend(this.offset, {
1113                         click: { //Where the click happened, relative to the element
1114                                 left: event.pageX - this.offset.left,
1115                                 top: event.pageY - this.offset.top
1116                         },
1117                         parent: this._getParentOffset(),
1118                         relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
1119                 });
1120
1121                 //Generate the original position
1122                 this.originalPosition = this.position = this._generatePosition(event);
1123                 this.originalPageX = event.pageX;
1124                 this.originalPageY = event.pageY;
1125
1126                 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
1127                 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
1128
1129                 //Set a containment if given in the options
1130                 this._setContainment();
1131
1132                 //Trigger event + callbacks
1133                 if(this._trigger("start", event) === false) {
1134                         this._clear();
1135                         return false;
1136                 }
1137
1138                 //Recache the helper size
1139                 this._cacheHelperProportions();
1140
1141                 //Prepare the droppable offsets
1142                 if ($.ui.ddmanager && !o.dropBehaviour) {
1143                         $.ui.ddmanager.prepareOffsets(this, event);
1144                 }
1145
1146
1147                 this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
1148
1149                 //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
1150                 if ( $.ui.ddmanager ) {
1151                         $.ui.ddmanager.dragStart(this, event);
1152                 }
1153
1154                 return true;
1155         },
1156
1157         _mouseDrag: function(event, noPropagation) {
1158                 // reset any necessary cached properties (see #5009)
1159                 if ( this.offsetParentCssPosition === "fixed" ) {
1160                         this.offset.parent = this._getParentOffset();
1161                 }
1162
1163                 //Compute the helpers position
1164                 this.position = this._generatePosition(event);
1165                 this.positionAbs = this._convertPositionTo("absolute");
1166
1167                 //Call plugins and callbacks and use the resulting position if something is returned
1168                 if (!noPropagation) {
1169                         var ui = this._uiHash();
1170                         if(this._trigger("drag", event, ui) === false) {
1171                                 this._mouseUp({});
1172                                 return false;
1173                         }
1174                         this.position = ui.position;
1175                 }
1176
1177                 if(!this.options.axis || this.options.axis !== "y") {
1178                         this.helper[0].style.left = this.position.left+"px";
1179                 }
1180                 if(!this.options.axis || this.options.axis !== "x") {
1181                         this.helper[0].style.top = this.position.top+"px";
1182                 }
1183                 if($.ui.ddmanager) {
1184                         $.ui.ddmanager.drag(this, event);
1185                 }
1186
1187                 return false;
1188         },
1189
1190         _mouseStop: function(event) {
1191
1192                 //If we are using droppables, inform the manager about the drop
1193                 var that = this,
1194                         dropped = false;
1195                 if ($.ui.ddmanager && !this.options.dropBehaviour) {
1196                         dropped = $.ui.ddmanager.drop(this, event);
1197                 }
1198
1199                 //if a drop comes from outside (a sortable)
1200                 if(this.dropped) {
1201                         dropped = this.dropped;
1202                         this.dropped = false;
1203                 }
1204
1205                 //if the original element is no longer in the DOM don't bother to continue (see #8269)
1206                 if ( this.options.helper === "original" && !$.contains( this.element[ 0 ].ownerDocument, this.element[ 0 ] ) ) {
1207                         return false;
1208                 }
1209
1210                 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))) {
1211                         $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
1212                                 if(that._trigger("stop", event) !== false) {
1213                                         that._clear();
1214                                 }
1215                         });
1216                 } else {
1217                         if(this._trigger("stop", event) !== false) {
1218                                 this._clear();
1219                         }
1220                 }
1221
1222                 return false;
1223         },
1224
1225         _mouseUp: function(event) {
1226                 //Remove frame helpers
1227                 $("div.ui-draggable-iframeFix").each(function() {
1228                         this.parentNode.removeChild(this);
1229                 });
1230
1231                 //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
1232                 if( $.ui.ddmanager ) {
1233                         $.ui.ddmanager.dragStop(this, event);
1234                 }
1235
1236                 return $.ui.mouse.prototype._mouseUp.call(this, event);
1237         },
1238
1239         cancel: function() {
1240
1241                 if(this.helper.is(".ui-draggable-dragging")) {
1242                         this._mouseUp({});
1243                 } else {
1244                         this._clear();
1245                 }
1246
1247                 return this;
1248
1249         },
1250
1251         _getHandle: function(event) {
1252                 return this.options.handle ?
1253                         !!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
1254                         true;
1255         },
1256
1257         _createHelper: function(event) {
1258
1259                 var o = this.options,
1260                         helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper === "clone" ? this.element.clone().removeAttr("id") : this.element);
1261
1262                 if(!helper.parents("body").length) {
1263                         helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
1264                 }
1265
1266                 if(helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
1267                         helper.css("position", "absolute");
1268                 }
1269
1270                 return helper;
1271
1272         },
1273
1274         _adjustOffsetFromHelper: function(obj) {
1275                 if (typeof obj === "string") {
1276                         obj = obj.split(" ");
1277                 }
1278                 if ($.isArray(obj)) {
1279                         obj = {left: +obj[0], top: +obj[1] || 0};
1280                 }
1281                 if ("left" in obj) {
1282                         this.offset.click.left = obj.left + this.margins.left;
1283                 }
1284                 if ("right" in obj) {
1285                         this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
1286                 }
1287                 if ("top" in obj) {
1288                         this.offset.click.top = obj.top + this.margins.top;
1289                 }
1290                 if ("bottom" in obj) {
1291                         this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
1292                 }
1293         },
1294
1295         _getParentOffset: function() {
1296
1297                 //Get the offsetParent and cache its position
1298                 var po = this.offsetParent.offset();
1299
1300                 // This is a special case where we need to modify a offset calculated on start, since the following happened:
1301                 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
1302                 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
1303                 //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
1304                 if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
1305                         po.left += this.scrollParent.scrollLeft();
1306                         po.top += this.scrollParent.scrollTop();
1307                 }
1308
1309                 //This needs to be actually done for all browsers, since pageX/pageY includes this information
1310                 //Ugly IE fix
1311                 if((this.offsetParent[0] === document.body) ||
1312                         (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
1313                         po = { top: 0, left: 0 };
1314                 }
1315
1316                 return {
1317                         top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
1318                         left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
1319                 };
1320
1321         },
1322
1323         _getRelativeOffset: function() {
1324
1325                 if(this.cssPosition === "relative") {
1326                         var p = this.element.position();
1327                         return {
1328                                 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
1329                                 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
1330                         };
1331                 } else {
1332                         return { top: 0, left: 0 };
1333                 }
1334
1335         },
1336
1337         _cacheMargins: function() {
1338                 this.margins = {
1339                         left: (parseInt(this.element.css("marginLeft"),10) || 0),
1340                         top: (parseInt(this.element.css("marginTop"),10) || 0),
1341                         right: (parseInt(this.element.css("marginRight"),10) || 0),
1342                         bottom: (parseInt(this.element.css("marginBottom"),10) || 0)
1343                 };
1344         },
1345
1346         _cacheHelperProportions: function() {
1347                 this.helperProportions = {
1348                         width: this.helper.outerWidth(),
1349                         height: this.helper.outerHeight()
1350                 };
1351         },
1352
1353         _setContainment: function() {
1354
1355                 var over, c, ce,
1356                         o = this.options;
1357
1358                 if ( !o.containment ) {
1359                         this.containment = null;
1360                         return;
1361                 }
1362
1363                 if ( o.containment === "window" ) {
1364                         this.containment = [
1365                                 $( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
1366                                 $( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
1367                                 $( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
1368                                 $( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
1369                         ];
1370                         return;
1371                 }
1372
1373                 if ( o.containment === "document") {
1374                         this.containment = [
1375                                 0,
1376                                 0,
1377                                 $( document ).width() - this.helperProportions.width - this.margins.left,
1378                                 ( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
1379                         ];
1380                         return;
1381                 }
1382
1383                 if ( o.containment.constructor === Array ) {
1384                         this.containment = o.containment;
1385                         return;
1386                 }
1387
1388                 if ( o.containment === "parent" ) {
1389                         o.containment = this.helper[ 0 ].parentNode;
1390                 }
1391
1392                 c = $( o.containment );
1393                 ce = c[ 0 ];
1394
1395                 if( !ce ) {
1396                         return;
1397                 }
1398
1399                 over = c.css( "overflow" ) !== "hidden";
1400
1401                 this.containment = [
1402                         ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
1403                         ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ) ,
1404                         ( over ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) - ( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) - ( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) - this.helperProportions.width - this.margins.left - this.margins.right,
1405                         ( over ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) - ( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) - ( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) - this.helperProportions.height - this.margins.top  - this.margins.bottom
1406                 ];
1407                 this.relative_container = c;
1408         },
1409
1410         _convertPositionTo: function(d, pos) {
1411
1412                 if(!pos) {
1413                         pos = this.position;
1414                 }
1415
1416                 var mod = d === "absolute" ? 1 : -1,
1417                         scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent;
1418
1419                 //Cache the scroll
1420                 if (!this.offset.scroll) {
1421                         this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
1422                 }
1423
1424                 return {
1425                         top: (
1426                                 pos.top +                                                                                                                               // The absolute mouse position
1427                                 this.offset.relative.top * mod +                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
1428                                 this.offset.parent.top * mod -                                                                          // The offsetParent's offset without borders (offset + border)
1429                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top ) * mod )
1430                         ),
1431                         left: (
1432                                 pos.left +                                                                                                                              // The absolute mouse position
1433                                 this.offset.relative.left * mod +                                                                               // Only for relative positioned nodes: Relative offset from element to offset parent
1434                                 this.offset.parent.left * mod   -                                                                               // The offsetParent's offset without borders (offset + border)
1435                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left ) * mod )
1436                         )
1437                 };
1438
1439         },
1440
1441         _generatePosition: function(event) {
1442
1443                 var containment, co, top, left,
1444                         o = this.options,
1445                         scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent,
1446                         pageX = event.pageX,
1447                         pageY = event.pageY;
1448
1449                 //Cache the scroll
1450                 if (!this.offset.scroll) {
1451                         this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
1452                 }
1453
1454                 /*
1455                  * - Position constraining -
1456                  * Constrain the position to a mix of grid, containment.
1457                  */
1458
1459                 // If we are not dragging yet, we won't check for options
1460                 if ( this.originalPosition ) {
1461                         if ( this.containment ) {
1462                                 if ( this.relative_container ){
1463                                         co = this.relative_container.offset();
1464                                         containment = [
1465                                                 this.containment[ 0 ] + co.left,
1466                                                 this.containment[ 1 ] + co.top,
1467                                                 this.containment[ 2 ] + co.left,
1468                                                 this.containment[ 3 ] + co.top
1469                                         ];
1470                                 }
1471                                 else {
1472                                         containment = this.containment;
1473                                 }
1474
1475                                 if(event.pageX - this.offset.click.left < containment[0]) {
1476                                         pageX = containment[0] + this.offset.click.left;
1477                                 }
1478                                 if(event.pageY - this.offset.click.top < containment[1]) {
1479                                         pageY = containment[1] + this.offset.click.top;
1480                                 }
1481                                 if(event.pageX - this.offset.click.left > containment[2]) {
1482                                         pageX = containment[2] + this.offset.click.left;
1483                                 }
1484                                 if(event.pageY - this.offset.click.top > containment[3]) {
1485                                         pageY = containment[3] + this.offset.click.top;
1486                                 }
1487                         }
1488
1489                         if(o.grid) {
1490                                 //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
1491                                 top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
1492                                 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;
1493
1494                                 left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
1495                                 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;
1496                         }
1497
1498                 }
1499
1500                 return {
1501                         top: (
1502                                 pageY -                                                                                                                                 // The absolute mouse position
1503                                 this.offset.click.top   -                                                                                               // Click offset (relative to the element)
1504                                 this.offset.relative.top -                                                                                              // Only for relative positioned nodes: Relative offset from element to offset parent
1505                                 this.offset.parent.top +                                                                                                // The offsetParent's offset without borders (offset + border)
1506                                 ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top )
1507                         ),
1508                         left: (
1509                                 pageX -                                                                                                                                 // The absolute mouse position
1510                                 this.offset.click.left -                                                                                                // Click offset (relative to the element)
1511                                 this.offset.relative.left -                                                                                             // Only for relative positioned nodes: Relative offset from element to offset parent
1512                                 this.offset.parent.left +                                                                                               // The offsetParent's offset without borders (offset + border)
1513                                 ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left )
1514                         )
1515                 };
1516
1517         },
1518
1519         _clear: function() {
1520                 this.helper.removeClass("ui-draggable-dragging");
1521                 if(this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
1522                         this.helper.remove();
1523                 }
1524                 this.helper = null;
1525                 this.cancelHelperRemoval = false;
1526         },
1527
1528         // From now on bulk stuff - mainly helpers
1529
1530         _trigger: function(type, event, ui) {
1531                 ui = ui || this._uiHash();
1532                 $.ui.plugin.call(this, type, [event, ui]);
1533                 //The absolute position has to be recalculated after plugins
1534                 if(type === "drag") {
1535                         this.positionAbs = this._convertPositionTo("absolute");
1536                 }
1537                 return $.Widget.prototype._trigger.call(this, type, event, ui);
1538         },
1539
1540         plugins: {},
1541
1542         _uiHash: function() {
1543                 return {
1544                         helper: this.helper,
1545                         position: this.position,
1546                         originalPosition: this.originalPosition,
1547                         offset: this.positionAbs
1548                 };
1549         }
1550
1551 });
1552
1553 $.ui.plugin.add("draggable", "connectToSortable", {
1554         start: function(event, ui) {
1555
1556                 var inst = $(this).data("ui-draggable"), o = inst.options,
1557                         uiSortable = $.extend({}, ui, { item: inst.element });
1558                 inst.sortables = [];
1559                 $(o.connectToSortable).each(function() {
1560                         var sortable = $.data(this, "ui-sortable");
1561                         if (sortable && !sortable.options.disabled) {
1562                                 inst.sortables.push({
1563                                         instance: sortable,
1564                                         shouldRevert: sortable.options.revert
1565                                 });
1566                                 sortable.refreshPositions();    // Call the sortable's refreshPositions at drag start to refresh the containerCache since the sortable container cache is used in drag and needs to be up to date (this will ensure it's initialised as well as being kept in step with any changes that might have happened on the page).
1567                                 sortable._trigger("activate", event, uiSortable);
1568                         }
1569                 });
1570
1571         },
1572         stop: function(event, ui) {
1573
1574                 //If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
1575                 var inst = $(this).data("ui-draggable"),
1576                         uiSortable = $.extend({}, ui, { item: inst.element });
1577
1578                 $.each(inst.sortables, function() {
1579                         if(this.instance.isOver) {
1580
1581                                 this.instance.isOver = 0;
1582
1583                                 inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
1584                                 this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
1585
1586                                 //The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: "valid/invalid"
1587                                 if(this.shouldRevert) {
1588                                         this.instance.options.revert = this.shouldRevert;
1589                                 }
1590
1591                                 //Trigger the stop of the sortable
1592                                 this.instance._mouseStop(event);
1593
1594                                 this.instance.options.helper = this.instance.options._helper;
1595
1596                                 //If the helper has been the original item, restore properties in the sortable
1597                                 if(inst.options.helper === "original") {
1598                                         this.instance.currentItem.css({ top: "auto", left: "auto" });
1599                                 }
1600
1601                         } else {
1602                                 this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
1603                                 this.instance._trigger("deactivate", event, uiSortable);
1604                         }
1605
1606                 });
1607
1608         },
1609         drag: function(event, ui) {
1610
1611                 var inst = $(this).data("ui-draggable"), that = this;
1612
1613                 $.each(inst.sortables, function() {
1614
1615                         var innermostIntersecting = false,
1616                                 thisSortable = this;
1617
1618                         //Copy over some variables to allow calling the sortable's native _intersectsWith
1619                         this.instance.positionAbs = inst.positionAbs;
1620                         this.instance.helperProportions = inst.helperProportions;
1621                         this.instance.offset.click = inst.offset.click;
1622
1623                         if(this.instance._intersectsWith(this.instance.containerCache)) {
1624                                 innermostIntersecting = true;
1625                                 $.each(inst.sortables, function () {
1626                                         this.instance.positionAbs = inst.positionAbs;
1627                                         this.instance.helperProportions = inst.helperProportions;
1628                                         this.instance.offset.click = inst.offset.click;
1629                                         if (this !== thisSortable &&
1630                                                 this.instance._intersectsWith(this.instance.containerCache) &&
1631                                                 $.contains(thisSortable.instance.element[0], this.instance.element[0])
1632                                         ) {
1633                                                 innermostIntersecting = false;
1634                                         }
1635                                         return innermostIntersecting;
1636                                 });
1637                         }
1638
1639
1640                         if(innermostIntersecting) {
1641                                 //If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
1642                                 if(!this.instance.isOver) {
1643
1644                                         this.instance.isOver = 1;
1645                                         //Now we fake the start of dragging for the sortable instance,
1646                                         //by cloning the list group item, appending it to the sortable and using it as inst.currentItem
1647                                         //We can then fire the start event of the sortable with our passed browser event, and our own helper (so it doesn't create a new one)
1648                                         this.instance.currentItem = $(that).clone().removeAttr("id").appendTo(this.instance.element).data("ui-sortable-item", true);
1649                                         this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
1650                                         this.instance.options.helper = function() { return ui.helper[0]; };
1651
1652                                         event.target = this.instance.currentItem[0];
1653                                         this.instance._mouseCapture(event, true);
1654                                         this.instance._mouseStart(event, true, true);
1655
1656                                         //Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
1657                                         this.instance.offset.click.top = inst.offset.click.top;
1658                                         this.instance.offset.click.left = inst.offset.click.left;
1659                                         this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
1660                                         this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
1661
1662                                         inst._trigger("toSortable", event);
1663                                         inst.dropped = this.instance.element; //draggable revert needs that
1664                                         //hack so receive/update callbacks work (mostly)
1665                                         inst.currentItem = inst.element;
1666                                         this.instance.fromOutside = inst;
1667
1668                                 }
1669
1670                                 //Provided we did all the previous steps, we can fire the drag event of the sortable on every draggable drag, when it intersects with the sortable
1671                                 if(this.instance.currentItem) {
1672                                         this.instance._mouseDrag(event);
1673                                 }
1674
1675                         } else {
1676
1677                                 //If it doesn't intersect with the sortable, and it intersected before,
1678                                 //we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
1679                                 if(this.instance.isOver) {
1680
1681                                         this.instance.isOver = 0;
1682                                         this.instance.cancelHelperRemoval = true;
1683
1684                                         //Prevent reverting on this forced stop
1685                                         this.instance.options.revert = false;
1686
1687                                         // The out event needs to be triggered independently
1688                                         this.instance._trigger("out", event, this.instance._uiHash(this.instance));
1689
1690                                         this.instance._mouseStop(event, true);
1691                                         this.instance.options.helper = this.instance.options._helper;
1692
1693                                         //Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
1694                                         this.instance.currentItem.remove();
1695                                         if(this.instance.placeholder) {
1696                                                 this.instance.placeholder.remove();
1697                                         }
1698
1699                                         inst._trigger("fromSortable", event);
1700                                         inst.dropped = false; //draggable revert needs that
1701                                 }
1702
1703                         }
1704
1705                 });
1706
1707         }
1708 });
1709
1710 $.ui.plugin.add("draggable", "cursor", {
1711         start: function() {
1712                 var t = $("body"), o = $(this).data("ui-draggable").options;
1713                 if (t.css("cursor")) {
1714                         o._cursor = t.css("cursor");
1715                 }
1716                 t.css("cursor", o.cursor);
1717         },
1718         stop: function() {
1719                 var o = $(this).data("ui-draggable").options;
1720                 if (o._cursor) {
1721                         $("body").css("cursor", o._cursor);
1722                 }
1723         }
1724 });
1725
1726 $.ui.plugin.add("draggable", "opacity", {
1727         start: function(event, ui) {
1728                 var t = $(ui.helper), o = $(this).data("ui-draggable").options;
1729                 if(t.css("opacity")) {
1730                         o._opacity = t.css("opacity");
1731                 }
1732                 t.css("opacity", o.opacity);
1733         },
1734         stop: function(event, ui) {
1735                 var o = $(this).data("ui-draggable").options;
1736                 if(o._opacity) {
1737                         $(ui.helper).css("opacity", o._opacity);
1738                 }
1739         }
1740 });
1741
1742 $.ui.plugin.add("draggable", "scroll", {
1743         start: function() {
1744                 var i = $(this).data("ui-draggable");
1745                 if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
1746                         i.overflowOffset = i.scrollParent.offset();
1747                 }
1748         },
1749         drag: function( event ) {
1750
1751                 var i = $(this).data("ui-draggable"), o = i.options, scrolled = false;
1752
1753                 if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
1754
1755                         if(!o.axis || o.axis !== "x") {
1756                                 if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
1757                                         i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
1758                                 } else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity) {
1759                                         i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
1760                                 }
1761                         }
1762
1763                         if(!o.axis || o.axis !== "y") {
1764                                 if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
1765                                         i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
1766                                 } else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity) {
1767                                         i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
1768                                 }
1769                         }
1770
1771                 } else {
1772
1773                         if(!o.axis || o.axis !== "x") {
1774                                 if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
1775                                         scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
1776                                 } else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
1777                                         scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
1778                                 }
1779                         }
1780
1781                         if(!o.axis || o.axis !== "y") {
1782                                 if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
1783                                         scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
1784                                 } else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
1785                                         scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
1786                                 }
1787                         }
1788
1789                 }
1790
1791                 if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
1792                         $.ui.ddmanager.prepareOffsets(i, event);
1793                 }
1794
1795         }
1796 });
1797
1798 $.ui.plugin.add("draggable", "snap", {
1799         start: function() {
1800
1801                 var i = $(this).data("ui-draggable"),
1802                         o = i.options;
1803
1804                 i.snapElements = [];
1805
1806                 $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
1807                         var $t = $(this),
1808                                 $o = $t.offset();
1809                         if(this !== i.element[0]) {
1810                                 i.snapElements.push({
1811                                         item: this,
1812                                         width: $t.outerWidth(), height: $t.outerHeight(),
1813                                         top: $o.top, left: $o.left
1814                                 });
1815                         }
1816                 });
1817
1818         },
1819         drag: function(event, ui) {
1820
1821                 var ts, bs, ls, rs, l, r, t, b, i, first,
1822                         inst = $(this).data("ui-draggable"),
1823                         o = inst.options,
1824                         d = o.snapTolerance,
1825                         x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
1826                         y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
1827
1828                 for (i = inst.snapElements.length - 1; i >= 0; i--){
1829
1830                         l = inst.snapElements[i].left;
1831                         r = l + inst.snapElements[i].width;
1832                         t = inst.snapElements[i].top;
1833                         b = t + inst.snapElements[i].height;
1834
1835                         if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
1836                                 if(inst.snapElements[i].snapping) {
1837                                         (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1838                                 }
1839                                 inst.snapElements[i].snapping = false;
1840                                 continue;
1841                         }
1842
1843                         if(o.snapMode !== "inner") {
1844                                 ts = Math.abs(t - y2) <= d;
1845                                 bs = Math.abs(b - y1) <= d;
1846                                 ls = Math.abs(l - x2) <= d;
1847                                 rs = Math.abs(r - x1) <= d;
1848                                 if(ts) {
1849                                         ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1850                                 }
1851                                 if(bs) {
1852                                         ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
1853                                 }
1854                                 if(ls) {
1855                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
1856                                 }
1857                                 if(rs) {
1858                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
1859                                 }
1860                         }
1861
1862                         first = (ts || bs || ls || rs);
1863
1864                         if(o.snapMode !== "outer") {
1865                                 ts = Math.abs(t - y1) <= d;
1866                                 bs = Math.abs(b - y2) <= d;
1867                                 ls = Math.abs(l - x1) <= d;
1868                                 rs = Math.abs(r - x2) <= d;
1869                                 if(ts) {
1870                                         ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
1871                                 }
1872                                 if(bs) {
1873                                         ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1874                                 }
1875                                 if(ls) {
1876                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
1877                                 }
1878                                 if(rs) {
1879                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
1880                                 }
1881                         }
1882
1883                         if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
1884                                 (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1885                         }
1886                         inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
1887
1888                 }
1889
1890         }
1891 });
1892
1893 $.ui.plugin.add("draggable", "stack", {
1894         start: function() {
1895                 var min,
1896                         o = this.data("ui-draggable").options,
1897                         group = $.makeArray($(o.stack)).sort(function(a,b) {
1898                                 return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
1899                         });
1900
1901                 if (!group.length) { return; }
1902
1903                 min = parseInt($(group[0]).css("zIndex"), 10) || 0;
1904                 $(group).each(function(i) {
1905                         $(this).css("zIndex", min + i);
1906                 });
1907                 this.css("zIndex", (min + group.length));
1908         }
1909 });
1910
1911 $.ui.plugin.add("draggable", "zIndex", {
1912         start: function(event, ui) {
1913                 var t = $(ui.helper), o = $(this).data("ui-draggable").options;
1914                 if(t.css("zIndex")) {
1915                         o._zIndex = t.css("zIndex");
1916                 }
1917                 t.css("zIndex", o.zIndex);
1918         },
1919         stop: function(event, ui) {
1920                 var o = $(this).data("ui-draggable").options;
1921                 if(o._zIndex) {
1922                         $(ui.helper).css("zIndex", o._zIndex);
1923                 }
1924         }
1925 });
1926
1927 })(jQuery);
1928
1929 (function( $, undefined ) {
1930
1931 function isOverAxis( x, reference, size ) {
1932         return ( x > reference ) && ( x < ( reference + size ) );
1933 }
1934
1935 $.widget("ui.droppable", {
1936         version: "1.10.3",
1937         widgetEventPrefix: "drop",
1938         options: {
1939                 accept: "*",
1940                 activeClass: false,
1941                 addClasses: true,
1942                 greedy: false,
1943                 hoverClass: false,
1944                 scope: "default",
1945                 tolerance: "intersect",
1946
1947                 // callbacks
1948                 activate: null,
1949                 deactivate: null,
1950                 drop: null,
1951                 out: null,
1952                 over: null
1953         },
1954         _create: function() {
1955
1956                 var o = this.options,
1957                         accept = o.accept;
1958
1959                 this.isover = false;
1960                 this.isout = true;
1961
1962                 this.accept = $.isFunction(accept) ? accept : function(d) {
1963                         return d.is(accept);
1964                 };
1965
1966                 //Store the droppable's proportions
1967                 this.proportions = { width: this.element[0].offsetWidth, height: this.element[0].offsetHeight };
1968
1969                 // Add the reference and positions to the manager
1970                 $.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
1971                 $.ui.ddmanager.droppables[o.scope].push(this);
1972
1973                 (o.addClasses && this.element.addClass("ui-droppable"));
1974
1975         },
1976
1977         _destroy: function() {
1978                 var i = 0,
1979                         drop = $.ui.ddmanager.droppables[this.options.scope];
1980
1981                 for ( ; i < drop.length; i++ ) {
1982                         if ( drop[i] === this ) {
1983                                 drop.splice(i, 1);
1984                         }
1985                 }
1986
1987                 this.element.removeClass("ui-droppable ui-droppable-disabled");
1988         },
1989
1990         _setOption: function(key, value) {
1991
1992                 if(key === "accept") {
1993                         this.accept = $.isFunction(value) ? value : function(d) {
1994                                 return d.is(value);
1995                         };
1996                 }
1997                 $.Widget.prototype._setOption.apply(this, arguments);
1998         },
1999
2000         _activate: function(event) {
2001                 var draggable = $.ui.ddmanager.current;
2002                 if(this.options.activeClass) {
2003                         this.element.addClass(this.options.activeClass);
2004                 }
2005                 if(draggable){
2006                         this._trigger("activate", event, this.ui(draggable));
2007                 }
2008         },
2009
2010         _deactivate: function(event) {
2011                 var draggable = $.ui.ddmanager.current;
2012                 if(this.options.activeClass) {
2013                         this.element.removeClass(this.options.activeClass);
2014                 }
2015                 if(draggable){
2016                         this._trigger("deactivate", event, this.ui(draggable));
2017                 }
2018         },
2019
2020         _over: function(event) {
2021
2022                 var draggable = $.ui.ddmanager.current;
2023
2024                 // Bail if draggable and droppable are same element
2025                 if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2026                         return;
2027                 }
2028
2029                 if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2030                         if(this.options.hoverClass) {
2031                                 this.element.addClass(this.options.hoverClass);
2032                         }
2033                         this._trigger("over", event, this.ui(draggable));
2034                 }
2035
2036         },
2037
2038         _out: function(event) {
2039
2040                 var draggable = $.ui.ddmanager.current;
2041
2042                 // Bail if draggable and droppable are same element
2043                 if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2044                         return;
2045                 }
2046
2047                 if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2048                         if(this.options.hoverClass) {
2049                                 this.element.removeClass(this.options.hoverClass);
2050                         }
2051                         this._trigger("out", event, this.ui(draggable));
2052                 }
2053
2054         },
2055
2056         _drop: function(event,custom) {
2057
2058                 var draggable = custom || $.ui.ddmanager.current,
2059                         childrenIntersection = false;
2060
2061                 // Bail if draggable and droppable are same element
2062                 if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2063                         return false;
2064                 }
2065
2066                 this.element.find(":data(ui-droppable)").not(".ui-draggable-dragging").each(function() {
2067                         var inst = $.data(this, "ui-droppable");
2068                         if(
2069                                 inst.options.greedy &&
2070                                 !inst.options.disabled &&
2071                                 inst.options.scope === draggable.options.scope &&
2072                                 inst.accept.call(inst.element[0], (draggable.currentItem || draggable.element)) &&
2073                                 $.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
2074                         ) { childrenIntersection = true; return false; }
2075                 });
2076                 if(childrenIntersection) {
2077                         return false;
2078                 }
2079
2080                 if(this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2081                         if(this.options.activeClass) {
2082                                 this.element.removeClass(this.options.activeClass);
2083                         }
2084                         if(this.options.hoverClass) {
2085                                 this.element.removeClass(this.options.hoverClass);
2086                         }
2087                         this._trigger("drop", event, this.ui(draggable));
2088                         return this.element;
2089                 }
2090
2091                 return false;
2092
2093         },
2094
2095         ui: function(c) {
2096                 return {
2097                         draggable: (c.currentItem || c.element),
2098                         helper: c.helper,
2099                         position: c.position,
2100                         offset: c.positionAbs
2101                 };
2102         }
2103
2104 });
2105
2106 $.ui.intersect = function(draggable, droppable, toleranceMode) {
2107
2108         if (!droppable.offset) {
2109                 return false;
2110         }
2111
2112         var draggableLeft, draggableTop,
2113                 x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
2114                 y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height,
2115                 l = droppable.offset.left, r = l + droppable.proportions.width,
2116                 t = droppable.offset.top, b = t + droppable.proportions.height;
2117
2118         switch (toleranceMode) {
2119                 case "fit":
2120                         return (l <= x1 && x2 <= r && t <= y1 && y2 <= b);
2121                 case "intersect":
2122                         return (l < x1 + (draggable.helperProportions.width / 2) && // Right Half
2123                                 x2 - (draggable.helperProportions.width / 2) < r && // Left Half
2124                                 t < y1 + (draggable.helperProportions.height / 2) && // Bottom Half
2125                                 y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
2126                 case "pointer":
2127                         draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left);
2128                         draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top);
2129                         return isOverAxis( draggableTop, t, droppable.proportions.height ) && isOverAxis( draggableLeft, l, droppable.proportions.width );
2130                 case "touch":
2131                         return (
2132                                 (y1 >= t && y1 <= b) || // Top edge touching
2133                                 (y2 >= t && y2 <= b) || // Bottom edge touching
2134                                 (y1 < t && y2 > b)              // Surrounded vertically
2135                         ) && (
2136                                 (x1 >= l && x1 <= r) || // Left edge touching
2137                                 (x2 >= l && x2 <= r) || // Right edge touching
2138                                 (x1 < l && x2 > r)              // Surrounded horizontally
2139                         );
2140                 default:
2141                         return false;
2142                 }
2143
2144 };
2145
2146 /*
2147         This manager tracks offsets of draggables and droppables
2148 */
2149 $.ui.ddmanager = {
2150         current: null,
2151         droppables: { "default": [] },
2152         prepareOffsets: function(t, event) {
2153
2154                 var i, j,
2155                         m = $.ui.ddmanager.droppables[t.options.scope] || [],
2156                         type = event ? event.type : null, // workaround for #2317
2157                         list = (t.currentItem || t.element).find(":data(ui-droppable)").addBack();
2158
2159                 droppablesLoop: for (i = 0; i < m.length; i++) {
2160
2161                         //No disabled and non-accepted
2162                         if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) {
2163                                 continue;
2164                         }
2165
2166                         // Filter out elements in the current dragged item
2167                         for (j=0; j < list.length; j++) {
2168                                 if(list[j] === m[i].element[0]) {
2169                                         m[i].proportions.height = 0;
2170                                         continue droppablesLoop;
2171                                 }
2172                         }
2173
2174                         m[i].visible = m[i].element.css("display") !== "none";
2175                         if(!m[i].visible) {
2176                                 continue;
2177                         }
2178
2179                         //Activate the droppable if used directly from draggables
2180                         if(type === "mousedown") {
2181                                 m[i]._activate.call(m[i], event);
2182                         }
2183
2184                         m[i].offset = m[i].element.offset();
2185                         m[i].proportions = { width: m[i].element[0].offsetWidth, height: m[i].element[0].offsetHeight };
2186
2187                 }
2188
2189         },
2190         drop: function(draggable, event) {
2191
2192                 var dropped = false;
2193                 // Create a copy of the droppables in case the list changes during the drop (#9116)
2194                 $.each(($.ui.ddmanager.droppables[draggable.options.scope] || []).slice(), function() {
2195
2196                         if(!this.options) {
2197                                 return;
2198                         }
2199                         if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance)) {
2200                                 dropped = this._drop.call(this, event) || dropped;
2201                         }
2202
2203                         if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2204                                 this.isout = true;
2205                                 this.isover = false;
2206                                 this._deactivate.call(this, event);
2207                         }
2208
2209                 });
2210                 return dropped;
2211
2212         },
2213         dragStart: function( draggable, event ) {
2214                 //Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
2215                 draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
2216                         if( !draggable.options.refreshPositions ) {
2217                                 $.ui.ddmanager.prepareOffsets( draggable, event );
2218                         }
2219                 });
2220         },
2221         drag: function(draggable, event) {
2222
2223                 //If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
2224                 if(draggable.options.refreshPositions) {
2225                         $.ui.ddmanager.prepareOffsets(draggable, event);
2226                 }
2227
2228                 //Run through all droppables and check their positions based on specific tolerance options
2229                 $.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
2230
2231                         if(this.options.disabled || this.greedyChild || !this.visible) {
2232                                 return;
2233                         }
2234
2235                         var parentInstance, scope, parent,
2236                                 intersects = $.ui.intersect(draggable, this, this.options.tolerance),
2237                                 c = !intersects && this.isover ? "isout" : (intersects && !this.isover ? "isover" : null);
2238                         if(!c) {
2239                                 return;
2240                         }
2241
2242                         if (this.options.greedy) {
2243                                 // find droppable parents with same scope
2244                                 scope = this.options.scope;
2245                                 parent = this.element.parents(":data(ui-droppable)").filter(function () {
2246                                         return $.data(this, "ui-droppable").options.scope === scope;
2247                                 });
2248
2249                                 if (parent.length) {
2250                                         parentInstance = $.data(parent[0], "ui-droppable");
2251                                         parentInstance.greedyChild = (c === "isover");
2252                                 }
2253                         }
2254
2255                         // we just moved into a greedy child
2256                         if (parentInstance && c === "isover") {
2257                                 parentInstance.isover = false;
2258                                 parentInstance.isout = true;
2259                                 parentInstance._out.call(parentInstance, event);
2260                         }
2261
2262                         this[c] = true;
2263                         this[c === "isout" ? "isover" : "isout"] = false;
2264                         this[c === "isover" ? "_over" : "_out"].call(this, event);
2265
2266                         // we just moved out of a greedy child
2267                         if (parentInstance && c === "isout") {
2268                                 parentInstance.isout = false;
2269                                 parentInstance.isover = true;
2270                                 parentInstance._over.call(parentInstance, event);
2271                         }
2272                 });
2273
2274         },
2275         dragStop: function( draggable, event ) {
2276                 draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
2277                 //Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
2278                 if( !draggable.options.refreshPositions ) {
2279                         $.ui.ddmanager.prepareOffsets( draggable, event );
2280                 }
2281         }
2282 };
2283
2284 })(jQuery);
2285
2286 (function( $, undefined ) {
2287
2288 function num(v) {
2289         return parseInt(v, 10) || 0;
2290 }
2291
2292 function isNumber(value) {
2293         return !isNaN(parseInt(value, 10));
2294 }
2295
2296 $.widget("ui.resizable", $.ui.mouse, {
2297         version: "1.10.3",
2298         widgetEventPrefix: "resize",
2299         options: {
2300                 alsoResize: false,
2301                 animate: false,
2302                 animateDuration: "slow",
2303                 animateEasing: "swing",
2304                 aspectRatio: false,
2305                 autoHide: false,
2306                 containment: false,
2307                 ghost: false,
2308                 grid: false,
2309                 handles: "e,s,se",
2310                 helper: false,
2311                 maxHeight: null,
2312                 maxWidth: null,
2313                 minHeight: 10,
2314                 minWidth: 10,
2315                 // See #7960
2316                 zIndex: 90,
2317
2318                 // callbacks
2319                 resize: null,
2320                 start: null,
2321                 stop: null
2322         },
2323         _create: function() {
2324
2325                 var n, i, handle, axis, hname,
2326                         that = this,
2327                         o = this.options;
2328                 this.element.addClass("ui-resizable");
2329
2330                 $.extend(this, {
2331                         _aspectRatio: !!(o.aspectRatio),
2332                         aspectRatio: o.aspectRatio,
2333                         originalElement: this.element,
2334                         _proportionallyResizeElements: [],
2335                         _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
2336                 });
2337
2338                 //Wrap the element if it cannot hold child nodes
2339                 if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {
2340
2341                         //Create a wrapper element and set the wrapper to the new current internal element
2342                         this.element.wrap(
2343                                 $("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
2344                                         position: this.element.css("position"),
2345                                         width: this.element.outerWidth(),
2346                                         height: this.element.outerHeight(),
2347                                         top: this.element.css("top"),
2348                                         left: this.element.css("left")
2349                                 })
2350                         );
2351
2352                         //Overwrite the original this.element
2353                         this.element = this.element.parent().data(
2354                                 "ui-resizable", this.element.data("ui-resizable")
2355                         );
2356
2357                         this.elementIsWrapper = true;
2358
2359                         //Move margins to the wrapper
2360                         this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
2361                         this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
2362
2363                         //Prevent Safari textarea resize
2364                         this.originalResizeStyle = this.originalElement.css("resize");
2365                         this.originalElement.css("resize", "none");
2366
2367                         //Push the actual element to our proportionallyResize internal array
2368                         this._proportionallyResizeElements.push(this.originalElement.css({ position: "static", zoom: 1, display: "block" }));
2369
2370                         // avoid IE jump (hard set the margin)
2371                         this.originalElement.css({ margin: this.originalElement.css("margin") });
2372
2373                         // fix handlers offset
2374                         this._proportionallyResize();
2375
2376                 }
2377
2378                 this.handles = o.handles || (!$(".ui-resizable-handle", this.element).length ? "e,s,se" : { n: ".ui-resizable-n", e: ".ui-resizable-e", s: ".ui-resizable-s", w: ".ui-resizable-w", se: ".ui-resizable-se", sw: ".ui-resizable-sw", ne: ".ui-resizable-ne", nw: ".ui-resizable-nw" });
2379                 if(this.handles.constructor === String) {
2380
2381                         if ( this.handles === "all") {
2382                                 this.handles = "n,e,s,w,se,sw,ne,nw";
2383                         }
2384
2385                         n = this.handles.split(",");
2386                         this.handles = {};
2387
2388                         for(i = 0; i < n.length; i++) {
2389
2390                                 handle = $.trim(n[i]);
2391                                 hname = "ui-resizable-"+handle;
2392                                 axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
2393
2394                                 // Apply zIndex to all handles - see #7960
2395                                 axis.css({ zIndex: o.zIndex });
2396
2397                                 //TODO : What's going on here?
2398                                 if ("se" === handle) {
2399                                         axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
2400                                 }
2401
2402                                 //Insert into internal handles object and append to element
2403                                 this.handles[handle] = ".ui-resizable-"+handle;
2404                                 this.element.append(axis);
2405                         }
2406
2407                 }
2408
2409                 this._renderAxis = function(target) {
2410
2411                         var i, axis, padPos, padWrapper;
2412
2413                         target = target || this.element;
2414
2415                         for(i in this.handles) {
2416
2417                                 if(this.handles[i].constructor === String) {
2418                                         this.handles[i] = $(this.handles[i], this.element).show();
2419                                 }
2420
2421                                 //Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
2422                                 if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {
2423
2424                                         axis = $(this.handles[i], this.element);
2425
2426                                         //Checking the correct pad and border
2427                                         padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
2428
2429                                         //The padding type i have to apply...
2430                                         padPos = [ "padding",
2431                                                 /ne|nw|n/.test(i) ? "Top" :
2432                                                 /se|sw|s/.test(i) ? "Bottom" :
2433                                                 /^e$/.test(i) ? "Right" : "Left" ].join("");
2434
2435                                         target.css(padPos, padWrapper);
2436
2437                                         this._proportionallyResize();
2438
2439                                 }
2440
2441                                 //TODO: What's that good for? There's not anything to be executed left
2442                                 if(!$(this.handles[i]).length) {
2443                                         continue;
2444                                 }
2445                         }
2446                 };
2447
2448                 //TODO: make renderAxis a prototype function
2449                 this._renderAxis(this.element);
2450
2451                 this._handles = $(".ui-resizable-handle", this.element)
2452                         .disableSelection();
2453
2454                 //Matching axis name
2455                 this._handles.mouseover(function() {
2456                         if (!that.resizing) {
2457                                 if (this.className) {
2458                                         axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
2459                                 }
2460                                 //Axis, default = se
2461                                 that.axis = axis && axis[1] ? axis[1] : "se";
2462                         }
2463                 });
2464
2465                 //If we want to auto hide the elements
2466                 if (o.autoHide) {
2467                         this._handles.hide();
2468                         $(this.element)
2469                                 .addClass("ui-resizable-autohide")
2470                                 .mouseenter(function() {
2471                                         if (o.disabled) {
2472                                                 return;
2473                                         }
2474                                         $(this).removeClass("ui-resizable-autohide");
2475                                         that._handles.show();
2476                                 })
2477                                 .mouseleave(function(){
2478                                         if (o.disabled) {
2479                                                 return;
2480                                         }
2481                                         if (!that.resizing) {
2482                                                 $(this).addClass("ui-resizable-autohide");
2483                                                 that._handles.hide();
2484                                         }
2485                                 });
2486                 }
2487
2488                 //Initialize the mouse interaction
2489                 this._mouseInit();
2490
2491         },
2492
2493         _destroy: function() {
2494
2495                 this._mouseDestroy();
2496
2497                 var wrapper,
2498                         _destroy = function(exp) {
2499                                 $(exp).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
2500                                         .removeData("resizable").removeData("ui-resizable").unbind(".resizable").find(".ui-resizable-handle").remove();
2501                         };
2502
2503                 //TODO: Unwrap at same DOM position
2504                 if (this.elementIsWrapper) {
2505                         _destroy(this.element);
2506                         wrapper = this.element;
2507                         this.originalElement.css({
2508                                 position: wrapper.css("position"),
2509                                 width: wrapper.outerWidth(),
2510                                 height: wrapper.outerHeight(),
2511                                 top: wrapper.css("top"),
2512                                 left: wrapper.css("left")
2513                         }).insertAfter( wrapper );
2514                         wrapper.remove();
2515                 }
2516
2517                 this.originalElement.css("resize", this.originalResizeStyle);
2518                 _destroy(this.originalElement);
2519
2520                 return this;
2521         },
2522
2523         _mouseCapture: function(event) {
2524                 var i, handle,
2525                         capture = false;
2526
2527                 for (i in this.handles) {
2528                         handle = $(this.handles[i])[0];
2529                         if (handle === event.target || $.contains(handle, event.target)) {
2530                                 capture = true;
2531                         }
2532                 }
2533
2534                 return !this.options.disabled && capture;
2535         },
2536
2537         _mouseStart: function(event) {
2538
2539                 var curleft, curtop, cursor,
2540                         o = this.options,
2541                         iniPos = this.element.position(),
2542                         el = this.element;
2543
2544                 this.resizing = true;
2545
2546                 // bugfix for http://dev.jquery.com/ticket/1749
2547                 if ( (/absolute/).test( el.css("position") ) ) {
2548                         el.css({ position: "absolute", top: el.css("top"), left: el.css("left") });
2549                 } else if (el.is(".ui-draggable")) {
2550                         el.css({ position: "absolute", top: iniPos.top, left: iniPos.left });
2551                 }
2552
2553                 this._renderProxy();
2554
2555                 curleft = num(this.helper.css("left"));
2556                 curtop = num(this.helper.css("top"));
2557
2558                 if (o.containment) {
2559                         curleft += $(o.containment).scrollLeft() || 0;
2560                         curtop += $(o.containment).scrollTop() || 0;
2561                 }
2562
2563                 //Store needed variables
2564                 this.offset = this.helper.offset();
2565                 this.position = { left: curleft, top: curtop };
2566                 this.size = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2567                 this.originalSize = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2568                 this.originalPosition = { left: curleft, top: curtop };
2569                 this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
2570                 this.originalMousePosition = { left: event.pageX, top: event.pageY };
2571
2572                 //Aspect Ratio
2573                 this.aspectRatio = (typeof o.aspectRatio === "number") ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);
2574
2575                 cursor = $(".ui-resizable-" + this.axis).css("cursor");
2576                 $("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
2577
2578                 el.addClass("ui-resizable-resizing");
2579                 this._propagate("start", event);
2580                 return true;
2581         },
2582
2583         _mouseDrag: function(event) {
2584
2585                 //Increase performance, avoid regex
2586                 var data,
2587                         el = this.helper, props = {},
2588                         smp = this.originalMousePosition,
2589                         a = this.axis,
2590                         prevTop = this.position.top,
2591                         prevLeft = this.position.left,
2592                         prevWidth = this.size.width,
2593                         prevHeight = this.size.height,
2594                         dx = (event.pageX-smp.left)||0,
2595                         dy = (event.pageY-smp.top)||0,
2596                         trigger = this._change[a];
2597
2598                 if (!trigger) {
2599                         return false;
2600                 }
2601
2602                 // Calculate the attrs that will be change
2603                 data = trigger.apply(this, [event, dx, dy]);
2604
2605                 // Put this in the mouseDrag handler since the user can start pressing shift while resizing
2606                 this._updateVirtualBoundaries(event.shiftKey);
2607                 if (this._aspectRatio || event.shiftKey) {
2608                         data = this._updateRatio(data, event);
2609                 }
2610
2611                 data = this._respectSize(data, event);
2612
2613                 this._updateCache(data);
2614
2615                 // plugins callbacks need to be called first
2616                 this._propagate("resize", event);
2617
2618                 if (this.position.top !== prevTop) {
2619                         props.top = this.position.top + "px";
2620                 }
2621                 if (this.position.left !== prevLeft) {
2622                         props.left = this.position.left + "px";
2623                 }
2624                 if (this.size.width !== prevWidth) {
2625                         props.width = this.size.width + "px";
2626                 }
2627                 if (this.size.height !== prevHeight) {
2628                         props.height = this.size.height + "px";
2629                 }
2630                 el.css(props);
2631
2632                 if (!this._helper && this._proportionallyResizeElements.length) {
2633                         this._proportionallyResize();
2634                 }
2635
2636                 // Call the user callback if the element was resized
2637                 if ( ! $.isEmptyObject(props) ) {
2638                         this._trigger("resize", event, this.ui());
2639                 }
2640
2641                 return false;
2642         },
2643
2644         _mouseStop: function(event) {
2645
2646                 this.resizing = false;
2647                 var pr, ista, soffseth, soffsetw, s, left, top,
2648                         o = this.options, that = this;
2649
2650                 if(this._helper) {
2651
2652                         pr = this._proportionallyResizeElements;
2653                         ista = pr.length && (/textarea/i).test(pr[0].nodeName);
2654                         soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height;
2655                         soffsetw = ista ? 0 : that.sizeDiff.width;
2656
2657                         s = { width: (that.helper.width()  - soffsetw), height: (that.helper.height() - soffseth) };
2658                         left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null;
2659                         top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2660
2661                         if (!o.animate) {
2662                                 this.element.css($.extend(s, { top: top, left: left }));
2663                         }
2664
2665                         that.helper.height(that.size.height);
2666                         that.helper.width(that.size.width);
2667
2668                         if (this._helper && !o.animate) {
2669                                 this._proportionallyResize();
2670                         }
2671                 }
2672
2673                 $("body").css("cursor", "auto");
2674
2675                 this.element.removeClass("ui-resizable-resizing");
2676
2677                 this._propagate("stop", event);
2678
2679                 if (this._helper) {
2680                         this.helper.remove();
2681                 }
2682
2683                 return false;
2684
2685         },
2686
2687         _updateVirtualBoundaries: function(forceAspectRatio) {
2688                 var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
2689                         o = this.options;
2690
2691                 b = {
2692                         minWidth: isNumber(o.minWidth) ? o.minWidth : 0,
2693                         maxWidth: isNumber(o.maxWidth) ? o.maxWidth : Infinity,
2694                         minHeight: isNumber(o.minHeight) ? o.minHeight : 0,
2695                         maxHeight: isNumber(o.maxHeight) ? o.maxHeight : Infinity
2696                 };
2697
2698                 if(this._aspectRatio || forceAspectRatio) {
2699                         // We want to create an enclosing box whose aspect ration is the requested one
2700                         // First, compute the "projected" size for each dimension based on the aspect ratio and other dimension
2701                         pMinWidth = b.minHeight * this.aspectRatio;
2702                         pMinHeight = b.minWidth / this.aspectRatio;
2703                         pMaxWidth = b.maxHeight * this.aspectRatio;
2704                         pMaxHeight = b.maxWidth / this.aspectRatio;
2705
2706                         if(pMinWidth > b.minWidth) {
2707                                 b.minWidth = pMinWidth;
2708                         }
2709                         if(pMinHeight > b.minHeight) {
2710                                 b.minHeight = pMinHeight;
2711                         }
2712                         if(pMaxWidth < b.maxWidth) {
2713                                 b.maxWidth = pMaxWidth;
2714                         }
2715                         if(pMaxHeight < b.maxHeight) {
2716                                 b.maxHeight = pMaxHeight;
2717                         }
2718                 }
2719                 this._vBoundaries = b;
2720         },
2721
2722         _updateCache: function(data) {
2723                 this.offset = this.helper.offset();
2724                 if (isNumber(data.left)) {
2725                         this.position.left = data.left;
2726                 }
2727                 if (isNumber(data.top)) {
2728                         this.position.top = data.top;
2729                 }
2730                 if (isNumber(data.height)) {
2731                         this.size.height = data.height;
2732                 }
2733                 if (isNumber(data.width)) {
2734                         this.size.width = data.width;
2735                 }
2736         },
2737
2738         _updateRatio: function( data ) {
2739
2740                 var cpos = this.position,
2741                         csize = this.size,
2742                         a = this.axis;
2743
2744                 if (isNumber(data.height)) {
2745                         data.width = (data.height * this.aspectRatio);
2746                 } else if (isNumber(data.width)) {
2747                         data.height = (data.width / this.aspectRatio);
2748                 }
2749
2750                 if (a === "sw") {
2751                         data.left = cpos.left + (csize.width - data.width);
2752                         data.top = null;
2753                 }
2754                 if (a === "nw") {
2755                         data.top = cpos.top + (csize.height - data.height);
2756                         data.left = cpos.left + (csize.width - data.width);
2757                 }
2758
2759                 return data;
2760         },
2761
2762         _respectSize: function( data ) {
2763
2764                 var o = this._vBoundaries,
2765                         a = this.axis,
2766                         ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
2767                         isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
2768                         dw = this.originalPosition.left + this.originalSize.width,
2769                         dh = this.position.top + this.size.height,
2770                         cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
2771                 if (isminw) {
2772                         data.width = o.minWidth;
2773                 }
2774                 if (isminh) {
2775                         data.height = o.minHeight;
2776                 }
2777                 if (ismaxw) {
2778                         data.width = o.maxWidth;
2779                 }
2780                 if (ismaxh) {
2781                         data.height = o.maxHeight;
2782                 }
2783
2784                 if (isminw && cw) {
2785                         data.left = dw - o.minWidth;
2786                 }
2787                 if (ismaxw && cw) {
2788                         data.left = dw - o.maxWidth;
2789                 }
2790                 if (isminh && ch) {
2791                         data.top = dh - o.minHeight;
2792                 }
2793                 if (ismaxh && ch) {
2794                         data.top = dh - o.maxHeight;
2795                 }
2796
2797                 // fixing jump error on top/left - bug #2330
2798                 if (!data.width && !data.height && !data.left && data.top) {
2799                         data.top = null;
2800                 } else if (!data.width && !data.height && !data.top && data.left) {
2801                         data.left = null;
2802                 }
2803
2804                 return data;
2805         },
2806
2807         _proportionallyResize: function() {
2808
2809                 if (!this._proportionallyResizeElements.length) {
2810                         return;
2811                 }
2812
2813                 var i, j, borders, paddings, prel,
2814                         element = this.helper || this.element;
2815
2816                 for ( i=0; i < this._proportionallyResizeElements.length; i++) {
2817
2818                         prel = this._proportionallyResizeElements[i];
2819
2820                         if (!this.borderDif) {
2821                                 this.borderDif = [];
2822                                 borders = [prel.css("borderTopWidth"), prel.css("borderRightWidth"), prel.css("borderBottomWidth"), prel.css("borderLeftWidth")];
2823                                 paddings = [prel.css("paddingTop"), prel.css("paddingRight"), prel.css("paddingBottom"), prel.css("paddingLeft")];
2824
2825                                 for ( j = 0; j < borders.length; j++ ) {
2826                                         this.borderDif[ j ] = ( parseInt( borders[ j ], 10 ) || 0 ) + ( parseInt( paddings[ j ], 10 ) || 0 );
2827                                 }
2828                         }
2829
2830                         prel.css({
2831                                 height: (element.height() - this.borderDif[0] - this.borderDif[2]) || 0,
2832                                 width: (element.width() - this.borderDif[1] - this.borderDif[3]) || 0
2833                         });
2834
2835                 }
2836
2837         },
2838
2839         _renderProxy: function() {
2840
2841                 var el = this.element, o = this.options;
2842                 this.elementOffset = el.offset();
2843
2844                 if(this._helper) {
2845
2846                         this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
2847
2848                         this.helper.addClass(this._helper).css({
2849                                 width: this.element.outerWidth() - 1,
2850                                 height: this.element.outerHeight() - 1,
2851                                 position: "absolute",
2852                                 left: this.elementOffset.left +"px",
2853                                 top: this.elementOffset.top +"px",
2854                                 zIndex: ++o.zIndex //TODO: Don't modify option
2855                         });
2856
2857                         this.helper
2858                                 .appendTo("body")
2859                                 .disableSelection();
2860
2861                 } else {
2862                         this.helper = this.element;
2863                 }
2864
2865         },
2866
2867         _change: {
2868                 e: function(event, dx) {
2869                         return { width: this.originalSize.width + dx };
2870                 },
2871                 w: function(event, dx) {
2872                         var cs = this.originalSize, sp = this.originalPosition;
2873                         return { left: sp.left + dx, width: cs.width - dx };
2874                 },
2875                 n: function(event, dx, dy) {
2876                         var cs = this.originalSize, sp = this.originalPosition;
2877                         return { top: sp.top + dy, height: cs.height - dy };
2878                 },
2879                 s: function(event, dx, dy) {
2880                         return { height: this.originalSize.height + dy };
2881                 },
2882                 se: function(event, dx, dy) {
2883                         return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2884                 },
2885                 sw: function(event, dx, dy) {
2886                         return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2887                 },
2888                 ne: function(event, dx, dy) {
2889                         return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2890                 },
2891                 nw: function(event, dx, dy) {
2892                         return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2893                 }
2894         },
2895
2896         _propagate: function(n, event) {
2897                 $.ui.plugin.call(this, n, [event, this.ui()]);
2898                 (n !== "resize" && this._trigger(n, event, this.ui()));
2899         },
2900
2901         plugins: {},
2902
2903         ui: function() {
2904                 return {
2905                         originalElement: this.originalElement,
2906                         element: this.element,
2907                         helper: this.helper,
2908                         position: this.position,
2909                         size: this.size,
2910                         originalSize: this.originalSize,
2911                         originalPosition: this.originalPosition
2912                 };
2913         }
2914
2915 });
2916
2917 /*
2918  * Resizable Extensions
2919  */
2920
2921 $.ui.plugin.add("resizable", "animate", {
2922
2923         stop: function( event ) {
2924                 var that = $(this).data("ui-resizable"),
2925                         o = that.options,
2926                         pr = that._proportionallyResizeElements,
2927                         ista = pr.length && (/textarea/i).test(pr[0].nodeName),
2928                         soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height,
2929                         soffsetw = ista ? 0 : that.sizeDiff.width,
2930                         style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
2931                         left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null,
2932                         top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2933
2934                 that.element.animate(
2935                         $.extend(style, top && left ? { top: top, left: left } : {}), {
2936                                 duration: o.animateDuration,
2937                                 easing: o.animateEasing,
2938                                 step: function() {
2939
2940                                         var data = {
2941                                                 width: parseInt(that.element.css("width"), 10),
2942                                                 height: parseInt(that.element.css("height"), 10),
2943                                                 top: parseInt(that.element.css("top"), 10),
2944                                                 left: parseInt(that.element.css("left"), 10)
2945                                         };
2946
2947                                         if (pr && pr.length) {
2948                                                 $(pr[0]).css({ width: data.width, height: data.height });
2949                                         }
2950
2951                                         // propagating resize, and updating values for each animation step
2952                                         that._updateCache(data);
2953                                         that._propagate("resize", event);
2954
2955                                 }
2956                         }
2957                 );
2958         }
2959
2960 });
2961
2962 $.ui.plugin.add("resizable", "containment", {
2963
2964         start: function() {
2965                 var element, p, co, ch, cw, width, height,
2966                         that = $(this).data("ui-resizable"),
2967                         o = that.options,
2968                         el = that.element,
2969                         oc = o.containment,
2970                         ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
2971
2972                 if (!ce) {
2973                         return;
2974                 }
2975
2976                 that.containerElement = $(ce);
2977
2978                 if (/document/.test(oc) || oc === document) {
2979                         that.containerOffset = { left: 0, top: 0 };
2980                         that.containerPosition = { left: 0, top: 0 };
2981
2982                         that.parentData = {
2983                                 element: $(document), left: 0, top: 0,
2984                                 width: $(document).width(), height: $(document).height() || document.body.parentNode.scrollHeight
2985                         };
2986                 }
2987
2988                 // i'm a node, so compute top, left, right, bottom
2989                 else {
2990                         element = $(ce);
2991                         p = [];
2992                         $([ "Top", "Right", "Left", "Bottom" ]).each(function(i, name) { p[i] = num(element.css("padding" + name)); });
2993
2994                         that.containerOffset = element.offset();
2995                         that.containerPosition = element.position();
2996                         that.containerSize = { height: (element.innerHeight() - p[3]), width: (element.innerWidth() - p[1]) };
2997
2998                         co = that.containerOffset;
2999                         ch = that.containerSize.height;
3000                         cw = that.containerSize.width;
3001                         width = ($.ui.hasScroll(ce, "left") ? ce.scrollWidth : cw );
3002                         height = ($.ui.hasScroll(ce) ? ce.scrollHeight : ch);
3003
3004                         that.parentData = {
3005                                 element: ce, left: co.left, top: co.top, width: width, height: height
3006                         };
3007                 }
3008         },
3009
3010         resize: function( event ) {
3011                 var woset, hoset, isParent, isOffsetRelative,
3012                         that = $(this).data("ui-resizable"),
3013                         o = that.options,
3014                         co = that.containerOffset, cp = that.position,
3015                         pRatio = that._aspectRatio || event.shiftKey,
3016                         cop = { top:0, left:0 }, ce = that.containerElement;
3017
3018                 if (ce[0] !== document && (/static/).test(ce.css("position"))) {
3019                         cop = co;
3020                 }
3021
3022                 if (cp.left < (that._helper ? co.left : 0)) {
3023                         that.size.width = that.size.width + (that._helper ? (that.position.left - co.left) : (that.position.left - cop.left));
3024                         if (pRatio) {
3025                                 that.size.height = that.size.width / that.aspectRatio;
3026                         }
3027                         that.position.left = o.helper ? co.left : 0;
3028                 }
3029
3030                 if (cp.top < (that._helper ? co.top : 0)) {
3031                         that.size.height = that.size.height + (that._helper ? (that.position.top - co.top) : that.position.top);
3032                         if (pRatio) {
3033                                 that.size.width = that.size.height * that.aspectRatio;
3034                         }
3035                         that.position.top = that._helper ? co.top : 0;
3036                 }
3037
3038                 that.offset.left = that.parentData.left+that.position.left;
3039                 that.offset.top = that.parentData.top+that.position.top;
3040
3041                 woset = Math.abs( (that._helper ? that.offset.left - cop.left : (that.offset.left - cop.left)) + that.sizeDiff.width );
3042                 hoset = Math.abs( (that._helper ? that.offset.top - cop.top : (that.offset.top - co.top)) + that.sizeDiff.height );
3043
3044                 isParent = that.containerElement.get(0) === that.element.parent().get(0);
3045                 isOffsetRelative = /relative|absolute/.test(that.containerElement.css("position"));
3046
3047                 if(isParent && isOffsetRelative) {
3048                         woset -= that.parentData.left;
3049                 }
3050
3051                 if (woset + that.size.width >= that.parentData.width) {
3052                         that.size.width = that.parentData.width - woset;
3053                         if (pRatio) {
3054                                 that.size.height = that.size.width / that.aspectRatio;
3055                         }
3056                 }
3057
3058                 if (hoset + that.size.height >= that.parentData.height) {
3059                         that.size.height = that.parentData.height - hoset;
3060                         if (pRatio) {
3061                                 that.size.width = that.size.height * that.aspectRatio;
3062                         }
3063                 }
3064         },
3065
3066         stop: function(){
3067                 var that = $(this).data("ui-resizable"),
3068                         o = that.options,
3069                         co = that.containerOffset,
3070                         cop = that.containerPosition,
3071                         ce = that.containerElement,
3072                         helper = $(that.helper),
3073                         ho = helper.offset(),
3074                         w = helper.outerWidth() - that.sizeDiff.width,
3075                         h = helper.outerHeight() - that.sizeDiff.height;
3076
3077                 if (that._helper && !o.animate && (/relative/).test(ce.css("position"))) {
3078                         $(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
3079                 }
3080
3081                 if (that._helper && !o.animate && (/static/).test(ce.css("position"))) {
3082                         $(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
3083                 }
3084
3085         }
3086 });
3087
3088 $.ui.plugin.add("resizable", "alsoResize", {
3089
3090         start: function () {
3091                 var that = $(this).data("ui-resizable"),
3092                         o = that.options,
3093                         _store = function (exp) {
3094                                 $(exp).each(function() {
3095                                         var el = $(this);
3096                                         el.data("ui-resizable-alsoresize", {
3097                                                 width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
3098                                                 left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10)
3099                                         });
3100                                 });
3101                         };
3102
3103                 if (typeof(o.alsoResize) === "object" && !o.alsoResize.parentNode) {
3104                         if (o.alsoResize.length) { o.alsoResize = o.alsoResize[0]; _store(o.alsoResize); }
3105                         else { $.each(o.alsoResize, function (exp) { _store(exp); }); }
3106                 }else{
3107                         _store(o.alsoResize);
3108                 }
3109         },
3110
3111         resize: function (event, ui) {
3112                 var that = $(this).data("ui-resizable"),
3113                         o = that.options,
3114                         os = that.originalSize,
3115                         op = that.originalPosition,
3116                         delta = {
3117                                 height: (that.size.height - os.height) || 0, width: (that.size.width - os.width) || 0,
3118                                 top: (that.position.top - op.top) || 0, left: (that.position.left - op.left) || 0
3119                         },
3120
3121                         _alsoResize = function (exp, c) {
3122                                 $(exp).each(function() {
3123                                         var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
3124                                                 css = c && c.length ? c : el.parents(ui.originalElement[0]).length ? ["width", "height"] : ["width", "height", "top", "left"];
3125
3126                                         $.each(css, function (i, prop) {
3127                                                 var sum = (start[prop]||0) + (delta[prop]||0);
3128                                                 if (sum && sum >= 0) {
3129                                                         style[prop] = sum || null;
3130                                                 }
3131                                         });
3132
3133                                         el.css(style);
3134                                 });
3135                         };
3136
3137                 if (typeof(o.alsoResize) === "object" && !o.alsoResize.nodeType) {
3138                         $.each(o.alsoResize, function (exp, c) { _alsoResize(exp, c); });
3139                 }else{
3140                         _alsoResize(o.alsoResize);
3141                 }
3142         },
3143
3144         stop: function () {
3145                 $(this).removeData("resizable-alsoresize");
3146         }
3147 });
3148
3149 $.ui.plugin.add("resizable", "ghost", {
3150
3151         start: function() {
3152
3153                 var that = $(this).data("ui-resizable"), o = that.options, cs = that.size;
3154
3155                 that.ghost = that.originalElement.clone();
3156                 that.ghost
3157                         .css({ opacity: 0.25, display: "block", position: "relative", height: cs.height, width: cs.width, margin: 0, left: 0, top: 0 })
3158                         .addClass("ui-resizable-ghost")
3159                         .addClass(typeof o.ghost === "string" ? o.ghost : "");
3160
3161                 that.ghost.appendTo(that.helper);
3162
3163         },
3164
3165         resize: function(){
3166                 var that = $(this).data("ui-resizable");
3167                 if (that.ghost) {
3168                         that.ghost.css({ position: "relative", height: that.size.height, width: that.size.width });
3169                 }
3170         },
3171
3172         stop: function() {
3173                 var that = $(this).data("ui-resizable");
3174                 if (that.ghost && that.helper) {
3175                         that.helper.get(0).removeChild(that.ghost.get(0));
3176                 }
3177         }
3178
3179 });
3180
3181 $.ui.plugin.add("resizable", "grid", {
3182
3183         resize: function() {
3184                 var that = $(this).data("ui-resizable"),
3185                         o = that.options,
3186                         cs = that.size,
3187                         os = that.originalSize,
3188                         op = that.originalPosition,
3189                         a = that.axis,
3190                         grid = typeof o.grid === "number" ? [o.grid, o.grid] : o.grid,
3191                         gridX = (grid[0]||1),
3192                         gridY = (grid[1]||1),
3193                         ox = Math.round((cs.width - os.width) / gridX) * gridX,
3194                         oy = Math.round((cs.height - os.height) / gridY) * gridY,
3195                         newWidth = os.width + ox,
3196                         newHeight = os.height + oy,
3197                         isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
3198                         isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
3199                         isMinWidth = o.minWidth && (o.minWidth > newWidth),
3200                         isMinHeight = o.minHeight && (o.minHeight > newHeight);
3201
3202                 o.grid = grid;
3203
3204                 if (isMinWidth) {
3205                         newWidth = newWidth + gridX;
3206                 }
3207                 if (isMinHeight) {
3208                         newHeight = newHeight + gridY;
3209                 }
3210                 if (isMaxWidth) {
3211                         newWidth = newWidth - gridX;
3212                 }
3213                 if (isMaxHeight) {
3214                         newHeight = newHeight - gridY;
3215                 }
3216
3217                 if (/^(se|s|e)$/.test(a)) {
3218                         that.size.width = newWidth;
3219                         that.size.height = newHeight;
3220                 } else if (/^(ne)$/.test(a)) {
3221                         that.size.width = newWidth;
3222                         that.size.height = newHeight;
3223                         that.position.top = op.top - oy;
3224                 } else if (/^(sw)$/.test(a)) {
3225                         that.size.width = newWidth;
3226                         that.size.height = newHeight;
3227                         that.position.left = op.left - ox;
3228                 } else {
3229                         that.size.width = newWidth;
3230                         that.size.height = newHeight;
3231                         that.position.top = op.top - oy;
3232                         that.position.left = op.left - ox;
3233                 }
3234         }
3235
3236 });
3237
3238 })(jQuery);
3239
3240 (function( $, undefined ) {
3241
3242 $.widget("ui.selectable", $.ui.mouse, {
3243         version: "1.10.3",
3244         options: {
3245                 appendTo: "body",
3246                 autoRefresh: true,
3247                 distance: 0,
3248                 filter: "*",
3249                 tolerance: "touch",
3250
3251                 // callbacks
3252                 selected: null,
3253                 selecting: null,
3254                 start: null,
3255                 stop: null,
3256                 unselected: null,
3257                 unselecting: null
3258         },
3259         _create: function() {
3260                 var selectees,
3261                         that = this;
3262
3263                 this.element.addClass("ui-selectable");
3264
3265                 this.dragged = false;
3266
3267                 // cache selectee children based on filter
3268                 this.refresh = function() {
3269                         selectees = $(that.options.filter, that.element[0]);
3270                         selectees.addClass("ui-selectee");
3271                         selectees.each(function() {
3272                                 var $this = $(this),
3273                                         pos = $this.offset();
3274                                 $.data(this, "selectable-item", {
3275                                         element: this,
3276                                         $element: $this,
3277                                         left: pos.left,
3278                                         top: pos.top,
3279                                         right: pos.left + $this.outerWidth(),
3280                                         bottom: pos.top + $this.outerHeight(),
3281                                         startselected: false,
3282                                         selected: $this.hasClass("ui-selected"),
3283                                         selecting: $this.hasClass("ui-selecting"),
3284                                         unselecting: $this.hasClass("ui-unselecting")
3285                                 });
3286                         });
3287                 };
3288                 this.refresh();
3289
3290                 this.selectees = selectees.addClass("ui-selectee");
3291
3292                 this._mouseInit();
3293
3294                 this.helper = $("<div class='ui-selectable-helper'></div>");
3295         },
3296
3297         _destroy: function() {
3298                 this.selectees
3299                         .removeClass("ui-selectee")
3300                         .removeData("selectable-item");
3301                 this.element
3302                         .removeClass("ui-selectable ui-selectable-disabled");
3303                 this._mouseDestroy();
3304         },
3305
3306         _mouseStart: function(event) {
3307                 var that = this,
3308                         options = this.options;
3309
3310                 this.opos = [event.pageX, event.pageY];
3311
3312                 if (this.options.disabled) {
3313                         return;
3314                 }
3315
3316                 this.selectees = $(options.filter, this.element[0]);
3317
3318                 this._trigger("start", event);
3319
3320                 $(options.appendTo).append(this.helper);
3321                 // position helper (lasso)
3322                 this.helper.css({
3323                         "left": event.pageX,
3324                         "top": event.pageY,
3325                         "width": 0,
3326                         "height": 0
3327                 });
3328
3329                 if (options.autoRefresh) {
3330                         this.refresh();
3331                 }
3332
3333                 this.selectees.filter(".ui-selected").each(function() {
3334                         var selectee = $.data(this, "selectable-item");
3335                         selectee.startselected = true;
3336                         if (!event.metaKey && !event.ctrlKey) {
3337                                 selectee.$element.removeClass("ui-selected");
3338                                 selectee.selected = false;
3339                                 selectee.$element.addClass("ui-unselecting");
3340                                 selectee.unselecting = true;
3341                                 // selectable UNSELECTING callback
3342                                 that._trigger("unselecting", event, {
3343                                         unselecting: selectee.element
3344                                 });
3345                         }
3346                 });
3347
3348                 $(event.target).parents().addBack().each(function() {
3349                         var doSelect,
3350                                 selectee = $.data(this, "selectable-item");
3351                         if (selectee) {
3352                                 doSelect = (!event.metaKey && !event.ctrlKey) || !selectee.$element.hasClass("ui-selected");
3353                                 selectee.$element
3354                                         .removeClass(doSelect ? "ui-unselecting" : "ui-selected")
3355                                         .addClass(doSelect ? "ui-selecting" : "ui-unselecting");
3356                                 selectee.unselecting = !doSelect;
3357                                 selectee.selecting = doSelect;
3358                                 selectee.selected = doSelect;
3359                                 // selectable (UN)SELECTING callback
3360                                 if (doSelect) {
3361                                         that._trigger("selecting", event, {
3362                                                 selecting: selectee.element
3363                                         });
3364                                 } else {
3365                                         that._trigger("unselecting", event, {
3366                                                 unselecting: selectee.element
3367                                         });
3368                                 }
3369                                 return false;
3370                         }
3371                 });
3372
3373         },
3374
3375         _mouseDrag: function(event) {
3376
3377                 this.dragged = true;
3378
3379                 if (this.options.disabled) {
3380                         return;
3381                 }
3382
3383                 var tmp,
3384                         that = this,
3385                         options = this.options,
3386                         x1 = this.opos[0],
3387                         y1 = this.opos[1],
3388                         x2 = event.pageX,
3389                         y2 = event.pageY;
3390
3391                 if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
3392                 if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
3393                 this.helper.css({left: x1, top: y1, width: x2-x1, height: y2-y1});
3394
3395                 this.selectees.each(function() {
3396                         var selectee = $.data(this, "selectable-item"),
3397                                 hit = false;
3398
3399                         //prevent helper from being selected if appendTo: selectable
3400                         if (!selectee || selectee.element === that.element[0]) {
3401                                 return;
3402                         }
3403
3404                         if (options.tolerance === "touch") {
3405                                 hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
3406                         } else if (options.tolerance === "fit") {
3407                                 hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
3408                         }
3409
3410                         if (hit) {
3411                                 // SELECT
3412                                 if (selectee.selected) {
3413                                         selectee.$element.removeClass("ui-selected");
3414                                         selectee.selected = false;
3415                                 }
3416                                 if (selectee.unselecting) {
3417                                         selectee.$element.removeClass("ui-unselecting");
3418                                         selectee.unselecting = false;
3419                                 }
3420                                 if (!selectee.selecting) {
3421                                         selectee.$element.addClass("ui-selecting");
3422                                         selectee.selecting = true;
3423                                         // selectable SELECTING callback
3424                                         that._trigger("selecting", event, {
3425                                                 selecting: selectee.element
3426                                         });
3427                                 }
3428                         } else {
3429                                 // UNSELECT
3430                                 if (selectee.selecting) {
3431                                         if ((event.metaKey || event.ctrlKey) && selectee.startselected) {
3432                                                 selectee.$element.removeClass("ui-selecting");
3433                                                 selectee.selecting = false;
3434                                                 selectee.$element.addClass("ui-selected");
3435                                                 selectee.selected = true;
3436                                         } else {
3437                                                 selectee.$element.removeClass("ui-selecting");
3438                                                 selectee.selecting = false;
3439                                                 if (selectee.startselected) {
3440                                                         selectee.$element.addClass("ui-unselecting");
3441                                                         selectee.unselecting = true;
3442                                                 }
3443                                                 // selectable UNSELECTING callback
3444                                                 that._trigger("unselecting", event, {
3445                                                         unselecting: selectee.element
3446                                                 });
3447                                         }
3448                                 }
3449                                 if (selectee.selected) {
3450                                         if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
3451                                                 selectee.$element.removeClass("ui-selected");
3452                                                 selectee.selected = false;
3453
3454                                                 selectee.$element.addClass("ui-unselecting");
3455                                                 selectee.unselecting = true;
3456                                                 // selectable UNSELECTING callback
3457                                                 that._trigger("unselecting", event, {
3458                                                         unselecting: selectee.element
3459                                                 });
3460                                         }
3461                                 }
3462                         }
3463                 });
3464
3465                 return false;
3466         },
3467
3468         _mouseStop: function(event) {
3469                 var that = this;
3470
3471                 this.dragged = false;
3472
3473                 $(".ui-unselecting", this.element[0]).each(function() {
3474                         var selectee = $.data(this, "selectable-item");
3475                         selectee.$element.removeClass("ui-unselecting");
3476                         selectee.unselecting = false;
3477                         selectee.startselected = false;
3478                         that._trigger("unselected", event, {
3479                                 unselected: selectee.element
3480                         });
3481                 });
3482                 $(".ui-selecting", this.element[0]).each(function() {
3483                         var selectee = $.data(this, "selectable-item");
3484                         selectee.$element.removeClass("ui-selecting").addClass("ui-selected");
3485                         selectee.selecting = false;
3486                         selectee.selected = true;
3487                         selectee.startselected = true;
3488                         that._trigger("selected", event, {
3489                                 selected: selectee.element
3490                         });
3491                 });
3492                 this._trigger("stop", event);
3493
3494                 this.helper.remove();
3495
3496                 return false;
3497         }
3498
3499 });
3500
3501 })(jQuery);
3502
3503 (function( $, undefined ) {
3504
3505 /*jshint loopfunc: true */
3506
3507 function isOverAxis( x, reference, size ) {
3508         return ( x > reference ) && ( x < ( reference + size ) );
3509 }
3510
3511 function isFloating(item) {
3512         return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
3513 }
3514
3515 $.widget("ui.sortable", $.ui.mouse, {
3516         version: "1.10.3",
3517         widgetEventPrefix: "sort",
3518         ready: false,
3519         options: {
3520                 appendTo: "parent",
3521                 axis: false,
3522                 connectWith: false,
3523                 containment: false,
3524                 cursor: "auto",
3525                 cursorAt: false,
3526                 dropOnEmpty: true,
3527                 forcePlaceholderSize: false,
3528                 forceHelperSize: false,
3529                 grid: false,
3530                 handle: false,
3531                 helper: "original",
3532                 items: "> *",
3533                 opacity: false,
3534                 placeholder: false,
3535                 revert: false,
3536                 scroll: true,
3537                 scrollSensitivity: 20,
3538                 scrollSpeed: 20,
3539                 scope: "default",
3540                 tolerance: "intersect",
3541                 zIndex: 1000,
3542
3543                 // callbacks
3544                 activate: null,
3545                 beforeStop: null,
3546                 change: null,
3547                 deactivate: null,
3548                 out: null,
3549                 over: null,
3550                 receive: null,
3551                 remove: null,
3552                 sort: null,
3553                 start: null,
3554                 stop: null,
3555                 update: null
3556         },
3557         _create: function() {
3558
3559                 var o = this.options;
3560                 this.containerCache = {};
3561                 this.element.addClass("ui-sortable");
3562
3563                 //Get the items
3564                 this.refresh();
3565
3566                 //Let's determine if the items are being displayed horizontally
3567                 this.floating = this.items.length ? o.axis === "x" || isFloating(this.items[0].item) : false;
3568
3569                 //Let's determine the parent's offset
3570                 this.offset = this.element.offset();
3571
3572                 //Initialize mouse events for interaction
3573                 this._mouseInit();
3574
3575                 //We're ready to go
3576                 this.ready = true;
3577
3578         },
3579
3580         _destroy: function() {
3581                 this.element
3582                         .removeClass("ui-sortable ui-sortable-disabled");
3583                 this._mouseDestroy();
3584
3585                 for ( var i = this.items.length - 1; i >= 0; i-- ) {
3586                         this.items[i].item.removeData(this.widgetName + "-item");
3587                 }
3588
3589                 return this;
3590         },
3591
3592         _setOption: function(key, value){
3593                 if ( key === "disabled" ) {
3594                         this.options[ key ] = value;
3595
3596                         this.widget().toggleClass( "ui-sortable-disabled", !!value );
3597                 } else {
3598                         // Don't call widget base _setOption for disable as it adds ui-state-disabled class
3599                         $.Widget.prototype._setOption.apply(this, arguments);
3600                 }
3601         },
3602
3603         _mouseCapture: function(event, overrideHandle) {
3604                 var currentItem = null,
3605                         validHandle = false,
3606                         that = this;
3607
3608                 if (this.reverting) {
3609                         return false;
3610                 }
3611
3612                 if(this.options.disabled || this.options.type === "static") {
3613                         return false;
3614                 }
3615
3616                 //We have to refresh the items data once first
3617                 this._refreshItems(event);
3618
3619                 //Find out if the clicked node (or one of its parents) is a actual item in this.items
3620                 $(event.target).parents().each(function() {
3621                         if($.data(this, that.widgetName + "-item") === that) {
3622                                 currentItem = $(this);
3623                                 return false;
3624                         }
3625                 });
3626                 if($.data(event.target, that.widgetName + "-item") === that) {
3627                         currentItem = $(event.target);
3628                 }
3629
3630                 if(!currentItem) {
3631                         return false;
3632                 }
3633                 if(this.options.handle && !overrideHandle) {
3634                         $(this.options.handle, currentItem).find("*").addBack().each(function() {
3635                                 if(this === event.target) {
3636                                         validHandle = true;
3637                                 }
3638                         });
3639                         if(!validHandle) {
3640                                 return false;
3641                         }
3642                 }
3643
3644                 this.currentItem = currentItem;
3645                 this._removeCurrentsFromItems();
3646                 return true;
3647
3648         },
3649
3650         _mouseStart: function(event, overrideHandle, noActivation) {
3651
3652                 var i, body,
3653                         o = this.options;
3654
3655                 this.currentContainer = this;
3656
3657                 //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
3658                 this.refreshPositions();
3659
3660                 //Create and append the visible helper
3661                 this.helper = this._createHelper(event);
3662
3663                 //Cache the helper size
3664                 this._cacheHelperProportions();
3665
3666                 /*
3667                  * - Position generation -
3668                  * This block generates everything position related - it's the core of draggables.
3669                  */
3670
3671                 //Cache the margins of the original element
3672                 this._cacheMargins();
3673
3674                 //Get the next scrolling parent
3675                 this.scrollParent = this.helper.scrollParent();
3676
3677                 //The element's absolute position on the page minus margins
3678                 this.offset = this.currentItem.offset();
3679                 this.offset = {
3680                         top: this.offset.top - this.margins.top,
3681                         left: this.offset.left - this.margins.left
3682                 };
3683
3684                 $.extend(this.offset, {
3685                         click: { //Where the click happened, relative to the element
3686                                 left: event.pageX - this.offset.left,
3687                                 top: event.pageY - this.offset.top
3688                         },
3689                         parent: this._getParentOffset(),
3690                         relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
3691                 });
3692
3693                 // Only after we got the offset, we can change the helper's position to absolute
3694                 // TODO: Still need to figure out a way to make relative sorting possible
3695                 this.helper.css("position", "absolute");
3696                 this.cssPosition = this.helper.css("position");
3697
3698                 //Generate the original position
3699                 this.originalPosition = this._generatePosition(event);
3700                 this.originalPageX = event.pageX;
3701                 this.originalPageY = event.pageY;
3702
3703                 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
3704                 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
3705
3706                 //Cache the former DOM position
3707                 this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
3708
3709                 //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
3710                 if(this.helper[0] !== this.currentItem[0]) {
3711                         this.currentItem.hide();
3712                 }
3713
3714                 //Create the placeholder
3715                 this._createPlaceholder();
3716
3717                 //Set a containment if given in the options
3718                 if(o.containment) {
3719                         this._setContainment();
3720                 }
3721
3722                 if( o.cursor && o.cursor !== "auto" ) { // cursor option
3723                         body = this.document.find( "body" );
3724
3725                         // support: IE
3726                         this.storedCursor = body.css( "cursor" );
3727                         body.css( "cursor", o.cursor );
3728
3729                         this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
3730                 }
3731
3732                 if(o.opacity) { // opacity option
3733                         if (this.helper.css("opacity")) {
3734                                 this._storedOpacity = this.helper.css("opacity");
3735                         }
3736                         this.helper.css("opacity", o.opacity);
3737                 }
3738
3739                 if(o.zIndex) { // zIndex option
3740                         if (this.helper.css("zIndex")) {
3741                                 this._storedZIndex = this.helper.css("zIndex");
3742                         }
3743                         this.helper.css("zIndex", o.zIndex);
3744                 }
3745
3746                 //Prepare scrolling
3747                 if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
3748                         this.overflowOffset = this.scrollParent.offset();
3749                 }
3750
3751                 //Call callbacks
3752                 this._trigger("start", event, this._uiHash());
3753
3754                 //Recache the helper size
3755                 if(!this._preserveHelperProportions) {
3756                         this._cacheHelperProportions();
3757                 }
3758
3759
3760                 //Post "activate" events to possible containers
3761                 if( !noActivation ) {
3762                         for ( i = this.containers.length - 1; i >= 0; i-- ) {
3763                                 this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
3764                         }
3765                 }
3766
3767                 //Prepare possible droppables
3768                 if($.ui.ddmanager) {
3769                         $.ui.ddmanager.current = this;
3770                 }
3771
3772                 if ($.ui.ddmanager && !o.dropBehaviour) {
3773                         $.ui.ddmanager.prepareOffsets(this, event);
3774                 }
3775
3776                 this.dragging = true;
3777
3778                 this.helper.addClass("ui-sortable-helper");
3779                 this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
3780                 return true;
3781
3782         },
3783
3784         _mouseDrag: function(event) {
3785                 var i, item, itemElement, intersection,
3786                         o = this.options,
3787                         scrolled = false;
3788
3789                 //Compute the helpers position
3790                 this.position = this._generatePosition(event);
3791                 this.positionAbs = this._convertPositionTo("absolute");
3792
3793                 if (!this.lastPositionAbs) {
3794                         this.lastPositionAbs = this.positionAbs;
3795                 }
3796
3797                 //Do scrolling
3798                 if(this.options.scroll) {
3799                         if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
3800
3801                                 if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
3802                                         this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
3803                                 } else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
3804                                         this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
3805                                 }
3806
3807                                 if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
3808                                         this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
3809                                 } else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
3810                                         this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
3811                                 }
3812
3813                         } else {
3814
3815                                 if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
3816                                         scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
3817                                 } else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
3818                                         scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
3819                                 }
3820
3821                                 if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
3822                                         scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
3823                                 } else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
3824                                         scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
3825                                 }
3826
3827                         }
3828
3829                         if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
3830                                 $.ui.ddmanager.prepareOffsets(this, event);
3831                         }
3832                 }
3833
3834                 //Regenerate the absolute position used for position checks
3835                 this.positionAbs = this._convertPositionTo("absolute");
3836
3837                 //Set the helper position
3838                 if(!this.options.axis || this.options.axis !== "y") {
3839                         this.helper[0].style.left = this.position.left+"px";
3840                 }
3841                 if(!this.options.axis || this.options.axis !== "x") {
3842                         this.helper[0].style.top = this.position.top+"px";
3843                 }
3844
3845                 //Rearrange
3846                 for (i = this.items.length - 1; i >= 0; i--) {
3847
3848                         //Cache variables and intersection, continue if no intersection
3849                         item = this.items[i];
3850                         itemElement = item.item[0];
3851                         intersection = this._intersectsWithPointer(item);
3852                         if (!intersection) {
3853                                 continue;
3854                         }
3855
3856                         // Only put the placeholder inside the current Container, skip all
3857                         // items form other containers. This works because when moving
3858                         // an item from one container to another the
3859                         // currentContainer is switched before the placeholder is moved.
3860                         //
3861                         // Without this moving items in "sub-sortables" can cause the placeholder to jitter
3862                         // beetween the outer and inner container.
3863                         if (item.instance !== this.currentContainer) {
3864                                 continue;
3865                         }
3866
3867                         // cannot intersect with itself
3868                         // no useless actions that have been done before
3869                         // no action if the item moved is the parent of the item checked
3870                         if (itemElement !== this.currentItem[0] &&
3871                                 this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
3872                                 !$.contains(this.placeholder[0], itemElement) &&
3873                                 (this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
3874                         ) {
3875
3876                                 this.direction = intersection === 1 ? "down" : "up";
3877
3878                                 if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
3879                                         this._rearrange(event, item);
3880                                 } else {
3881                                         break;
3882                                 }
3883
3884                                 this._trigger("change", event, this._uiHash());
3885                                 break;
3886                         }
3887                 }
3888
3889                 //Post events to containers
3890                 this._contactContainers(event);
3891
3892                 //Interconnect with droppables
3893                 if($.ui.ddmanager) {
3894                         $.ui.ddmanager.drag(this, event);
3895                 }
3896
3897                 //Call callbacks
3898                 this._trigger("sort", event, this._uiHash());
3899
3900                 this.lastPositionAbs = this.positionAbs;
3901                 return false;
3902
3903         },
3904
3905         _mouseStop: function(event, noPropagation) {
3906
3907                 if(!event) {
3908                         return;
3909                 }
3910
3911                 //If we are using droppables, inform the manager about the drop
3912                 if ($.ui.ddmanager && !this.options.dropBehaviour) {
3913                         $.ui.ddmanager.drop(this, event);
3914                 }
3915
3916                 if(this.options.revert) {
3917                         var that = this,
3918                                 cur = this.placeholder.offset(),
3919                                 axis = this.options.axis,
3920                                 animation = {};
3921
3922                         if ( !axis || axis === "x" ) {
3923                                 animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollLeft);
3924                         }
3925                         if ( !axis || axis === "y" ) {
3926                                 animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollTop);
3927                         }
3928                         this.reverting = true;
3929                         $(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
3930                                 that._clear(event);
3931                         });
3932                 } else {
3933                         this._clear(event, noPropagation);
3934                 }
3935
3936                 return false;
3937
3938         },
3939
3940         cancel: function() {
3941
3942                 if(this.dragging) {
3943
3944                         this._mouseUp({ target: null });
3945
3946                         if(this.options.helper === "original") {
3947                                 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
3948                         } else {
3949                                 this.currentItem.show();
3950                         }
3951
3952                         //Post deactivating events to containers
3953                         for (var i = this.containers.length - 1; i >= 0; i--){
3954                                 this.containers[i]._trigger("deactivate", null, this._uiHash(this));
3955                                 if(this.containers[i].containerCache.over) {
3956                                         this.containers[i]._trigger("out", null, this._uiHash(this));
3957                                         this.containers[i].containerCache.over = 0;
3958                                 }
3959                         }
3960
3961                 }
3962
3963                 if (this.placeholder) {
3964                         //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
3965                         if(this.placeholder[0].parentNode) {
3966                                 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
3967                         }
3968                         if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
3969                                 this.helper.remove();
3970                         }
3971
3972                         $.extend(this, {
3973                                 helper: null,
3974                                 dragging: false,
3975                                 reverting: false,
3976                                 _noFinalSort: null
3977                         });
3978
3979                         if(this.domPosition.prev) {
3980                                 $(this.domPosition.prev).after(this.currentItem);
3981                         } else {
3982                                 $(this.domPosition.parent).prepend(this.currentItem);
3983                         }
3984                 }
3985
3986                 return this;
3987
3988         },
3989
3990         serialize: function(o) {
3991
3992                 var items = this._getItemsAsjQuery(o && o.connected),
3993                         str = [];
3994                 o = o || {};
3995
3996                 $(items).each(function() {
3997                         var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
3998                         if (res) {
3999                                 str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
4000                         }
4001                 });
4002
4003                 if(!str.length && o.key) {
4004                         str.push(o.key + "=");
4005                 }
4006
4007                 return str.join("&");
4008
4009         },
4010
4011         toArray: function(o) {
4012
4013                 var items = this._getItemsAsjQuery(o && o.connected),
4014                         ret = [];
4015
4016                 o = o || {};
4017
4018                 items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
4019                 return ret;
4020
4021         },
4022
4023         /* Be careful with the following core functions */
4024         _intersectsWith: function(item) {
4025
4026                 var x1 = this.positionAbs.left,
4027                         x2 = x1 + this.helperProportions.width,
4028                         y1 = this.positionAbs.top,
4029                         y2 = y1 + this.helperProportions.height,
4030                         l = item.left,
4031                         r = l + item.width,
4032                         t = item.top,
4033                         b = t + item.height,
4034                         dyClick = this.offset.click.top,
4035                         dxClick = this.offset.click.left,
4036                         isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
4037                         isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
4038                         isOverElement = isOverElementHeight && isOverElementWidth;
4039
4040                 if ( this.options.tolerance === "pointer" ||
4041                         this.options.forcePointerForContainers ||
4042                         (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
4043                 ) {
4044                         return isOverElement;
4045                 } else {
4046
4047                         return (l < x1 + (this.helperProportions.width / 2) && // Right Half
4048                                 x2 - (this.helperProportions.width / 2) < r && // Left Half
4049                                 t < y1 + (this.helperProportions.height / 2) && // Bottom Half
4050                                 y2 - (this.helperProportions.height / 2) < b ); // Top Half
4051
4052                 }
4053         },
4054
4055         _intersectsWithPointer: function(item) {
4056
4057                 var isOverElementHeight = (this.options.axis === "x") || isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
4058                         isOverElementWidth = (this.options.axis === "y") || isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
4059                         isOverElement = isOverElementHeight && isOverElementWidth,
4060                         verticalDirection = this._getDragVerticalDirection(),
4061                         horizontalDirection = this._getDragHorizontalDirection();
4062
4063                 if (!isOverElement) {
4064                         return false;
4065                 }
4066
4067                 return this.floating ?
4068                         ( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
4069                         : ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
4070
4071         },
4072
4073         _intersectsWithSides: function(item) {
4074
4075                 var isOverBottomHalf = isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
4076                         isOverRightHalf = isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
4077                         verticalDirection = this._getDragVerticalDirection(),
4078                         horizontalDirection = this._getDragHorizontalDirection();
4079
4080                 if (this.floating && horizontalDirection) {
4081                         return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
4082                 } else {
4083                         return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
4084                 }
4085
4086         },
4087
4088         _getDragVerticalDirection: function() {
4089                 var delta = this.positionAbs.top - this.lastPositionAbs.top;
4090                 return delta !== 0 && (delta > 0 ? "down" : "up");
4091         },
4092
4093         _getDragHorizontalDirection: function() {
4094                 var delta = this.positionAbs.left - this.lastPositionAbs.left;
4095                 return delta !== 0 && (delta > 0 ? "right" : "left");
4096         },
4097
4098         refresh: function(event) {
4099                 this._refreshItems(event);
4100                 this.refreshPositions();
4101                 return this;
4102         },
4103
4104         _connectWith: function() {
4105                 var options = this.options;
4106                 return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
4107         },
4108
4109         _getItemsAsjQuery: function(connected) {
4110
4111                 var i, j, cur, inst,
4112                         items = [],
4113                         queries = [],
4114                         connectWith = this._connectWith();
4115
4116                 if(connectWith && connected) {
4117                         for (i = connectWith.length - 1; i >= 0; i--){
4118                                 cur = $(connectWith[i]);
4119                                 for ( j = cur.length - 1; j >= 0; j--){
4120                                         inst = $.data(cur[j], this.widgetFullName);
4121                                         if(inst && inst !== this && !inst.options.disabled) {
4122                                                 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]);
4123                                         }
4124                                 }
4125                         }
4126                 }
4127
4128                 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]);
4129
4130                 for (i = queries.length - 1; i >= 0; i--){
4131                         queries[i][0].each(function() {
4132                                 items.push(this);
4133                         });
4134                 }
4135
4136                 return $(items);
4137
4138         },
4139
4140         _removeCurrentsFromItems: function() {
4141
4142                 var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
4143
4144                 this.items = $.grep(this.items, function (item) {
4145                         for (var j=0; j < list.length; j++) {
4146                                 if(list[j] === item.item[0]) {
4147                                         return false;
4148                                 }
4149                         }
4150                         return true;
4151                 });
4152
4153         },
4154
4155         _refreshItems: function(event) {
4156
4157                 this.items = [];
4158                 this.containers = [this];
4159
4160                 var i, j, cur, inst, targetData, _queries, item, queriesLength,
4161                         items = this.items,
4162                         queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
4163                         connectWith = this._connectWith();
4164
4165                 if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
4166                         for (i = connectWith.length - 1; i >= 0; i--){
4167                                 cur = $(connectWith[i]);
4168                                 for (j = cur.length - 1; j >= 0; j--){
4169                                         inst = $.data(cur[j], this.widgetFullName);
4170                                         if(inst && inst !== this && !inst.options.disabled) {
4171                                                 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
4172                                                 this.containers.push(inst);
4173                                         }
4174                                 }
4175                         }
4176                 }
4177
4178                 for (i = queries.length - 1; i >= 0; i--) {
4179                         targetData = queries[i][1];
4180                         _queries = queries[i][0];
4181
4182                         for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
4183                                 item = $(_queries[j]);
4184
4185                                 item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
4186
4187                                 items.push({
4188                                         item: item,
4189                                         instance: targetData,
4190                                         width: 0, height: 0,
4191                                         left: 0, top: 0
4192                                 });
4193                         }
4194                 }
4195
4196         },
4197
4198         refreshPositions: function(fast) {
4199
4200                 //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
4201                 if(this.offsetParent && this.helper) {
4202                         this.offset.parent = this._getParentOffset();
4203                 }
4204
4205                 var i, item, t, p;
4206
4207                 for (i = this.items.length - 1; i >= 0; i--){
4208                         item = this.items[i];
4209
4210                         //We ignore calculating positions of all connected containers when we're not over them
4211                         if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
4212                                 continue;
4213                         }
4214
4215                         t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
4216
4217                         if (!fast) {
4218                                 item.width = t.outerWidth();
4219                                 item.height = t.outerHeight();
4220                         }
4221
4222                         p = t.offset();
4223                         item.left = p.left;
4224                         item.top = p.top;
4225                 }
4226
4227                 if(this.options.custom && this.options.custom.refreshContainers) {
4228                         this.options.custom.refreshContainers.call(this);
4229                 } else {
4230                         for (i = this.containers.length - 1; i >= 0; i--){
4231                                 p = this.containers[i].element.offset();
4232                                 this.containers[i].containerCache.left = p.left;
4233                                 this.containers[i].containerCache.top = p.top;
4234                                 this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
4235                                 this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
4236                         }
4237                 }
4238
4239                 return this;
4240         },
4241
4242         _createPlaceholder: function(that) {
4243                 that = that || this;
4244                 var className,
4245                         o = that.options;
4246
4247                 if(!o.placeholder || o.placeholder.constructor === String) {
4248                         className = o.placeholder;
4249                         o.placeholder = {
4250                                 element: function() {
4251
4252                                         var nodeName = that.currentItem[0].nodeName.toLowerCase(),
4253                                                 element = $( "<" + nodeName + ">", that.document[0] )
4254                                                         .addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
4255                                                         .removeClass("ui-sortable-helper");
4256
4257                                         if ( nodeName === "tr" ) {
4258                                                 that.currentItem.children().each(function() {
4259                                                         $( "<td>&#160;</td>", that.document[0] )
4260                                                                 .attr( "colspan", $( this ).attr( "colspan" ) || 1 )
4261                                                                 .appendTo( element );
4262                                                 });
4263                                         } else if ( nodeName === "img" ) {
4264                                                 element.attr( "src", that.currentItem.attr( "src" ) );
4265                                         }
4266
4267                                         if ( !className ) {
4268                                                 element.css( "visibility", "hidden" );
4269                                         }
4270
4271                                         return element;
4272                                 },
4273                                 update: function(container, p) {
4274
4275                                         // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
4276                                         // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
4277                                         if(className && !o.forcePlaceholderSize) {
4278                                                 return;
4279                                         }
4280
4281                                         //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
4282                                         if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
4283                                         if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
4284                                 }
4285                         };
4286                 }
4287
4288                 //Create the placeholder
4289                 that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
4290
4291                 //Append it after the actual current item
4292                 that.currentItem.after(that.placeholder);
4293
4294                 //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
4295                 o.placeholder.update(that, that.placeholder);
4296
4297         },
4298
4299         _contactContainers: function(event) {
4300                 var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, base, cur, nearBottom, floating,
4301                         innermostContainer = null,
4302                         innermostIndex = null;
4303
4304                 // get innermost container that intersects with item
4305                 for (i = this.containers.length - 1; i >= 0; i--) {
4306
4307                         // never consider a container that's located within the item itself
4308                         if($.contains(this.currentItem[0], this.containers[i].element[0])) {
4309                                 continue;
4310                         }
4311
4312                         if(this._intersectsWith(this.containers[i].containerCache)) {
4313
4314                                 // if we've already found a container and it's more "inner" than this, then continue
4315                                 if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
4316                                         continue;
4317                                 }
4318
4319                                 innermostContainer = this.containers[i];
4320                                 innermostIndex = i;
4321
4322                         } else {
4323                                 // container doesn't intersect. trigger "out" event if necessary
4324                                 if(this.containers[i].containerCache.over) {
4325                                         this.containers[i]._trigger("out", event, this._uiHash(this));
4326                                         this.containers[i].containerCache.over = 0;
4327                                 }
4328                         }
4329
4330                 }
4331
4332                 // if no intersecting containers found, return
4333                 if(!innermostContainer) {
4334                         return;
4335                 }
4336
4337                 // move the item into the container if it's not there already
4338                 if(this.containers.length === 1) {
4339                         if (!this.containers[innermostIndex].containerCache.over) {
4340                                 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
4341                                 this.containers[innermostIndex].containerCache.over = 1;
4342                         }
4343                 } else {
4344
4345                         //When entering a new container, we will find the item with the least distance and append our item near it
4346                         dist = 10000;
4347                         itemWithLeastDistance = null;
4348                         floating = innermostContainer.floating || isFloating(this.currentItem);
4349                         posProperty = floating ? "left" : "top";
4350                         sizeProperty = floating ? "width" : "height";
4351                         base = this.positionAbs[posProperty] + this.offset.click[posProperty];
4352                         for (j = this.items.length - 1; j >= 0; j--) {
4353                                 if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
4354                                         continue;
4355                                 }
4356                                 if(this.items[j].item[0] === this.currentItem[0]) {
4357                                         continue;
4358                                 }
4359                                 if (floating && !isOverAxis(this.positionAbs.top + this.offset.click.top, this.items[j].top, this.items[j].height)) {
4360                                         continue;
4361                                 }
4362                                 cur = this.items[j].item.offset()[posProperty];
4363                                 nearBottom = false;
4364                                 if(Math.abs(cur - base) > Math.abs(cur + this.items[j][sizeProperty] - base)){
4365                                         nearBottom = true;
4366                                         cur += this.items[j][sizeProperty];
4367                                 }
4368
4369                                 if(Math.abs(cur - base) < dist) {
4370                                         dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
4371                                         this.direction = nearBottom ? "up": "down";
4372                                 }
4373                         }
4374
4375                         //Check if dropOnEmpty is enabled
4376                         if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
4377                                 return;
4378                         }
4379
4380                         if(this.currentContainer === this.containers[innermostIndex]) {
4381                                 return;
4382                         }
4383
4384                         itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
4385                         this._trigger("change", event, this._uiHash());
4386                         this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
4387                         this.currentContainer = this.containers[innermostIndex];
4388
4389                         //Update the placeholder
4390                         this.options.placeholder.update(this.currentContainer, this.placeholder);
4391
4392                         this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
4393                         this.containers[innermostIndex].containerCache.over = 1;
4394                 }
4395
4396
4397         },
4398
4399         _createHelper: function(event) {
4400
4401                 var o = this.options,
4402                         helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
4403
4404                 //Add the helper to the DOM if that didn't happen already
4405                 if(!helper.parents("body").length) {
4406                         $(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
4407                 }
4408
4409                 if(helper[0] === this.currentItem[0]) {
4410                         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") };
4411                 }
4412
4413                 if(!helper[0].style.width || o.forceHelperSize) {
4414                         helper.width(this.currentItem.width());
4415                 }
4416                 if(!helper[0].style.height || o.forceHelperSize) {
4417                         helper.height(this.currentItem.height());
4418                 }
4419
4420                 return helper;
4421
4422         },
4423
4424         _adjustOffsetFromHelper: function(obj) {
4425                 if (typeof obj === "string") {
4426                         obj = obj.split(" ");
4427                 }
4428                 if ($.isArray(obj)) {
4429                         obj = {left: +obj[0], top: +obj[1] || 0};
4430                 }
4431                 if ("left" in obj) {
4432                         this.offset.click.left = obj.left + this.margins.left;
4433                 }
4434                 if ("right" in obj) {
4435                         this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
4436                 }
4437                 if ("top" in obj) {
4438                         this.offset.click.top = obj.top + this.margins.top;
4439                 }
4440                 if ("bottom" in obj) {
4441                         this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
4442                 }
4443         },
4444
4445         _getParentOffset: function() {
4446
4447
4448                 //Get the offsetParent and cache its position
4449                 this.offsetParent = this.helper.offsetParent();
4450                 var po = this.offsetParent.offset();
4451
4452                 // This is a special case where we need to modify a offset calculated on start, since the following happened:
4453                 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
4454                 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
4455                 //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
4456                 if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
4457                         po.left += this.scrollParent.scrollLeft();
4458                         po.top += this.scrollParent.scrollTop();
4459                 }
4460
4461                 // This needs to be actually done for all browsers, since pageX/pageY includes this information
4462                 // with an ugly IE fix
4463                 if( this.offsetParent[0] === document.body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
4464                         po = { top: 0, left: 0 };
4465                 }
4466
4467                 return {
4468                         top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
4469                         left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
4470                 };
4471
4472         },
4473
4474         _getRelativeOffset: function() {
4475
4476                 if(this.cssPosition === "relative") {
4477                         var p = this.currentItem.position();
4478                         return {
4479                                 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
4480                                 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
4481                         };
4482                 } else {
4483                         return { top: 0, left: 0 };
4484                 }
4485
4486         },
4487
4488         _cacheMargins: function() {
4489                 this.margins = {
4490                         left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
4491                         top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
4492                 };
4493         },
4494
4495         _cacheHelperProportions: function() {
4496                 this.helperProportions = {
4497                         width: this.helper.outerWidth(),
4498                         height: this.helper.outerHeight()
4499                 };
4500         },
4501
4502         _setContainment: function() {
4503
4504                 var ce, co, over,
4505                         o = this.options;
4506                 if(o.containment === "parent") {
4507                         o.containment = this.helper[0].parentNode;
4508                 }
4509                 if(o.containment === "document" || o.containment === "window") {
4510                         this.containment = [
4511                                 0 - this.offset.relative.left - this.offset.parent.left,
4512                                 0 - this.offset.relative.top - this.offset.parent.top,
4513                                 $(o.containment === "document" ? document : window).width() - this.helperProportions.width - this.margins.left,
4514                                 ($(o.containment === "document" ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
4515                         ];
4516                 }
4517
4518                 if(!(/^(document|window|parent)$/).test(o.containment)) {
4519                         ce = $(o.containment)[0];
4520                         co = $(o.containment).offset();
4521                         over = ($(ce).css("overflow") !== "hidden");
4522
4523                         this.containment = [
4524                                 co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
4525                                 co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
4526                                 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,
4527                                 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
4528                         ];
4529                 }
4530
4531         },
4532
4533         _convertPositionTo: function(d, pos) {
4534
4535                 if(!pos) {
4536                         pos = this.position;
4537                 }
4538                 var mod = d === "absolute" ? 1 : -1,
4539                         scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
4540                         scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
4541
4542                 return {
4543                         top: (
4544                                 pos.top +                                                                                                                               // The absolute mouse position
4545                                 this.offset.relative.top * mod +                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
4546                                 this.offset.parent.top * mod -                                                                                  // The offsetParent's offset without borders (offset + border)
4547                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
4548                         ),
4549                         left: (
4550                                 pos.left +                                                                                                                              // The absolute mouse position
4551                                 this.offset.relative.left * mod +                                                                               // Only for relative positioned nodes: Relative offset from element to offset parent
4552                                 this.offset.parent.left * mod   -                                                                               // The offsetParent's offset without borders (offset + border)
4553                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
4554                         )
4555                 };
4556
4557         },
4558
4559         _generatePosition: function(event) {
4560
4561                 var top, left,
4562                         o = this.options,
4563                         pageX = event.pageX,
4564                         pageY = event.pageY,
4565                         scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
4566
4567                 // This is another very weird special case that only happens for relative elements:
4568                 // 1. If the css position is relative
4569                 // 2. and the scroll parent is the document or similar to the offset parent
4570                 // we have to refresh the relative offset during the scroll so there are no jumps
4571                 if(this.cssPosition === "relative" && !(this.scrollParent[0] !== document && this.scrollParent[0] !== this.offsetParent[0])) {
4572                         this.offset.relative = this._getRelativeOffset();
4573                 }
4574
4575                 /*
4576                  * - Position constraining -
4577                  * Constrain the position to a mix of grid, containment.
4578                  */
4579
4580                 if(this.originalPosition) { //If we are not dragging yet, we won't check for options
4581
4582                         if(this.containment) {
4583                                 if(event.pageX - this.offset.click.left < this.containment[0]) {
4584                                         pageX = this.containment[0] + this.offset.click.left;
4585                                 }
4586                                 if(event.pageY - this.offset.click.top < this.containment[1]) {
4587                                         pageY = this.containment[1] + this.offset.click.top;
4588                                 }
4589                                 if(event.pageX - this.offset.click.left > this.containment[2]) {
4590                                         pageX = this.containment[2] + this.offset.click.left;
4591                                 }
4592                                 if(event.pageY - this.offset.click.top > this.containment[3]) {
4593                                         pageY = this.containment[3] + this.offset.click.top;
4594                                 }
4595                         }
4596
4597                         if(o.grid) {
4598                                 top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
4599                                 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;
4600
4601                                 left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
4602                                 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;
4603                         }
4604
4605                 }
4606
4607                 return {
4608                         top: (
4609                                 pageY -                                                                                                                         // The absolute mouse position
4610                                 this.offset.click.top -                                                                                                 // Click offset (relative to the element)
4611                                 this.offset.relative.top        -                                                                                       // Only for relative positioned nodes: Relative offset from element to offset parent
4612                                 this.offset.parent.top +                                                                                                // The offsetParent's offset without borders (offset + border)
4613                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
4614                         ),
4615                         left: (
4616                                 pageX -                                                                                                                         // The absolute mouse position
4617                                 this.offset.click.left -                                                                                                // Click offset (relative to the element)
4618                                 this.offset.relative.left       -                                                                                       // Only for relative positioned nodes: Relative offset from element to offset parent
4619                                 this.offset.parent.left +                                                                                               // The offsetParent's offset without borders (offset + border)
4620                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
4621                         )
4622                 };
4623
4624         },
4625
4626         _rearrange: function(event, i, a, hardRefresh) {
4627
4628                 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));
4629
4630                 //Various things done here to improve the performance:
4631                 // 1. we create a setTimeout, that calls refreshPositions
4632                 // 2. on the instance, we have a counter variable, that get's higher after every append
4633                 // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
4634                 // 4. this lets only the last addition to the timeout stack through
4635                 this.counter = this.counter ? ++this.counter : 1;
4636                 var counter = this.counter;
4637
4638                 this._delay(function() {
4639                         if(counter === this.counter) {
4640                                 this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
4641                         }
4642                 });
4643
4644         },
4645
4646         _clear: function(event, noPropagation) {
4647
4648                 this.reverting = false;
4649                 // We delay all events that have to be triggered to after the point where the placeholder has been removed and
4650                 // everything else normalized again
4651                 var i,
4652                         delayedTriggers = [];
4653
4654                 // We first have to update the dom position of the actual currentItem
4655                 // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
4656                 if(!this._noFinalSort && this.currentItem.parent().length) {
4657                         this.placeholder.before(this.currentItem);
4658                 }
4659                 this._noFinalSort = null;
4660
4661                 if(this.helper[0] === this.currentItem[0]) {
4662                         for(i in this._storedCSS) {
4663                                 if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
4664                                         this._storedCSS[i] = "";
4665                                 }
4666                         }
4667                         this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
4668                 } else {
4669                         this.currentItem.show();
4670                 }
4671
4672                 if(this.fromOutside && !noPropagation) {
4673                         delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
4674                 }
4675                 if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
4676                         delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
4677                 }
4678
4679                 // Check if the items Container has Changed and trigger appropriate
4680                 // events.
4681                 if (this !== this.currentContainer) {
4682                         if(!noPropagation) {
4683                                 delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
4684                                 delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); };  }).call(this, this.currentContainer));
4685                                 delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this));  }; }).call(this, this.currentContainer));
4686                         }
4687                 }
4688
4689
4690                 //Post events to containers
4691                 for (i = this.containers.length - 1; i >= 0; i--){
4692                         if(!noPropagation) {
4693                                 delayedTriggers.push((function(c) { return function(event) { c._trigger("deactivate", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
4694                         }
4695                         if(this.containers[i].containerCache.over) {
4696                                 delayedTriggers.push((function(c) { return function(event) { c._trigger("out", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
4697                                 this.containers[i].containerCache.over = 0;
4698                         }
4699                 }
4700
4701                 //Do what was originally in plugins
4702                 if ( this.storedCursor ) {
4703                         this.document.find( "body" ).css( "cursor", this.storedCursor );
4704                         this.storedStylesheet.remove();
4705                 }
4706                 if(this._storedOpacity) {
4707                         this.helper.css("opacity", this._storedOpacity);
4708                 }
4709                 if(this._storedZIndex) {
4710                         this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
4711                 }
4712
4713                 this.dragging = false;
4714                 if(this.cancelHelperRemoval) {
4715                         if(!noPropagation) {
4716                                 this._trigger("beforeStop", event, this._uiHash());
4717                                 for (i=0; i < delayedTriggers.length; i++) {
4718                                         delayedTriggers[i].call(this, event);
4719                                 } //Trigger all delayed events
4720                                 this._trigger("stop", event, this._uiHash());
4721                         }
4722
4723                         this.fromOutside = false;
4724                         return false;
4725                 }
4726
4727                 if(!noPropagation) {
4728                         this._trigger("beforeStop", event, this._uiHash());
4729                 }
4730
4731                 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
4732                 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
4733
4734                 if(this.helper[0] !== this.currentItem[0]) {
4735                         this.helper.remove();
4736                 }
4737                 this.helper = null;
4738
4739                 if(!noPropagation) {
4740                         for (i=0; i < delayedTriggers.length; i++) {
4741                                 delayedTriggers[i].call(this, event);
4742                         } //Trigger all delayed events
4743                         this._trigger("stop", event, this._uiHash());
4744                 }
4745
4746                 this.fromOutside = false;
4747                 return true;
4748
4749         },
4750
4751         _trigger: function() {
4752                 if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
4753                         this.cancel();
4754                 }
4755         },
4756
4757         _uiHash: function(_inst) {
4758                 var inst = _inst || this;
4759                 return {
4760                         helper: inst.helper,
4761                         placeholder: inst.placeholder || $([]),
4762                         position: inst.position,
4763                         originalPosition: inst.originalPosition,
4764                         offset: inst.positionAbs,
4765                         item: inst.currentItem,
4766                         sender: _inst ? _inst.element : null
4767                 };
4768         }
4769
4770 });
4771
4772 })(jQuery);
4773
4774 (function($, undefined) {
4775
4776 var dataSpace = "ui-effects-";
4777
4778 $.effects = {
4779         effect: {}
4780 };
4781
4782 /*!
4783  * jQuery Color Animations v2.1.2
4784  * https://github.com/jquery/jquery-color
4785  *
4786  * Copyright 2013 jQuery Foundation and other contributors
4787  * Released under the MIT license.
4788  * http://jquery.org/license
4789  *
4790  * Date: Wed Jan 16 08:47:09 2013 -0600
4791  */
4792 (function( jQuery, undefined ) {
4793
4794         var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
4795
4796         // plusequals test for += 100 -= 100
4797         rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
4798         // a set of RE's that can match strings and generate color tuples.
4799         stringParsers = [{
4800                         re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
4801                         parse: function( execResult ) {
4802                                 return [
4803                                         execResult[ 1 ],
4804                                         execResult[ 2 ],
4805                                         execResult[ 3 ],
4806                                         execResult[ 4 ]
4807                                 ];
4808                         }
4809                 }, {
4810                         re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
4811                         parse: function( execResult ) {
4812                                 return [
4813                                         execResult[ 1 ] * 2.55,
4814                                         execResult[ 2 ] * 2.55,
4815                                         execResult[ 3 ] * 2.55,
4816                                         execResult[ 4 ]
4817                                 ];
4818                         }
4819                 }, {
4820                         // this regex ignores A-F because it's compared against an already lowercased string
4821                         re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
4822                         parse: function( execResult ) {
4823                                 return [
4824                                         parseInt( execResult[ 1 ], 16 ),
4825                                         parseInt( execResult[ 2 ], 16 ),
4826                                         parseInt( execResult[ 3 ], 16 )
4827                                 ];
4828                         }
4829                 }, {
4830                         // this regex ignores A-F because it's compared against an already lowercased string
4831                         re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
4832                         parse: function( execResult ) {
4833                                 return [
4834                                         parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
4835                                         parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
4836                                         parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
4837                                 ];
4838                         }
4839                 }, {
4840                         re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
4841                         space: "hsla",
4842                         parse: function( execResult ) {
4843                                 return [
4844                                         execResult[ 1 ],
4845                                         execResult[ 2 ] / 100,
4846                                         execResult[ 3 ] / 100,
4847                                         execResult[ 4 ]
4848                                 ];
4849                         }
4850                 }],
4851
4852         // jQuery.Color( )
4853         color = jQuery.Color = function( color, green, blue, alpha ) {
4854                 return new jQuery.Color.fn.parse( color, green, blue, alpha );
4855         },
4856         spaces = {
4857                 rgba: {
4858                         props: {
4859                                 red: {
4860                                         idx: 0,
4861                                         type: "byte"
4862                                 },
4863                                 green: {
4864                                         idx: 1,
4865                                         type: "byte"
4866                                 },
4867                                 blue: {
4868                                         idx: 2,
4869                                         type: "byte"
4870                                 }
4871                         }
4872                 },
4873
4874                 hsla: {
4875                         props: {
4876                                 hue: {
4877                                         idx: 0,
4878                                         type: "degrees"
4879                                 },
4880                                 saturation: {
4881                                         idx: 1,
4882                                         type: "percent"
4883                                 },
4884                                 lightness: {
4885                                         idx: 2,
4886                                         type: "percent"
4887                                 }
4888                         }
4889                 }
4890         },
4891         propTypes = {
4892                 "byte": {
4893                         floor: true,
4894                         max: 255
4895                 },
4896                 "percent": {
4897                         max: 1
4898                 },
4899                 "degrees": {
4900                         mod: 360,
4901                         floor: true
4902                 }
4903         },
4904         support = color.support = {},
4905
4906         // element for support tests
4907         supportElem = jQuery( "<p>" )[ 0 ],
4908
4909         // colors = jQuery.Color.names
4910         colors,
4911
4912         // local aliases of functions called often
4913         each = jQuery.each;
4914
4915 // determine rgba support immediately
4916 supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
4917 support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
4918
4919 // define cache name and alpha properties
4920 // for rgba and hsla spaces
4921 each( spaces, function( spaceName, space ) {
4922         space.cache = "_" + spaceName;
4923         space.props.alpha = {
4924                 idx: 3,
4925                 type: "percent",
4926                 def: 1
4927         };
4928 });
4929
4930 function clamp( value, prop, allowEmpty ) {
4931         var type = propTypes[ prop.type ] || {};
4932
4933         if ( value == null ) {
4934                 return (allowEmpty || !prop.def) ? null : prop.def;
4935         }
4936
4937         // ~~ is an short way of doing floor for positive numbers
4938         value = type.floor ? ~~value : parseFloat( value );
4939
4940         // IE will pass in empty strings as value for alpha,
4941         // which will hit this case
4942         if ( isNaN( value ) ) {
4943                 return prop.def;
4944         }
4945
4946         if ( type.mod ) {
4947                 // we add mod before modding to make sure that negatives values
4948                 // get converted properly: -10 -> 350
4949                 return (value + type.mod) % type.mod;
4950         }
4951
4952         // for now all property types without mod have min and max
4953         return 0 > value ? 0 : type.max < value ? type.max : value;
4954 }
4955
4956 function stringParse( string ) {
4957         var inst = color(),
4958                 rgba = inst._rgba = [];
4959
4960         string = string.toLowerCase();
4961
4962         each( stringParsers, function( i, parser ) {
4963                 var parsed,
4964                         match = parser.re.exec( string ),
4965                         values = match && parser.parse( match ),
4966                         spaceName = parser.space || "rgba";
4967
4968                 if ( values ) {
4969                         parsed = inst[ spaceName ]( values );
4970
4971                         // if this was an rgba parse the assignment might happen twice
4972                         // oh well....
4973                         inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
4974                         rgba = inst._rgba = parsed._rgba;
4975
4976                         // exit each( stringParsers ) here because we matched
4977                         return false;
4978                 }
4979         });
4980
4981         // Found a stringParser that handled it
4982         if ( rgba.length ) {
4983
4984                 // if this came from a parsed string, force "transparent" when alpha is 0
4985                 // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
4986                 if ( rgba.join() === "0,0,0,0" ) {
4987                         jQuery.extend( rgba, colors.transparent );
4988                 }
4989                 return inst;
4990         }
4991
4992         // named colors
4993         return colors[ string ];
4994 }
4995
4996 color.fn = jQuery.extend( color.prototype, {
4997         parse: function( red, green, blue, alpha ) {
4998                 if ( red === undefined ) {
4999                         this._rgba = [ null, null, null, null ];
5000                         return this;
5001                 }
5002                 if ( red.jquery || red.nodeType ) {
5003                         red = jQuery( red ).css( green );
5004                         green = undefined;
5005                 }
5006
5007                 var inst = this,
5008                         type = jQuery.type( red ),
5009                         rgba = this._rgba = [];
5010
5011                 // more than 1 argument specified - assume ( red, green, blue, alpha )
5012                 if ( green !== undefined ) {
5013                         red = [ red, green, blue, alpha ];
5014                         type = "array";
5015                 }
5016
5017                 if ( type === "string" ) {
5018                         return this.parse( stringParse( red ) || colors._default );
5019                 }
5020
5021                 if ( type === "array" ) {
5022                         each( spaces.rgba.props, function( key, prop ) {
5023                                 rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
5024                         });
5025                         return this;
5026                 }
5027
5028                 if ( type === "object" ) {
5029                         if ( red instanceof color ) {
5030                                 each( spaces, function( spaceName, space ) {
5031                                         if ( red[ space.cache ] ) {
5032                                                 inst[ space.cache ] = red[ space.cache ].slice();
5033                                         }
5034                                 });
5035                         } else {
5036                                 each( spaces, function( spaceName, space ) {
5037                                         var cache = space.cache;
5038                                         each( space.props, function( key, prop ) {
5039
5040                                                 // if the cache doesn't exist, and we know how to convert
5041                                                 if ( !inst[ cache ] && space.to ) {
5042
5043                                                         // if the value was null, we don't need to copy it
5044                                                         // if the key was alpha, we don't need to copy it either
5045                                                         if ( key === "alpha" || red[ key ] == null ) {
5046                                                                 return;
5047                                                         }
5048                                                         inst[ cache ] = space.to( inst._rgba );
5049                                                 }
5050
5051                                                 // this is the only case where we allow nulls for ALL properties.
5052                                                 // call clamp with alwaysAllowEmpty
5053                                                 inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
5054                                         });
5055
5056                                         // everything defined but alpha?
5057                                         if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
5058                                                 // use the default of 1
5059                                                 inst[ cache ][ 3 ] = 1;
5060                                                 if ( space.from ) {
5061                                                         inst._rgba = space.from( inst[ cache ] );
5062                                                 }
5063                                         }
5064                                 });
5065                         }
5066                         return this;
5067                 }
5068         },
5069         is: function( compare ) {
5070                 var is = color( compare ),
5071                         same = true,
5072                         inst = this;
5073
5074                 each( spaces, function( _, space ) {
5075                         var localCache,
5076                                 isCache = is[ space.cache ];
5077                         if (isCache) {
5078                                 localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
5079                                 each( space.props, function( _, prop ) {
5080                                         if ( isCache[ prop.idx ] != null ) {
5081                                                 same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
5082                                                 return same;
5083                                         }
5084                                 });
5085                         }
5086                         return same;
5087                 });
5088                 return same;
5089         },
5090         _space: function() {
5091                 var used = [],
5092                         inst = this;
5093                 each( spaces, function( spaceName, space ) {
5094                         if ( inst[ space.cache ] ) {
5095                                 used.push( spaceName );
5096                         }
5097                 });
5098                 return used.pop();
5099         },
5100         transition: function( other, distance ) {
5101                 var end = color( other ),
5102                         spaceName = end._space(),
5103                         space = spaces[ spaceName ],
5104                         startColor = this.alpha() === 0 ? color( "transparent" ) : this,
5105                         start = startColor[ space.cache ] || space.to( startColor._rgba ),
5106                         result = start.slice();
5107
5108                 end = end[ space.cache ];
5109                 each( space.props, function( key, prop ) {
5110                         var index = prop.idx,
5111                                 startValue = start[ index ],
5112                                 endValue = end[ index ],
5113                                 type = propTypes[ prop.type ] || {};
5114
5115                         // if null, don't override start value
5116                         if ( endValue === null ) {
5117                                 return;
5118                         }
5119                         // if null - use end
5120                         if ( startValue === null ) {
5121                                 result[ index ] = endValue;
5122                         } else {
5123                                 if ( type.mod ) {
5124                                         if ( endValue - startValue > type.mod / 2 ) {
5125                                                 startValue += type.mod;
5126                                         } else if ( startValue - endValue > type.mod / 2 ) {
5127                                                 startValue -= type.mod;
5128                                         }
5129                                 }
5130                                 result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
5131                         }
5132                 });
5133                 return this[ spaceName ]( result );
5134         },
5135         blend: function( opaque ) {
5136                 // if we are already opaque - return ourself
5137                 if ( this._rgba[ 3 ] === 1 ) {
5138                         return this;
5139                 }
5140
5141                 var rgb = this._rgba.slice(),
5142                         a = rgb.pop(),
5143                         blend = color( opaque )._rgba;
5144
5145                 return color( jQuery.map( rgb, function( v, i ) {
5146                         return ( 1 - a ) * blend[ i ] + a * v;
5147                 }));
5148         },
5149         toRgbaString: function() {
5150                 var prefix = "rgba(",
5151                         rgba = jQuery.map( this._rgba, function( v, i ) {
5152                                 return v == null ? ( i > 2 ? 1 : 0 ) : v;
5153                         });
5154
5155                 if ( rgba[ 3 ] === 1 ) {
5156                         rgba.pop();
5157                         prefix = "rgb(";
5158                 }
5159
5160                 return prefix + rgba.join() + ")";
5161         },
5162         toHslaString: function() {
5163                 var prefix = "hsla(",
5164                         hsla = jQuery.map( this.hsla(), function( v, i ) {
5165                                 if ( v == null ) {
5166                                         v = i > 2 ? 1 : 0;
5167                                 }
5168
5169                                 // catch 1 and 2
5170                                 if ( i && i < 3 ) {
5171                                         v = Math.round( v * 100 ) + "%";
5172                                 }
5173                                 return v;
5174                         });
5175
5176                 if ( hsla[ 3 ] === 1 ) {
5177                         hsla.pop();
5178                         prefix = "hsl(";
5179                 }
5180                 return prefix + hsla.join() + ")";
5181         },
5182         toHexString: function( includeAlpha ) {
5183                 var rgba = this._rgba.slice(),
5184                         alpha = rgba.pop();
5185
5186                 if ( includeAlpha ) {
5187                         rgba.push( ~~( alpha * 255 ) );
5188                 }
5189
5190                 return "#" + jQuery.map( rgba, function( v ) {
5191
5192                         // default to 0 when nulls exist
5193                         v = ( v || 0 ).toString( 16 );
5194                         return v.length === 1 ? "0" + v : v;
5195                 }).join("");
5196         },
5197         toString: function() {
5198                 return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
5199         }
5200 });
5201 color.fn.parse.prototype = color.fn;
5202
5203 // hsla conversions adapted from:
5204 // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
5205
5206 function hue2rgb( p, q, h ) {
5207         h = ( h + 1 ) % 1;
5208         if ( h * 6 < 1 ) {
5209                 return p + (q - p) * h * 6;
5210         }
5211         if ( h * 2 < 1) {
5212                 return q;
5213         }
5214         if ( h * 3 < 2 ) {
5215                 return p + (q - p) * ((2/3) - h) * 6;
5216         }
5217         return p;
5218 }
5219
5220 spaces.hsla.to = function ( rgba ) {
5221         if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
5222                 return [ null, null, null, rgba[ 3 ] ];
5223         }
5224         var r = rgba[ 0 ] / 255,
5225                 g = rgba[ 1 ] / 255,
5226                 b = rgba[ 2 ] / 255,
5227                 a = rgba[ 3 ],
5228                 max = Math.max( r, g, b ),
5229                 min = Math.min( r, g, b ),
5230                 diff = max - min,
5231                 add = max + min,
5232                 l = add * 0.5,
5233                 h, s;
5234
5235         if ( min === max ) {
5236                 h = 0;
5237         } else if ( r === max ) {
5238                 h = ( 60 * ( g - b ) / diff ) + 360;
5239         } else if ( g === max ) {
5240                 h = ( 60 * ( b - r ) / diff ) + 120;
5241         } else {
5242                 h = ( 60 * ( r - g ) / diff ) + 240;
5243         }
5244
5245         // chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
5246         // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
5247         if ( diff === 0 ) {
5248                 s = 0;
5249         } else if ( l <= 0.5 ) {
5250                 s = diff / add;
5251         } else {
5252                 s = diff / ( 2 - add );
5253         }
5254         return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
5255 };
5256
5257 spaces.hsla.from = function ( hsla ) {
5258         if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
5259                 return [ null, null, null, hsla[ 3 ] ];
5260         }
5261         var h = hsla[ 0 ] / 360,
5262                 s = hsla[ 1 ],
5263                 l = hsla[ 2 ],
5264                 a = hsla[ 3 ],
5265                 q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
5266                 p = 2 * l - q;
5267
5268         return [
5269                 Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
5270                 Math.round( hue2rgb( p, q, h ) * 255 ),
5271                 Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
5272                 a
5273         ];
5274 };
5275
5276
5277 each( spaces, function( spaceName, space ) {
5278         var props = space.props,
5279                 cache = space.cache,
5280                 to = space.to,
5281                 from = space.from;
5282
5283         // makes rgba() and hsla()
5284         color.fn[ spaceName ] = function( value ) {
5285
5286                 // generate a cache for this space if it doesn't exist
5287                 if ( to && !this[ cache ] ) {
5288                         this[ cache ] = to( this._rgba );
5289                 }
5290                 if ( value === undefined ) {
5291                         return this[ cache ].slice();
5292                 }
5293
5294                 var ret,
5295                         type = jQuery.type( value ),
5296                         arr = ( type === "array" || type === "object" ) ? value : arguments,
5297                         local = this[ cache ].slice();
5298
5299                 each( props, function( key, prop ) {
5300                         var val = arr[ type === "object" ? key : prop.idx ];
5301                         if ( val == null ) {
5302                                 val = local[ prop.idx ];
5303                         }
5304                         local[ prop.idx ] = clamp( val, prop );
5305                 });
5306
5307                 if ( from ) {
5308                         ret = color( from( local ) );
5309                         ret[ cache ] = local;
5310                         return ret;
5311                 } else {
5312                         return color( local );
5313                 }
5314         };
5315
5316         // makes red() green() blue() alpha() hue() saturation() lightness()
5317         each( props, function( key, prop ) {
5318                 // alpha is included in more than one space
5319                 if ( color.fn[ key ] ) {
5320                         return;
5321                 }
5322                 color.fn[ key ] = function( value ) {
5323                         var vtype = jQuery.type( value ),
5324                                 fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
5325                                 local = this[ fn ](),
5326                                 cur = local[ prop.idx ],
5327                                 match;
5328
5329                         if ( vtype === "undefined" ) {
5330                                 return cur;
5331                         }
5332
5333                         if ( vtype === "function" ) {
5334                                 value = value.call( this, cur );
5335                                 vtype = jQuery.type( value );
5336                         }
5337                         if ( value == null && prop.empty ) {
5338                                 return this;
5339                         }
5340                         if ( vtype === "string" ) {
5341                                 match = rplusequals.exec( value );
5342                                 if ( match ) {
5343                                         value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
5344                                 }
5345                         }
5346                         local[ prop.idx ] = value;
5347                         return this[ fn ]( local );
5348                 };
5349         });
5350 });
5351
5352 // add cssHook and .fx.step function for each named hook.
5353 // accept a space separated string of properties
5354 color.hook = function( hook ) {
5355         var hooks = hook.split( " " );
5356         each( hooks, function( i, hook ) {
5357                 jQuery.cssHooks[ hook ] = {
5358                         set: function( elem, value ) {
5359                                 var parsed, curElem,
5360                                         backgroundColor = "";
5361
5362                                 if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
5363                                         value = color( parsed || value );
5364                                         if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
5365                                                 curElem = hook === "backgroundColor" ? elem.parentNode : elem;
5366                                                 while (
5367                                                         (backgroundColor === "" || backgroundColor === "transparent") &&
5368                                                         curElem && curElem.style
5369                                                 ) {
5370                                                         try {
5371                                                                 backgroundColor = jQuery.css( curElem, "backgroundColor" );
5372                                                                 curElem = curElem.parentNode;
5373                                                         } catch ( e ) {
5374                                                         }
5375                                                 }
5376
5377                                                 value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
5378                                                         backgroundColor :
5379                                                         "_default" );
5380                                         }
5381
5382                                         value = value.toRgbaString();
5383                                 }
5384                                 try {
5385                                         elem.style[ hook ] = value;
5386                                 } catch( e ) {
5387                                         // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
5388                                 }
5389                         }
5390                 };
5391                 jQuery.fx.step[ hook ] = function( fx ) {
5392                         if ( !fx.colorInit ) {
5393                                 fx.start = color( fx.elem, hook );
5394                                 fx.end = color( fx.end );
5395                                 fx.colorInit = true;
5396                         }
5397                         jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
5398                 };
5399         });
5400
5401 };
5402
5403 color.hook( stepHooks );
5404
5405 jQuery.cssHooks.borderColor = {
5406         expand: function( value ) {
5407                 var expanded = {};
5408
5409                 each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
5410                         expanded[ "border" + part + "Color" ] = value;
5411                 });
5412                 return expanded;
5413         }
5414 };
5415
5416 // Basic color names only.
5417 // Usage of any of the other color names requires adding yourself or including
5418 // jquery.color.svg-names.js.
5419 colors = jQuery.Color.names = {
5420         // 4.1. Basic color keywords
5421         aqua: "#00ffff",
5422         black: "#000000",
5423         blue: "#0000ff",
5424         fuchsia: "#ff00ff",
5425         gray: "#808080",
5426         green: "#008000",
5427         lime: "#00ff00",
5428         maroon: "#800000",
5429         navy: "#000080",
5430         olive: "#808000",
5431         purple: "#800080",
5432         red: "#ff0000",
5433         silver: "#c0c0c0",
5434         teal: "#008080",
5435         white: "#ffffff",
5436         yellow: "#ffff00",
5437
5438         // 4.2.3. "transparent" color keyword
5439         transparent: [ null, null, null, 0 ],
5440
5441         _default: "#ffffff"
5442 };
5443
5444 })( jQuery );
5445
5446
5447 /******************************************************************************/
5448 /****************************** CLASS ANIMATIONS ******************************/
5449 /******************************************************************************/
5450 (function() {
5451
5452 var classAnimationActions = [ "add", "remove", "toggle" ],
5453         shorthandStyles = {
5454                 border: 1,
5455                 borderBottom: 1,
5456                 borderColor: 1,
5457                 borderLeft: 1,
5458                 borderRight: 1,
5459                 borderTop: 1,
5460                 borderWidth: 1,
5461                 margin: 1,
5462                 padding: 1
5463         };
5464
5465 $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
5466         $.fx.step[ prop ] = function( fx ) {
5467                 if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
5468                         jQuery.style( fx.elem, prop, fx.end );
5469                         fx.setAttr = true;
5470                 }
5471         };
5472 });
5473
5474 function getElementStyles( elem ) {
5475         var key, len,
5476                 style = elem.ownerDocument.defaultView ?
5477                         elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
5478                         elem.currentStyle,
5479                 styles = {};
5480
5481         if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
5482                 len = style.length;
5483                 while ( len-- ) {
5484                         key = style[ len ];
5485                         if ( typeof style[ key ] === "string" ) {
5486                                 styles[ $.camelCase( key ) ] = style[ key ];
5487                         }
5488                 }
5489         // support: Opera, IE <9
5490         } else {
5491                 for ( key in style ) {
5492                         if ( typeof style[ key ] === "string" ) {
5493                                 styles[ key ] = style[ key ];
5494                         }
5495                 }
5496         }
5497
5498         return styles;
5499 }
5500
5501
5502 function styleDifference( oldStyle, newStyle ) {
5503         var diff = {},
5504                 name, value;
5505
5506         for ( name in newStyle ) {
5507                 value = newStyle[ name ];
5508                 if ( oldStyle[ name ] !== value ) {
5509                         if ( !shorthandStyles[ name ] ) {
5510                                 if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
5511                                         diff[ name ] = value;
5512                                 }
5513                         }
5514                 }
5515         }
5516
5517         return diff;
5518 }
5519
5520 // support: jQuery <1.8
5521 if ( !$.fn.addBack ) {
5522         $.fn.addBack = function( selector ) {
5523                 return this.add( selector == null ?
5524                         this.prevObject : this.prevObject.filter( selector )
5525                 );
5526         };
5527 }
5528
5529 $.effects.animateClass = function( value, duration, easing, callback ) {
5530         var o = $.speed( duration, easing, callback );
5531
5532         return this.queue( function() {
5533                 var animated = $( this ),
5534                         baseClass = animated.attr( "class" ) || "",
5535                         applyClassChange,
5536                         allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
5537
5538                 // map the animated objects to store the original styles.
5539                 allAnimations = allAnimations.map(function() {
5540                         var el = $( this );
5541                         return {
5542                                 el: el,
5543                                 start: getElementStyles( this )
5544                         };
5545                 });
5546
5547                 // apply class change
5548                 applyClassChange = function() {
5549                         $.each( classAnimationActions, function(i, action) {
5550                                 if ( value[ action ] ) {
5551                                         animated[ action + "Class" ]( value[ action ] );
5552                                 }
5553                         });
5554                 };
5555                 applyClassChange();
5556
5557                 // map all animated objects again - calculate new styles and diff
5558                 allAnimations = allAnimations.map(function() {
5559                         this.end = getElementStyles( this.el[ 0 ] );
5560                         this.diff = styleDifference( this.start, this.end );
5561                         return this;
5562                 });
5563
5564                 // apply original class
5565                 animated.attr( "class", baseClass );
5566
5567                 // map all animated objects again - this time collecting a promise
5568                 allAnimations = allAnimations.map(function() {
5569                         var styleInfo = this,
5570                                 dfd = $.Deferred(),
5571                                 opts = $.extend({}, o, {
5572                                         queue: false,
5573                                         complete: function() {
5574                                                 dfd.resolve( styleInfo );
5575                                         }
5576                                 });
5577
5578                         this.el.animate( this.diff, opts );
5579                         return dfd.promise();
5580                 });
5581
5582                 // once all animations have completed:
5583                 $.when.apply( $, allAnimations.get() ).done(function() {
5584
5585                         // set the final class
5586                         applyClassChange();
5587
5588                         // for each animated element,
5589                         // clear all css properties that were animated
5590                         $.each( arguments, function() {
5591                                 var el = this.el;
5592                                 $.each( this.diff, function(key) {
5593                                         el.css( key, "" );
5594                                 });
5595                         });
5596
5597                         // this is guarnteed to be there if you use jQuery.speed()
5598                         // it also handles dequeuing the next anim...
5599                         o.complete.call( animated[ 0 ] );
5600                 });
5601         });
5602 };
5603
5604 $.fn.extend({
5605         addClass: (function( orig ) {
5606                 return function( classNames, speed, easing, callback ) {
5607                         return speed ?
5608                                 $.effects.animateClass.call( this,
5609                                         { add: classNames }, speed, easing, callback ) :
5610                                 orig.apply( this, arguments );
5611                 };
5612         })( $.fn.addClass ),
5613
5614         removeClass: (function( orig ) {
5615                 return function( classNames, speed, easing, callback ) {
5616                         return arguments.length > 1 ?
5617                                 $.effects.animateClass.call( this,
5618                                         { remove: classNames }, speed, easing, callback ) :
5619                                 orig.apply( this, arguments );
5620                 };
5621         })( $.fn.removeClass ),
5622
5623         toggleClass: (function( orig ) {
5624                 return function( classNames, force, speed, easing, callback ) {
5625                         if ( typeof force === "boolean" || force === undefined ) {
5626                                 if ( !speed ) {
5627                                         // without speed parameter
5628                                         return orig.apply( this, arguments );
5629                                 } else {
5630                                         return $.effects.animateClass.call( this,
5631                                                 (force ? { add: classNames } : { remove: classNames }),
5632                                                 speed, easing, callback );
5633                                 }
5634                         } else {
5635                                 // without force parameter
5636                                 return $.effects.animateClass.call( this,
5637                                         { toggle: classNames }, force, speed, easing );
5638                         }
5639                 };
5640         })( $.fn.toggleClass ),
5641
5642         switchClass: function( remove, add, speed, easing, callback) {
5643                 return $.effects.animateClass.call( this, {
5644                         add: add,
5645                         remove: remove
5646                 }, speed, easing, callback );
5647         }
5648 });
5649
5650 })();
5651
5652 /******************************************************************************/
5653 /*********************************** EFFECTS **********************************/
5654 /******************************************************************************/
5655
5656 (function() {
5657
5658 $.extend( $.effects, {
5659         version: "1.10.3",
5660
5661         // Saves a set of properties in a data storage
5662         save: function( element, set ) {
5663                 for( var i=0; i < set.length; i++ ) {
5664                         if ( set[ i ] !== null ) {
5665                                 element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
5666                         }
5667                 }
5668         },
5669
5670         // Restores a set of previously saved properties from a data storage
5671         restore: function( element, set ) {
5672                 var val, i;
5673                 for( i=0; i < set.length; i++ ) {
5674                         if ( set[ i ] !== null ) {
5675                                 val = element.data( dataSpace + set[ i ] );
5676                                 // support: jQuery 1.6.2
5677                                 // http://bugs.jquery.com/ticket/9917
5678                                 // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
5679                                 // We can't differentiate between "" and 0 here, so we just assume
5680                                 // empty string since it's likely to be a more common value...
5681                                 if ( val === undefined ) {
5682                                         val = "";
5683                                 }
5684                                 element.css( set[ i ], val );
5685                         }
5686                 }
5687         },
5688
5689         setMode: function( el, mode ) {
5690                 if (mode === "toggle") {
5691                         mode = el.is( ":hidden" ) ? "show" : "hide";
5692                 }
5693                 return mode;
5694         },
5695
5696         // Translates a [top,left] array into a baseline value
5697         // this should be a little more flexible in the future to handle a string & hash
5698         getBaseline: function( origin, original ) {
5699                 var y, x;
5700                 switch ( origin[ 0 ] ) {
5701                         case "top": y = 0; break;
5702                         case "middle": y = 0.5; break;
5703                         case "bottom": y = 1; break;
5704                         default: y = origin[ 0 ] / original.height;
5705                 }
5706                 switch ( origin[ 1 ] ) {
5707                         case "left": x = 0; break;
5708                         case "center": x = 0.5; break;
5709                         case "right": x = 1; break;
5710                         default: x = origin[ 1 ] / original.width;
5711                 }
5712                 return {
5713                         x: x,
5714                         y: y
5715                 };
5716         },
5717
5718         // Wraps the element around a wrapper that copies position properties
5719         createWrapper: function( element ) {
5720
5721                 // if the element is already wrapped, return it
5722                 if ( element.parent().is( ".ui-effects-wrapper" )) {
5723                         return element.parent();
5724                 }
5725
5726                 // wrap the element
5727                 var props = {
5728                                 width: element.outerWidth(true),
5729                                 height: element.outerHeight(true),
5730                                 "float": element.css( "float" )
5731                         },
5732                         wrapper = $( "<div></div>" )
5733                                 .addClass( "ui-effects-wrapper" )
5734                                 .css({
5735                                         fontSize: "100%",
5736                                         background: "transparent",
5737                                         border: "none",
5738                                         margin: 0,
5739                                         padding: 0
5740                                 }),
5741                         // Store the size in case width/height are defined in % - Fixes #5245
5742                         size = {
5743                                 width: element.width(),
5744                                 height: element.height()
5745                         },
5746                         active = document.activeElement;
5747
5748                 // support: Firefox
5749                 // Firefox incorrectly exposes anonymous content
5750                 // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
5751                 try {
5752                         active.id;
5753                 } catch( e ) {
5754                         active = document.body;
5755                 }
5756
5757                 element.wrap( wrapper );
5758
5759                 // Fixes #7595 - Elements lose focus when wrapped.
5760                 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
5761                         $( active ).focus();
5762                 }
5763
5764                 wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
5765
5766                 // transfer positioning properties to the wrapper
5767                 if ( element.css( "position" ) === "static" ) {
5768                         wrapper.css({ position: "relative" });
5769                         element.css({ position: "relative" });
5770                 } else {
5771                         $.extend( props, {
5772                                 position: element.css( "position" ),
5773                                 zIndex: element.css( "z-index" )
5774                         });
5775                         $.each([ "top", "left", "bottom", "right" ], function(i, pos) {
5776                                 props[ pos ] = element.css( pos );
5777                                 if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
5778                                         props[ pos ] = "auto";
5779                                 }
5780                         });
5781                         element.css({
5782                                 position: "relative",
5783                                 top: 0,
5784                                 left: 0,
5785                                 right: "auto",
5786                                 bottom: "auto"
5787                         });
5788                 }
5789                 element.css(size);
5790
5791                 return wrapper.css( props ).show();
5792         },
5793
5794         removeWrapper: function( element ) {
5795                 var active = document.activeElement;
5796
5797                 if ( element.parent().is( ".ui-effects-wrapper" ) ) {
5798                         element.parent().replaceWith( element );
5799
5800                         // Fixes #7595 - Elements lose focus when wrapped.
5801                         if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
5802                                 $( active ).focus();
5803                         }
5804                 }
5805
5806
5807                 return element;
5808         },
5809
5810         setTransition: function( element, list, factor, value ) {
5811                 value = value || {};
5812                 $.each( list, function( i, x ) {
5813                         var unit = element.cssUnit( x );
5814                         if ( unit[ 0 ] > 0 ) {
5815                                 value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
5816                         }
5817                 });
5818                 return value;
5819         }
5820 });
5821
5822 // return an effect options object for the given parameters:
5823 function _normalizeArguments( effect, options, speed, callback ) {
5824
5825         // allow passing all options as the first parameter
5826         if ( $.isPlainObject( effect ) ) {
5827                 options = effect;
5828                 effect = effect.effect;
5829         }
5830
5831         // convert to an object
5832         effect = { effect: effect };
5833
5834         // catch (effect, null, ...)
5835         if ( options == null ) {
5836                 options = {};
5837         }
5838
5839         // catch (effect, callback)
5840         if ( $.isFunction( options ) ) {
5841                 callback = options;
5842                 speed = null;
5843                 options = {};
5844         }
5845
5846         // catch (effect, speed, ?)
5847         if ( typeof options === "number" || $.fx.speeds[ options ] ) {
5848                 callback = speed;
5849                 speed = options;
5850                 options = {};
5851         }
5852
5853         // catch (effect, options, callback)
5854         if ( $.isFunction( speed ) ) {
5855                 callback = speed;
5856                 speed = null;
5857         }
5858
5859         // add options to effect
5860         if ( options ) {
5861                 $.extend( effect, options );
5862         }
5863
5864         speed = speed || options.duration;
5865         effect.duration = $.fx.off ? 0 :
5866                 typeof speed === "number" ? speed :
5867                 speed in $.fx.speeds ? $.fx.speeds[ speed ] :
5868                 $.fx.speeds._default;
5869
5870         effect.complete = callback || options.complete;
5871
5872         return effect;
5873 }
5874
5875 function standardAnimationOption( option ) {
5876         // Valid standard speeds (nothing, number, named speed)
5877         if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
5878                 return true;
5879         }
5880
5881         // Invalid strings - treat as "normal" speed
5882         if ( typeof option === "string" && !$.effects.effect[ option ] ) {
5883                 return true;
5884         }
5885
5886         // Complete callback
5887         if ( $.isFunction( option ) ) {
5888                 return true;
5889         }
5890
5891         // Options hash (but not naming an effect)
5892         if ( typeof option === "object" && !option.effect ) {
5893                 return true;
5894         }
5895
5896         // Didn't match any standard API
5897         return false;
5898 }
5899
5900 $.fn.extend({
5901         effect: function( /* effect, options, speed, callback */ ) {
5902                 var args = _normalizeArguments.apply( this, arguments ),
5903                         mode = args.mode,
5904                         queue = args.queue,
5905                         effectMethod = $.effects.effect[ args.effect ];
5906
5907                 if ( $.fx.off || !effectMethod ) {
5908                         // delegate to the original method (e.g., .show()) if possible
5909                         if ( mode ) {
5910                                 return this[ mode ]( args.duration, args.complete );
5911                         } else {
5912                                 return this.each( function() {
5913                                         if ( args.complete ) {
5914                                                 args.complete.call( this );
5915                                         }
5916                                 });
5917                         }
5918                 }
5919
5920                 function run( next ) {
5921                         var elem = $( this ),
5922                                 complete = args.complete,
5923                                 mode = args.mode;
5924
5925                         function done() {
5926                                 if ( $.isFunction( complete ) ) {
5927                                         complete.call( elem[0] );
5928                                 }
5929                                 if ( $.isFunction( next ) ) {
5930                                         next();
5931                                 }
5932                         }
5933
5934                         // If the element already has the correct final state, delegate to
5935                         // the core methods so the internal tracking of "olddisplay" works.
5936                         if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
5937                                 elem[ mode ]();
5938                                 done();
5939                         } else {
5940                                 effectMethod.call( elem[0], args, done );
5941                         }
5942                 }
5943
5944                 return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
5945         },
5946
5947         show: (function( orig ) {
5948                 return function( option ) {
5949                         if ( standardAnimationOption( option ) ) {
5950                                 return orig.apply( this, arguments );
5951                         } else {
5952                                 var args = _normalizeArguments.apply( this, arguments );
5953                                 args.mode = "show";
5954                                 return this.effect.call( this, args );
5955                         }
5956                 };
5957         })( $.fn.show ),
5958
5959         hide: (function( orig ) {
5960                 return function( option ) {
5961                         if ( standardAnimationOption( option ) ) {
5962                                 return orig.apply( this, arguments );
5963                         } else {
5964                                 var args = _normalizeArguments.apply( this, arguments );
5965                                 args.mode = "hide";
5966                                 return this.effect.call( this, args );
5967                         }
5968                 };
5969         })( $.fn.hide ),
5970
5971         toggle: (function( orig ) {
5972                 return function( option ) {
5973                         if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
5974                                 return orig.apply( this, arguments );
5975                         } else {
5976                                 var args = _normalizeArguments.apply( this, arguments );
5977                                 args.mode = "toggle";
5978                                 return this.effect.call( this, args );
5979                         }
5980                 };
5981         })( $.fn.toggle ),
5982
5983         // helper functions
5984         cssUnit: function(key) {
5985                 var style = this.css( key ),
5986                         val = [];
5987
5988                 $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
5989                         if ( style.indexOf( unit ) > 0 ) {
5990                                 val = [ parseFloat( style ), unit ];
5991                         }
5992                 });
5993                 return val;
5994         }
5995 });
5996
5997 })();
5998
5999 /******************************************************************************/
6000 /*********************************** EASING ***********************************/
6001 /******************************************************************************/
6002
6003 (function() {
6004
6005 // based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
6006
6007 var baseEasings = {};
6008
6009 $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
6010         baseEasings[ name ] = function( p ) {
6011                 return Math.pow( p, i + 2 );
6012         };
6013 });
6014
6015 $.extend( baseEasings, {
6016         Sine: function ( p ) {
6017                 return 1 - Math.cos( p * Math.PI / 2 );
6018         },
6019         Circ: function ( p ) {
6020                 return 1 - Math.sqrt( 1 - p * p );
6021         },
6022         Elastic: function( p ) {
6023                 return p === 0 || p === 1 ? p :
6024                         -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
6025         },
6026         Back: function( p ) {
6027                 return p * p * ( 3 * p - 2 );
6028         },
6029         Bounce: function ( p ) {
6030                 var pow2,
6031                         bounce = 4;
6032
6033                 while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
6034                 return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
6035         }
6036 });
6037
6038 $.each( baseEasings, function( name, easeIn ) {
6039         $.easing[ "easeIn" + name ] = easeIn;
6040         $.easing[ "easeOut" + name ] = function( p ) {
6041                 return 1 - easeIn( 1 - p );
6042         };
6043         $.easing[ "easeInOut" + name ] = function( p ) {
6044                 return p < 0.5 ?
6045                         easeIn( p * 2 ) / 2 :
6046                         1 - easeIn( p * -2 + 2 ) / 2;
6047         };
6048 });
6049
6050 })();
6051
6052 })(jQuery);
6053
6054 (function( $, undefined ) {
6055
6056 var uid = 0,
6057         hideProps = {},
6058         showProps = {};
6059
6060 hideProps.height = hideProps.paddingTop = hideProps.paddingBottom =
6061         hideProps.borderTopWidth = hideProps.borderBottomWidth = "hide";
6062 showProps.height = showProps.paddingTop = showProps.paddingBottom =
6063         showProps.borderTopWidth = showProps.borderBottomWidth = "show";
6064
6065 $.widget( "ui.accordion", {
6066         version: "1.10.3",
6067         options: {
6068                 active: 0,
6069                 animate: {},
6070                 collapsible: false,
6071                 event: "click",
6072                 header: "> li > :first-child,> :not(li):even",
6073                 heightStyle: "auto",
6074                 icons: {
6075                         activeHeader: "ui-icon-triangle-1-s",
6076                         header: "ui-icon-triangle-1-e"
6077                 },
6078
6079                 // callbacks
6080                 activate: null,
6081                 beforeActivate: null
6082         },
6083
6084         _create: function() {
6085                 var options = this.options;
6086                 this.prevShow = this.prevHide = $();
6087                 this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
6088                         // ARIA
6089                         .attr( "role", "tablist" );
6090
6091                 // don't allow collapsible: false and active: false / null
6092                 if ( !options.collapsible && (options.active === false || options.active == null) ) {
6093                         options.active = 0;
6094                 }
6095
6096                 this._processPanels();
6097                 // handle negative values
6098                 if ( options.active < 0 ) {
6099                         options.active += this.headers.length;
6100                 }
6101                 this._refresh();
6102         },
6103
6104         _getCreateEventData: function() {
6105                 return {
6106                         header: this.active,
6107                         panel: !this.active.length ? $() : this.active.next(),
6108                         content: !this.active.length ? $() : this.active.next()
6109                 };
6110         },
6111
6112         _createIcons: function() {
6113                 var icons = this.options.icons;
6114                 if ( icons ) {
6115                         $( "<span>" )
6116                                 .addClass( "ui-accordion-header-icon ui-icon " + icons.header )
6117                                 .prependTo( this.headers );
6118                         this.active.children( ".ui-accordion-header-icon" )
6119                                 .removeClass( icons.header )
6120                                 .addClass( icons.activeHeader );
6121                         this.headers.addClass( "ui-accordion-icons" );
6122                 }
6123         },
6124
6125         _destroyIcons: function() {
6126                 this.headers
6127                         .removeClass( "ui-accordion-icons" )
6128                         .children( ".ui-accordion-header-icon" )
6129                                 .remove();
6130         },
6131
6132         _destroy: function() {
6133                 var contents;
6134
6135                 // clean up main element
6136                 this.element
6137                         .removeClass( "ui-accordion ui-widget ui-helper-reset" )
6138                         .removeAttr( "role" );
6139
6140                 // clean up headers
6141                 this.headers
6142                         .removeClass( "ui-accordion-header ui-accordion-header-active ui-helper-reset ui-state-default ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
6143                         .removeAttr( "role" )
6144                         .removeAttr( "aria-selected" )
6145                         .removeAttr( "aria-controls" )
6146                         .removeAttr( "tabIndex" )
6147                         .each(function() {
6148                                 if ( /^ui-accordion/.test( this.id ) ) {
6149                                         this.removeAttribute( "id" );
6150                                 }
6151                         });
6152                 this._destroyIcons();
6153
6154                 // clean up content panels
6155                 contents = this.headers.next()
6156                         .css( "display", "" )
6157                         .removeAttr( "role" )
6158                         .removeAttr( "aria-expanded" )
6159                         .removeAttr( "aria-hidden" )
6160                         .removeAttr( "aria-labelledby" )
6161                         .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active ui-state-disabled" )
6162                         .each(function() {
6163                                 if ( /^ui-accordion/.test( this.id ) ) {
6164                                         this.removeAttribute( "id" );
6165                                 }
6166                         });
6167                 if ( this.options.heightStyle !== "content" ) {
6168                         contents.css( "height", "" );
6169                 }
6170         },
6171
6172         _setOption: function( key, value ) {
6173                 if ( key === "active" ) {
6174                         // _activate() will handle invalid values and update this.options
6175                         this._activate( value );
6176                         return;
6177                 }
6178
6179                 if ( key === "event" ) {
6180                         if ( this.options.event ) {
6181                                 this._off( this.headers, this.options.event );
6182                         }
6183                         this._setupEvents( value );
6184                 }
6185
6186                 this._super( key, value );
6187
6188                 // setting collapsible: false while collapsed; open first panel
6189                 if ( key === "collapsible" && !value && this.options.active === false ) {
6190                         this._activate( 0 );
6191                 }
6192
6193                 if ( key === "icons" ) {
6194                         this._destroyIcons();
6195                         if ( value ) {
6196                                 this._createIcons();
6197                         }
6198                 }
6199
6200                 // #5332 - opacity doesn't cascade to positioned elements in IE
6201                 // so we need to add the disabled class to the headers and panels
6202                 if ( key === "disabled" ) {
6203                         this.headers.add( this.headers.next() )
6204                                 .toggleClass( "ui-state-disabled", !!value );
6205                 }
6206         },
6207
6208         _keydown: function( event ) {
6209                 /*jshint maxcomplexity:15*/
6210                 if ( event.altKey || event.ctrlKey ) {
6211                         return;
6212                 }
6213
6214                 var keyCode = $.ui.keyCode,
6215                         length = this.headers.length,
6216                         currentIndex = this.headers.index( event.target ),
6217                         toFocus = false;
6218
6219                 switch ( event.keyCode ) {
6220                         case keyCode.RIGHT:
6221                         case keyCode.DOWN:
6222                                 toFocus = this.headers[ ( currentIndex + 1 ) % length ];
6223                                 break;
6224                         case keyCode.LEFT:
6225                         case keyCode.UP:
6226                                 toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
6227                                 break;
6228                         case keyCode.SPACE:
6229                         case keyCode.ENTER:
6230                                 this._eventHandler( event );
6231                                 break;
6232                         case keyCode.HOME:
6233                                 toFocus = this.headers[ 0 ];
6234                                 break;
6235                         case keyCode.END:
6236                                 toFocus = this.headers[ length - 1 ];
6237                                 break;
6238                 }
6239
6240                 if ( toFocus ) {
6241                         $( event.target ).attr( "tabIndex", -1 );
6242                         $( toFocus ).attr( "tabIndex", 0 );
6243                         toFocus.focus();
6244                         event.preventDefault();
6245                 }
6246         },
6247
6248         _panelKeyDown : function( event ) {
6249                 if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
6250                         $( event.currentTarget ).prev().focus();
6251                 }
6252         },
6253
6254         refresh: function() {
6255                 var options = this.options;
6256                 this._processPanels();
6257
6258                 // was collapsed or no panel
6259                 if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
6260                         options.active = false;
6261                         this.active = $();
6262                 // active false only when collapsible is true
6263                 } else if ( options.active === false ) {
6264                         this._activate( 0 );
6265                 // was active, but active panel is gone
6266                 } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
6267                         // all remaining panel are disabled
6268                         if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
6269                                 options.active = false;
6270                                 this.active = $();
6271                         // activate previous panel
6272                         } else {
6273                                 this._activate( Math.max( 0, options.active - 1 ) );
6274                         }
6275                 // was active, active panel still exists
6276                 } else {
6277                         // make sure active index is correct
6278                         options.active = this.headers.index( this.active );
6279                 }
6280
6281                 this._destroyIcons();
6282
6283                 this._refresh();
6284         },
6285
6286         _processPanels: function() {
6287                 this.headers = this.element.find( this.options.header )
6288                         .addClass( "ui-accordion-header ui-helper-reset ui-state-default ui-corner-all" );
6289
6290                 this.headers.next()
6291                         .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
6292                         .filter(":not(.ui-accordion-content-active)")
6293                         .hide();
6294         },
6295
6296         _refresh: function() {
6297                 var maxHeight,
6298                         options = this.options,
6299                         heightStyle = options.heightStyle,
6300                         parent = this.element.parent(),
6301                         accordionId = this.accordionId = "ui-accordion-" +
6302                                 (this.element.attr( "id" ) || ++uid);
6303
6304                 this.active = this._findActive( options.active )
6305                         .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
6306                         .removeClass( "ui-corner-all" );
6307                 this.active.next()
6308                         .addClass( "ui-accordion-content-active" )
6309                         .show();
6310
6311                 this.headers
6312                         .attr( "role", "tab" )
6313                         .each(function( i ) {
6314                                 var header = $( this ),
6315                                         headerId = header.attr( "id" ),
6316                                         panel = header.next(),
6317                                         panelId = panel.attr( "id" );
6318                                 if ( !headerId ) {
6319                                         headerId = accordionId + "-header-" + i;
6320                                         header.attr( "id", headerId );
6321                                 }
6322                                 if ( !panelId ) {
6323                                         panelId = accordionId + "-panel-" + i;
6324                                         panel.attr( "id", panelId );
6325                                 }
6326                                 header.attr( "aria-controls", panelId );
6327                                 panel.attr( "aria-labelledby", headerId );
6328                         })
6329                         .next()
6330                                 .attr( "role", "tabpanel" );
6331
6332                 this.headers
6333                         .not( this.active )
6334                         .attr({
6335                                 "aria-selected": "false",
6336                                 tabIndex: -1
6337                         })
6338                         .next()
6339                                 .attr({
6340                                         "aria-expanded": "false",
6341                                         "aria-hidden": "true"
6342                                 })
6343                                 .hide();
6344
6345                 // make sure at least one header is in the tab order
6346                 if ( !this.active.length ) {
6347                         this.headers.eq( 0 ).attr( "tabIndex", 0 );
6348                 } else {
6349                         this.active.attr({
6350                                 "aria-selected": "true",
6351                                 tabIndex: 0
6352                         })
6353                         .next()
6354                                 .attr({
6355                                         "aria-expanded": "true",
6356                                         "aria-hidden": "false"
6357                                 });
6358                 }
6359
6360                 this._createIcons();
6361
6362                 this._setupEvents( options.event );
6363
6364                 if ( heightStyle === "fill" ) {
6365                         maxHeight = parent.height();
6366                         this.element.siblings( ":visible" ).each(function() {
6367                                 var elem = $( this ),
6368                                         position = elem.css( "position" );
6369
6370                                 if ( position === "absolute" || position === "fixed" ) {
6371                                         return;
6372                                 }
6373                                 maxHeight -= elem.outerHeight( true );
6374                         });
6375
6376                         this.headers.each(function() {
6377                                 maxHeight -= $( this ).outerHeight( true );
6378                         });
6379
6380                         this.headers.next()
6381                                 .each(function() {
6382                                         $( this ).height( Math.max( 0, maxHeight -
6383                                                 $( this ).innerHeight() + $( this ).height() ) );
6384                                 })
6385                                 .css( "overflow", "auto" );
6386                 } else if ( heightStyle === "auto" ) {
6387                         maxHeight = 0;
6388                         this.headers.next()
6389                                 .each(function() {
6390                                         maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
6391                                 })
6392                                 .height( maxHeight );
6393                 }
6394         },
6395
6396         _activate: function( index ) {
6397                 var active = this._findActive( index )[ 0 ];
6398
6399                 // trying to activate the already active panel
6400                 if ( active === this.active[ 0 ] ) {
6401                         return;
6402                 }
6403
6404                 // trying to collapse, simulate a click on the currently active header
6405                 active = active || this.active[ 0 ];
6406
6407                 this._eventHandler({
6408                         target: active,
6409                         currentTarget: active,
6410                         preventDefault: $.noop
6411                 });
6412         },
6413
6414         _findActive: function( selector ) {
6415                 return typeof selector === "number" ? this.headers.eq( selector ) : $();
6416         },
6417
6418         _setupEvents: function( event ) {
6419                 var events = {
6420                         keydown: "_keydown"
6421                 };
6422                 if ( event ) {
6423                         $.each( event.split(" "), function( index, eventName ) {
6424                                 events[ eventName ] = "_eventHandler";
6425                         });
6426                 }
6427
6428                 this._off( this.headers.add( this.headers.next() ) );
6429                 this._on( this.headers, events );
6430                 this._on( this.headers.next(), { keydown: "_panelKeyDown" });
6431                 this._hoverable( this.headers );
6432                 this._focusable( this.headers );
6433         },
6434
6435         _eventHandler: function( event ) {
6436                 var options = this.options,
6437                         active = this.active,
6438                         clicked = $( event.currentTarget ),
6439                         clickedIsActive = clicked[ 0 ] === active[ 0 ],
6440                         collapsing = clickedIsActive && options.collapsible,
6441                         toShow = collapsing ? $() : clicked.next(),
6442                         toHide = active.next(),
6443                         eventData = {
6444                                 oldHeader: active,
6445                                 oldPanel: toHide,
6446                                 newHeader: collapsing ? $() : clicked,
6447                                 newPanel: toShow
6448                         };
6449
6450                 event.preventDefault();
6451
6452                 if (
6453                                 // click on active header, but not collapsible
6454                                 ( clickedIsActive && !options.collapsible ) ||
6455                                 // allow canceling activation
6456                                 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
6457                         return;
6458                 }
6459
6460                 options.active = collapsing ? false : this.headers.index( clicked );
6461
6462                 // when the call to ._toggle() comes after the class changes
6463                 // it causes a very odd bug in IE 8 (see #6720)
6464                 this.active = clickedIsActive ? $() : clicked;
6465                 this._toggle( eventData );
6466
6467                 // switch classes
6468                 // corner classes on the previously active header stay after the animation
6469                 active.removeClass( "ui-accordion-header-active ui-state-active" );
6470                 if ( options.icons ) {
6471                         active.children( ".ui-accordion-header-icon" )
6472                                 .removeClass( options.icons.activeHeader )
6473                                 .addClass( options.icons.header );
6474                 }
6475
6476                 if ( !clickedIsActive ) {
6477                         clicked
6478                                 .removeClass( "ui-corner-all" )
6479                                 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
6480                         if ( options.icons ) {
6481                                 clicked.children( ".ui-accordion-header-icon" )
6482                                         .removeClass( options.icons.header )
6483                                         .addClass( options.icons.activeHeader );
6484                         }
6485
6486                         clicked
6487                                 .next()
6488                                 .addClass( "ui-accordion-content-active" );
6489                 }
6490         },
6491
6492         _toggle: function( data ) {
6493                 var toShow = data.newPanel,
6494                         toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
6495
6496                 // handle activating a panel during the animation for another activation
6497                 this.prevShow.add( this.prevHide ).stop( true, true );
6498                 this.prevShow = toShow;
6499                 this.prevHide = toHide;
6500
6501                 if ( this.options.animate ) {
6502                         this._animate( toShow, toHide, data );
6503                 } else {
6504                         toHide.hide();
6505                         toShow.show();
6506                         this._toggleComplete( data );
6507                 }
6508
6509                 toHide.attr({
6510                         "aria-expanded": "false",
6511                         "aria-hidden": "true"
6512                 });
6513                 toHide.prev().attr( "aria-selected", "false" );
6514                 // if we're switching panels, remove the old header from the tab order
6515                 // if we're opening from collapsed state, remove the previous header from the tab order
6516                 // if we're collapsing, then keep the collapsing header in the tab order
6517                 if ( toShow.length && toHide.length ) {
6518                         toHide.prev().attr( "tabIndex", -1 );
6519                 } else if ( toShow.length ) {
6520                         this.headers.filter(function() {
6521                                 return $( this ).attr( "tabIndex" ) === 0;
6522                         })
6523                         .attr( "tabIndex", -1 );
6524                 }
6525
6526                 toShow
6527                         .attr({
6528                                 "aria-expanded": "true",
6529                                 "aria-hidden": "false"
6530                         })
6531                         .prev()
6532                                 .attr({
6533                                         "aria-selected": "true",
6534                                         tabIndex: 0
6535                                 });
6536         },
6537
6538         _animate: function( toShow, toHide, data ) {
6539                 var total, easing, duration,
6540                         that = this,
6541                         adjust = 0,
6542                         down = toShow.length &&
6543                                 ( !toHide.length || ( toShow.index() < toHide.index() ) ),
6544                         animate = this.options.animate || {},
6545                         options = down && animate.down || animate,
6546                         complete = function() {
6547                                 that._toggleComplete( data );
6548                         };
6549
6550                 if ( typeof options === "number" ) {
6551                         duration = options;
6552                 }
6553                 if ( typeof options === "string" ) {
6554                         easing = options;
6555                 }
6556                 // fall back from options to animation in case of partial down settings
6557                 easing = easing || options.easing || animate.easing;
6558                 duration = duration || options.duration || animate.duration;
6559
6560                 if ( !toHide.length ) {
6561                         return toShow.animate( showProps, duration, easing, complete );
6562                 }
6563                 if ( !toShow.length ) {
6564                         return toHide.animate( hideProps, duration, easing, complete );
6565                 }
6566
6567                 total = toShow.show().outerHeight();
6568                 toHide.animate( hideProps, {
6569                         duration: duration,
6570                         easing: easing,
6571                         step: function( now, fx ) {
6572                                 fx.now = Math.round( now );
6573                         }
6574                 });
6575                 toShow
6576                         .hide()
6577                         .animate( showProps, {
6578                                 duration: duration,
6579                                 easing: easing,
6580                                 complete: complete,
6581                                 step: function( now, fx ) {
6582                                         fx.now = Math.round( now );
6583                                         if ( fx.prop !== "height" ) {
6584                                                 adjust += fx.now;
6585                                         } else if ( that.options.heightStyle !== "content" ) {
6586                                                 fx.now = Math.round( total - toHide.outerHeight() - adjust );
6587                                                 adjust = 0;
6588                                         }
6589                                 }
6590                         });
6591         },
6592
6593         _toggleComplete: function( data ) {
6594                 var toHide = data.oldPanel;
6595
6596                 toHide
6597                         .removeClass( "ui-accordion-content-active" )
6598                         .prev()
6599                                 .removeClass( "ui-corner-top" )
6600                                 .addClass( "ui-corner-all" );
6601
6602                 // Work around for rendering bug in IE (#5421)
6603                 if ( toHide.length ) {
6604                         toHide.parent()[0].className = toHide.parent()[0].className;
6605                 }
6606
6607                 this._trigger( "activate", null, data );
6608         }
6609 });
6610
6611 })( jQuery );
6612
6613 (function( $, undefined ) {
6614
6615 // used to prevent race conditions with remote data sources
6616 var requestIndex = 0;
6617
6618 $.widget( "ui.autocomplete", {
6619         version: "1.10.3",
6620         defaultElement: "<input>",
6621         options: {
6622                 appendTo: null,
6623                 autoFocus: false,
6624                 delay: 300,
6625                 minLength: 1,
6626                 position: {
6627                         my: "left top",
6628                         at: "left bottom",
6629                         collision: "none"
6630                 },
6631                 source: null,
6632
6633                 // callbacks
6634                 change: null,
6635                 close: null,
6636                 focus: null,
6637                 open: null,
6638                 response: null,
6639                 search: null,
6640                 select: null
6641         },
6642
6643         pending: 0,
6644
6645         _create: function() {
6646                 // Some browsers only repeat keydown events, not keypress events,
6647                 // so we use the suppressKeyPress flag to determine if we've already
6648                 // handled the keydown event. #7269
6649                 // Unfortunately the code for & in keypress is the same as the up arrow,
6650                 // so we use the suppressKeyPressRepeat flag to avoid handling keypress
6651                 // events when we know the keydown event was used to modify the
6652                 // search term. #7799
6653                 var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
6654                         nodeName = this.element[0].nodeName.toLowerCase(),
6655                         isTextarea = nodeName === "textarea",
6656                         isInput = nodeName === "input";
6657
6658                 this.isMultiLine =
6659                         // Textareas are always multi-line
6660                         isTextarea ? true :
6661                         // Inputs are always single-line, even if inside a contentEditable element
6662                         // IE also treats inputs as contentEditable
6663                         isInput ? false :
6664                         // All other element types are determined by whether or not they're contentEditable
6665                         this.element.prop( "isContentEditable" );
6666
6667                 this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
6668                 this.isNewMenu = true;
6669
6670                 this.element
6671                         .addClass( "ui-autocomplete-input" )
6672                         .attr( "autocomplete", "off" );
6673
6674                 this._on( this.element, {
6675                         keydown: function( event ) {
6676                                 /*jshint maxcomplexity:15*/
6677                                 if ( this.element.prop( "readOnly" ) ) {
6678                                         suppressKeyPress = true;
6679                                         suppressInput = true;
6680                                         suppressKeyPressRepeat = true;
6681                                         return;
6682                                 }
6683
6684                                 suppressKeyPress = false;
6685                                 suppressInput = false;
6686                                 suppressKeyPressRepeat = false;
6687                                 var keyCode = $.ui.keyCode;
6688                                 switch( event.keyCode ) {
6689                                 case keyCode.PAGE_UP:
6690                                         suppressKeyPress = true;
6691                                         this._move( "previousPage", event );
6692                                         break;
6693                                 case keyCode.PAGE_DOWN:
6694                                         suppressKeyPress = true;
6695                                         this._move( "nextPage", event );
6696                                         break;
6697                                 case keyCode.UP:
6698                                         suppressKeyPress = true;
6699                                         this._keyEvent( "previous", event );
6700                                         break;
6701                                 case keyCode.DOWN:
6702                                         suppressKeyPress = true;
6703                                         this._keyEvent( "next", event );
6704                                         break;
6705                                 case keyCode.ENTER:
6706                                 case keyCode.NUMPAD_ENTER:
6707                                         // when menu is open and has focus
6708                                         if ( this.menu.active ) {
6709                                                 // #6055 - Opera still allows the keypress to occur
6710                                                 // which causes forms to submit
6711                                                 suppressKeyPress = true;
6712                                                 event.preventDefault();
6713                                                 this.menu.select( event );
6714                                         }
6715                                         break;
6716                                 case keyCode.TAB:
6717                                         if ( this.menu.active ) {
6718                                                 this.menu.select( event );
6719                                         }
6720                                         break;
6721                                 case keyCode.ESCAPE:
6722                                         if ( this.menu.element.is( ":visible" ) ) {
6723                                                 this._value( this.term );
6724                                                 this.close( event );
6725                                                 // Different browsers have different default behavior for escape
6726                                                 // Single press can mean undo or clear
6727                                                 // Double press in IE means clear the whole form
6728                                                 event.preventDefault();
6729                                         }
6730                                         break;
6731                                 default:
6732                                         suppressKeyPressRepeat = true;
6733                                         // search timeout should be triggered before the input value is changed
6734                                         this._searchTimeout( event );
6735                                         break;
6736                                 }
6737                         },
6738                         keypress: function( event ) {
6739                                 if ( suppressKeyPress ) {
6740                                         suppressKeyPress = false;
6741                                         if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
6742                                                 event.preventDefault();
6743                                         }
6744                                         return;
6745                                 }
6746                                 if ( suppressKeyPressRepeat ) {
6747                                         return;
6748                                 }
6749
6750                                 // replicate some key handlers to allow them to repeat in Firefox and Opera
6751                                 var keyCode = $.ui.keyCode;
6752                                 switch( event.keyCode ) {
6753                                 case keyCode.PAGE_UP:
6754                                         this._move( "previousPage", event );
6755                                         break;
6756                                 case keyCode.PAGE_DOWN:
6757                                         this._move( "nextPage", event );
6758                                         break;
6759                                 case keyCode.UP:
6760                                         this._keyEvent( "previous", event );
6761                                         break;
6762                                 case keyCode.DOWN:
6763                                         this._keyEvent( "next", event );
6764                                         break;
6765                                 }
6766                         },
6767                         input: function( event ) {
6768                                 if ( suppressInput ) {
6769                                         suppressInput = false;
6770                                         event.preventDefault();
6771                                         return;
6772                                 }
6773                                 this._searchTimeout( event );
6774                         },
6775                         focus: function() {
6776                                 this.selectedItem = null;
6777                                 this.previous = this._value();
6778                         },
6779                         blur: function( event ) {
6780                                 if ( this.cancelBlur ) {
6781                                         delete this.cancelBlur;
6782                                         return;
6783                                 }
6784
6785                                 clearTimeout( this.searching );
6786                                 this.close( event );
6787                                 this._change( event );
6788                         }
6789                 });
6790
6791                 this._initSource();
6792                 this.menu = $( "<ul>" )
6793                         .addClass( "ui-autocomplete ui-front" )
6794                         .appendTo( this._appendTo() )
6795                         .menu({
6796                                 // disable ARIA support, the live region takes care of that
6797                                 role: null
6798                         })
6799                         .hide()
6800                         .data( "ui-menu" );
6801
6802                 this._on( this.menu.element, {
6803                         mousedown: function( event ) {
6804                                 // prevent moving focus out of the text field
6805                                 event.preventDefault();
6806
6807                                 // IE doesn't prevent moving focus even with event.preventDefault()
6808                                 // so we set a flag to know when we should ignore the blur event
6809                                 this.cancelBlur = true;
6810                                 this._delay(function() {
6811                                         delete this.cancelBlur;
6812                                 });
6813
6814                                 // clicking on the scrollbar causes focus to shift to the body
6815                                 // but we can't detect a mouseup or a click immediately afterward
6816                                 // so we have to track the next mousedown and close the menu if
6817                                 // the user clicks somewhere outside of the autocomplete
6818                                 var menuElement = this.menu.element[ 0 ];
6819                                 if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
6820                                         this._delay(function() {
6821                                                 var that = this;
6822                                                 this.document.one( "mousedown", function( event ) {
6823                                                         if ( event.target !== that.element[ 0 ] &&
6824                                                                         event.target !== menuElement &&
6825                                                                         !$.contains( menuElement, event.target ) ) {
6826                                                                 that.close();
6827                                                         }
6828                                                 });
6829                                         });
6830                                 }
6831                         },
6832                         menufocus: function( event, ui ) {
6833                                 // support: Firefox
6834                                 // Prevent accidental activation of menu items in Firefox (#7024 #9118)
6835                                 if ( this.isNewMenu ) {
6836                                         this.isNewMenu = false;
6837                                         if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
6838                                                 this.menu.blur();
6839
6840                                                 this.document.one( "mousemove", function() {
6841                                                         $( event.target ).trigger( event.originalEvent );
6842                                                 });
6843
6844                                                 return;
6845                                         }
6846                                 }
6847
6848                                 var item = ui.item.data( "ui-autocomplete-item" );
6849                                 if ( false !== this._trigger( "focus", event, { item: item } ) ) {
6850                                         // use value to match what will end up in the input, if it was a key event
6851                                         if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
6852                                                 this._value( item.value );
6853                                         }
6854                                 } else {
6855                                         // Normally the input is populated with the item's value as the
6856                                         // menu is navigated, causing screen readers to notice a change and
6857                                         // announce the item. Since the focus event was canceled, this doesn't
6858                                         // happen, so we update the live region so that screen readers can
6859                                         // still notice the change and announce it.
6860                                         this.liveRegion.text( item.value );
6861                                 }
6862                         },
6863                         menuselect: function( event, ui ) {
6864                                 var item = ui.item.data( "ui-autocomplete-item" ),
6865                                         previous = this.previous;
6866
6867                                 // only trigger when focus was lost (click on menu)
6868                                 if ( this.element[0] !== this.document[0].activeElement ) {
6869                                         this.element.focus();
6870                                         this.previous = previous;
6871                                         // #6109 - IE triggers two focus events and the second
6872                                         // is asynchronous, so we need to reset the previous
6873                                         // term synchronously and asynchronously :-(
6874                                         this._delay(function() {
6875                                                 this.previous = previous;
6876                                                 this.selectedItem = item;
6877                                         });
6878                                 }
6879
6880                                 if ( false !== this._trigger( "select", event, { item: item } ) ) {
6881                                         this._value( item.value );
6882                                 }
6883                                 // reset the term after the select event
6884                                 // this allows custom select handling to work properly
6885                                 this.term = this._value();
6886
6887                                 this.close( event );
6888                                 this.selectedItem = item;
6889                         }
6890                 });
6891
6892                 this.liveRegion = $( "<span>", {
6893                                 role: "status",
6894                                 "aria-live": "polite"
6895                         })
6896                         .addClass( "ui-helper-hidden-accessible" )
6897                         .insertBefore( this.element );
6898
6899                 // turning off autocomplete prevents the browser from remembering the
6900                 // value when navigating through history, so we re-enable autocomplete
6901                 // if the page is unloaded before the widget is destroyed. #7790
6902                 this._on( this.window, {
6903                         beforeunload: function() {
6904                                 this.element.removeAttr( "autocomplete" );
6905                         }
6906                 });
6907         },
6908
6909         _destroy: function() {
6910                 clearTimeout( this.searching );
6911                 this.element
6912                         .removeClass( "ui-autocomplete-input" )
6913                         .removeAttr( "autocomplete" );
6914                 this.menu.element.remove();
6915                 this.liveRegion.remove();
6916         },
6917
6918         _setOption: function( key, value ) {
6919                 this._super( key, value );
6920                 if ( key === "source" ) {
6921                         this._initSource();
6922                 }
6923                 if ( key === "appendTo" ) {
6924                         this.menu.element.appendTo( this._appendTo() );
6925                 }
6926                 if ( key === "disabled" && value && this.xhr ) {
6927                         this.xhr.abort();
6928                 }
6929         },
6930
6931         _appendTo: function() {
6932                 var element = this.options.appendTo;
6933
6934                 if ( element ) {
6935                         element = element.jquery || element.nodeType ?
6936                                 $( element ) :
6937                                 this.document.find( element ).eq( 0 );
6938                 }
6939
6940                 if ( !element ) {
6941                         element = this.element.closest( ".ui-front" );
6942                 }
6943
6944                 if ( !element.length ) {
6945                         element = this.document[0].body;
6946                 }
6947
6948                 return element;
6949         },
6950
6951         _initSource: function() {
6952                 var array, url,
6953                         that = this;
6954                 if ( $.isArray(this.options.source) ) {
6955                         array = this.options.source;
6956                         this.source = function( request, response ) {
6957                                 response( $.ui.autocomplete.filter( array, request.term ) );
6958                         };
6959                 } else if ( typeof this.options.source === "string" ) {
6960                         url = this.options.source;
6961                         this.source = function( request, response ) {
6962                                 if ( that.xhr ) {
6963                                         that.xhr.abort();
6964                                 }
6965                                 that.xhr = $.ajax({
6966                                         url: url,
6967                                         data: request,
6968                                         dataType: "json",
6969                                         success: function( data ) {
6970                                                 response( data );
6971                                         },
6972                                         error: function() {
6973                                                 response( [] );
6974                                         }
6975                                 });
6976                         };
6977                 } else {
6978                         this.source = this.options.source;
6979                 }
6980         },
6981
6982         _searchTimeout: function( event ) {
6983                 clearTimeout( this.searching );
6984                 this.searching = this._delay(function() {
6985                         // only search if the value has changed
6986                         if ( this.term !== this._value() ) {
6987                                 this.selectedItem = null;
6988                                 this.search( null, event );
6989                         }
6990                 }, this.options.delay );
6991         },
6992
6993         search: function( value, event ) {
6994                 value = value != null ? value : this._value();
6995
6996                 // always save the actual value, not the one passed as an argument
6997                 this.term = this._value();
6998
6999                 if ( value.length < this.options.minLength ) {
7000                         return this.close( event );
7001                 }
7002
7003                 if ( this._trigger( "search", event ) === false ) {
7004                         return;
7005                 }
7006
7007                 return this._search( value );
7008         },
7009
7010         _search: function( value ) {
7011                 this.pending++;
7012                 this.element.addClass( "ui-autocomplete-loading" );
7013                 this.cancelSearch = false;
7014
7015                 this.source( { term: value }, this._response() );
7016         },
7017
7018         _response: function() {
7019                 var that = this,
7020                         index = ++requestIndex;
7021
7022                 return function( content ) {
7023                         if ( index === requestIndex ) {
7024                                 that.__response( content );
7025                         }
7026
7027                         that.pending--;
7028                         if ( !that.pending ) {
7029                                 that.element.removeClass( "ui-autocomplete-loading" );
7030                         }
7031                 };
7032         },
7033
7034         __response: function( content ) {
7035                 if ( content ) {
7036                         content = this._normalize( content );
7037                 }
7038                 this._trigger( "response", null, { content: content } );
7039                 if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
7040                         this._suggest( content );
7041                         this._trigger( "open" );
7042                 } else {
7043                         // use ._close() instead of .close() so we don't cancel future searches
7044                         this._close();
7045                 }
7046         },
7047
7048         close: function( event ) {
7049                 this.cancelSearch = true;
7050                 this._close( event );
7051         },
7052
7053         _close: function( event ) {
7054                 if ( this.menu.element.is( ":visible" ) ) {
7055                         this.menu.element.hide();
7056                         this.menu.blur();
7057                         this.isNewMenu = true;
7058                         this._trigger( "close", event );
7059                 }
7060         },
7061
7062         _change: function( event ) {
7063                 if ( this.previous !== this._value() ) {
7064                         this._trigger( "change", event, { item: this.selectedItem } );
7065                 }
7066         },
7067
7068         _normalize: function( items ) {
7069                 // assume all items have the right format when the first item is complete
7070                 if ( items.length && items[0].label && items[0].value ) {
7071                         return items;
7072                 }
7073                 return $.map( items, function( item ) {
7074                         if ( typeof item === "string" ) {
7075                                 return {
7076                                         label: item,
7077                                         value: item
7078                                 };
7079                         }
7080                         return $.extend({
7081                                 label: item.label || item.value,
7082                                 value: item.value || item.label
7083                         }, item );
7084                 });
7085         },
7086
7087         _suggest: function( items ) {
7088                 var ul = this.menu.element.empty();
7089                 this._renderMenu( ul, items );
7090                 this.isNewMenu = true;
7091                 this.menu.refresh();
7092
7093                 // size and position menu
7094                 ul.show();
7095                 this._resizeMenu();
7096                 ul.position( $.extend({
7097                         of: this.element
7098                 }, this.options.position ));
7099
7100                 if ( this.options.autoFocus ) {
7101                         this.menu.next();
7102                 }
7103         },
7104
7105         _resizeMenu: function() {
7106                 var ul = this.menu.element;
7107                 ul.outerWidth( Math.max(
7108                         // Firefox wraps long text (possibly a rounding bug)
7109                         // so we add 1px to avoid the wrapping (#7513)
7110                         ul.width( "" ).outerWidth() + 1,
7111                         this.element.outerWidth()
7112                 ) );
7113         },
7114
7115         _renderMenu: function( ul, items ) {
7116                 var that = this;
7117                 $.each( items, function( index, item ) {
7118                         that._renderItemData( ul, item );
7119                 });
7120         },
7121
7122         _renderItemData: function( ul, item ) {
7123                 return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
7124         },
7125
7126         _renderItem: function( ul, item ) {
7127                 return $( "<li>" )
7128                         .append( $( "<a>" ).text( item.label ) )
7129                         .appendTo( ul );
7130         },
7131
7132         _move: function( direction, event ) {
7133                 if ( !this.menu.element.is( ":visible" ) ) {
7134                         this.search( null, event );
7135                         return;
7136                 }
7137                 if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
7138                                 this.menu.isLastItem() && /^next/.test( direction ) ) {
7139                         this._value( this.term );
7140                         this.menu.blur();
7141                         return;
7142                 }
7143                 this.menu[ direction ]( event );
7144         },
7145
7146         widget: function() {
7147                 return this.menu.element;
7148         },
7149
7150         _value: function() {
7151                 return this.valueMethod.apply( this.element, arguments );
7152         },
7153
7154         _keyEvent: function( keyEvent, event ) {
7155                 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
7156                         this._move( keyEvent, event );
7157
7158                         // prevents moving cursor to beginning/end of the text field in some browsers
7159                         event.preventDefault();
7160                 }
7161         }
7162 });
7163
7164 $.extend( $.ui.autocomplete, {
7165         escapeRegex: function( value ) {
7166                 return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
7167         },
7168         filter: function(array, term) {
7169                 var matcher = new RegExp( $.ui.autocomplete.escapeRegex(term), "i" );
7170                 return $.grep( array, function(value) {
7171                         return matcher.test( value.label || value.value || value );
7172                 });
7173         }
7174 });
7175
7176
7177 // live region extension, adding a `messages` option
7178 // NOTE: This is an experimental API. We are still investigating
7179 // a full solution for string manipulation and internationalization.
7180 $.widget( "ui.autocomplete", $.ui.autocomplete, {
7181         options: {
7182                 messages: {
7183                         noResults: "No search results.",
7184                         results: function( amount ) {
7185                                 return amount + ( amount > 1 ? " results are" : " result is" ) +
7186                                         " available, use up and down arrow keys to navigate.";
7187                         }
7188                 }
7189         },
7190
7191         __response: function( content ) {
7192                 var message;
7193                 this._superApply( arguments );
7194                 if ( this.options.disabled || this.cancelSearch ) {
7195                         return;
7196                 }
7197                 if ( content && content.length ) {
7198                         message = this.options.messages.results( content.length );
7199                 } else {
7200                         message = this.options.messages.noResults;
7201                 }
7202                 this.liveRegion.text( message );
7203         }
7204 });
7205
7206 }( jQuery ));
7207
7208 (function( $, undefined ) {
7209
7210 var lastActive, startXPos, startYPos, clickDragged,
7211         baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
7212         stateClasses = "ui-state-hover ui-state-active ",
7213         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",
7214         formResetHandler = function() {
7215                 var form = $( this );
7216                 setTimeout(function() {
7217                         form.find( ":ui-button" ).button( "refresh" );
7218                 }, 1 );
7219         },
7220         radioGroup = function( radio ) {
7221                 var name = radio.name,
7222                         form = radio.form,
7223                         radios = $( [] );
7224                 if ( name ) {
7225                         name = name.replace( /'/g, "\\'" );
7226                         if ( form ) {
7227                                 radios = $( form ).find( "[name='" + name + "']" );
7228                         } else {
7229                                 radios = $( "[name='" + name + "']", radio.ownerDocument )
7230                                         .filter(function() {
7231                                                 return !this.form;
7232                                         });
7233                         }
7234                 }
7235                 return radios;
7236         };
7237
7238 $.widget( "ui.button", {
7239         version: "1.10.3",
7240         defaultElement: "<button>",
7241         options: {
7242                 disabled: null,
7243                 text: true,
7244                 label: null,
7245                 icons: {
7246                         primary: null,
7247                         secondary: null
7248                 }
7249         },
7250         _create: function() {
7251                 this.element.closest( "form" )
7252                         .unbind( "reset" + this.eventNamespace )
7253                         .bind( "reset" + this.eventNamespace, formResetHandler );
7254
7255                 if ( typeof this.options.disabled !== "boolean" ) {
7256                         this.options.disabled = !!this.element.prop( "disabled" );
7257                 } else {
7258                         this.element.prop( "disabled", this.options.disabled );
7259                 }
7260
7261                 this._determineButtonType();
7262                 this.hasTitle = !!this.buttonElement.attr( "title" );
7263
7264                 var that = this,
7265                         options = this.options,
7266                         toggleButton = this.type === "checkbox" || this.type === "radio",
7267                         activeClass = !toggleButton ? "ui-state-active" : "",
7268                         focusClass = "ui-state-focus";
7269
7270                 if ( options.label === null ) {
7271                         options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
7272                 }
7273
7274                 this._hoverable( this.buttonElement );
7275
7276                 this.buttonElement
7277                         .addClass( baseClasses )
7278                         .attr( "role", "button" )
7279                         .bind( "mouseenter" + this.eventNamespace, function() {
7280                                 if ( options.disabled ) {
7281                                         return;
7282                                 }
7283                                 if ( this === lastActive ) {
7284                                         $( this ).addClass( "ui-state-active" );
7285                                 }
7286                         })
7287                         .bind( "mouseleave" + this.eventNamespace, function() {
7288                                 if ( options.disabled ) {
7289                                         return;
7290                                 }
7291                                 $( this ).removeClass( activeClass );
7292                         })
7293                         .bind( "click" + this.eventNamespace, function( event ) {
7294                                 if ( options.disabled ) {
7295                                         event.preventDefault();
7296                                         event.stopImmediatePropagation();
7297                                 }
7298                         });
7299
7300                 this.element
7301                         .bind( "focus" + this.eventNamespace, function() {
7302                                 // no need to check disabled, focus won't be triggered anyway
7303                                 that.buttonElement.addClass( focusClass );
7304                         })
7305                         .bind( "blur" + this.eventNamespace, function() {
7306                                 that.buttonElement.removeClass( focusClass );
7307                         });
7308
7309                 if ( toggleButton ) {
7310                         this.element.bind( "change" + this.eventNamespace, function() {
7311                                 if ( clickDragged ) {
7312                                         return;
7313                                 }
7314                                 that.refresh();
7315                         });
7316                         // if mouse moves between mousedown and mouseup (drag) set clickDragged flag
7317                         // prevents issue where button state changes but checkbox/radio checked state
7318                         // does not in Firefox (see ticket #6970)
7319                         this.buttonElement
7320                                 .bind( "mousedown" + this.eventNamespace, function( event ) {
7321                                         if ( options.disabled ) {
7322                                                 return;
7323                                         }
7324                                         clickDragged = false;
7325                                         startXPos = event.pageX;
7326                                         startYPos = event.pageY;
7327                                 })
7328                                 .bind( "mouseup" + this.eventNamespace, function( event ) {
7329                                         if ( options.disabled ) {
7330                                                 return;
7331                                         }
7332                                         if ( startXPos !== event.pageX || startYPos !== event.pageY ) {
7333                                                 clickDragged = true;
7334                                         }
7335                         });
7336                 }
7337
7338                 if ( this.type === "checkbox" ) {
7339                         this.buttonElement.bind( "click" + this.eventNamespace, function() {
7340                                 if ( options.disabled || clickDragged ) {
7341                                         return false;
7342                                 }
7343                         });
7344                 } else if ( this.type === "radio" ) {
7345                         this.buttonElement.bind( "click" + this.eventNamespace, function() {
7346                                 if ( options.disabled || clickDragged ) {
7347                                         return false;
7348                                 }
7349                                 $( this ).addClass( "ui-state-active" );
7350                                 that.buttonElement.attr( "aria-pressed", "true" );
7351
7352                                 var radio = that.element[ 0 ];
7353                                 radioGroup( radio )
7354                                         .not( radio )
7355                                         .map(function() {
7356                                                 return $( this ).button( "widget" )[ 0 ];
7357                                         })
7358                                         .removeClass( "ui-state-active" )
7359                                         .attr( "aria-pressed", "false" );
7360                         });
7361                 } else {
7362                         this.buttonElement
7363                                 .bind( "mousedown" + this.eventNamespace, function() {
7364                                         if ( options.disabled ) {
7365                                                 return false;
7366                                         }
7367                                         $( this ).addClass( "ui-state-active" );
7368                                         lastActive = this;
7369                                         that.document.one( "mouseup", function() {
7370                                                 lastActive = null;
7371                                         });
7372                                 })
7373                                 .bind( "mouseup" + this.eventNamespace, function() {
7374                                         if ( options.disabled ) {
7375                                                 return false;
7376                                         }
7377                                         $( this ).removeClass( "ui-state-active" );
7378                                 })
7379                                 .bind( "keydown" + this.eventNamespace, function(event) {
7380                                         if ( options.disabled ) {
7381                                                 return false;
7382                                         }
7383                                         if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
7384                                                 $( this ).addClass( "ui-state-active" );
7385                                         }
7386                                 })
7387                                 // see #8559, we bind to blur here in case the button element loses
7388                                 // focus between keydown and keyup, it would be left in an "active" state
7389                                 .bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() {
7390                                         $( this ).removeClass( "ui-state-active" );
7391                                 });
7392
7393                         if ( this.buttonElement.is("a") ) {
7394                                 this.buttonElement.keyup(function(event) {
7395                                         if ( event.keyCode === $.ui.keyCode.SPACE ) {
7396                                                 // TODO pass through original event correctly (just as 2nd argument doesn't work)
7397                                                 $( this ).click();
7398                                         }
7399                                 });
7400                         }
7401                 }
7402
7403                 // TODO: pull out $.Widget's handling for the disabled option into
7404                 // $.Widget.prototype._setOptionDisabled so it's easy to proxy and can
7405                 // be overridden by individual plugins
7406                 this._setOption( "disabled", options.disabled );
7407                 this._resetButton();
7408         },
7409
7410         _determineButtonType: function() {
7411                 var ancestor, labelSelector, checked;
7412
7413                 if ( this.element.is("[type=checkbox]") ) {
7414                         this.type = "checkbox";
7415                 } else if ( this.element.is("[type=radio]") ) {
7416                         this.type = "radio";
7417                 } else if ( this.element.is("input") ) {
7418                         this.type = "input";
7419                 } else {
7420                         this.type = "button";
7421                 }
7422
7423                 if ( this.type === "checkbox" || this.type === "radio" ) {
7424                         // we don't search against the document in case the element
7425                         // is disconnected from the DOM
7426                         ancestor = this.element.parents().last();
7427                         labelSelector = "label[for='" + this.element.attr("id") + "']";
7428                         this.buttonElement = ancestor.find( labelSelector );
7429                         if ( !this.buttonElement.length ) {
7430                                 ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
7431                                 this.buttonElement = ancestor.filter( labelSelector );
7432                                 if ( !this.buttonElement.length ) {
7433                                         this.buttonElement = ancestor.find( labelSelector );
7434                                 }
7435                         }
7436                         this.element.addClass( "ui-helper-hidden-accessible" );
7437
7438                         checked = this.element.is( ":checked" );
7439                         if ( checked ) {
7440                                 this.buttonElement.addClass( "ui-state-active" );
7441                         }
7442                         this.buttonElement.prop( "aria-pressed", checked );
7443                 } else {
7444                         this.buttonElement = this.element;
7445                 }
7446         },
7447
7448         widget: function() {
7449                 return this.buttonElement;
7450         },
7451
7452         _destroy: function() {
7453                 this.element
7454                         .removeClass( "ui-helper-hidden-accessible" );
7455                 this.buttonElement
7456                         .removeClass( baseClasses + " " + stateClasses + " " + typeClasses )
7457                         .removeAttr( "role" )
7458                         .removeAttr( "aria-pressed" )
7459                         .html( this.buttonElement.find(".ui-button-text").html() );
7460
7461                 if ( !this.hasTitle ) {
7462                         this.buttonElement.removeAttr( "title" );
7463                 }
7464         },
7465
7466         _setOption: function( key, value ) {
7467                 this._super( key, value );
7468                 if ( key === "disabled" ) {
7469                         if ( value ) {
7470                                 this.element.prop( "disabled", true );
7471                         } else {
7472                                 this.element.prop( "disabled", false );
7473                         }
7474                         return;
7475                 }
7476                 this._resetButton();
7477         },
7478
7479         refresh: function() {
7480                 //See #8237 & #8828
7481                 var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
7482
7483                 if ( isDisabled !== this.options.disabled ) {
7484                         this._setOption( "disabled", isDisabled );
7485                 }
7486                 if ( this.type === "radio" ) {
7487                         radioGroup( this.element[0] ).each(function() {
7488                                 if ( $( this ).is( ":checked" ) ) {
7489                                         $( this ).button( "widget" )
7490                                                 .addClass( "ui-state-active" )
7491                                                 .attr( "aria-pressed", "true" );
7492                                 } else {
7493                                         $( this ).button( "widget" )
7494                                                 .removeClass( "ui-state-active" )
7495                                                 .attr( "aria-pressed", "false" );
7496                                 }
7497                         });
7498                 } else if ( this.type === "checkbox" ) {
7499                         if ( this.element.is( ":checked" ) ) {
7500                                 this.buttonElement
7501                                         .addClass( "ui-state-active" )
7502                                         .attr( "aria-pressed", "true" );
7503                         } else {
7504                                 this.buttonElement
7505                                         .removeClass( "ui-state-active" )
7506                                         .attr( "aria-pressed", "false" );
7507                         }
7508                 }
7509         },
7510
7511         _resetButton: function() {
7512                 if ( this.type === "input" ) {
7513                         if ( this.options.label ) {
7514                                 this.element.val( this.options.label );
7515                         }
7516                         return;
7517                 }
7518                 var buttonElement = this.buttonElement.removeClass( typeClasses ),
7519                         buttonText = $( "<span></span>", this.document[0] )
7520                                 .addClass( "ui-button-text" )
7521                                 .html( this.options.label )
7522                                 .appendTo( buttonElement.empty() )
7523                                 .text(),
7524                         icons = this.options.icons,
7525                         multipleIcons = icons.primary && icons.secondary,
7526                         buttonClasses = [];
7527
7528                 if ( icons.primary || icons.secondary ) {
7529                         if ( this.options.text ) {
7530                                 buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
7531                         }
7532
7533                         if ( icons.primary ) {
7534                                 buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
7535                         }
7536
7537                         if ( icons.secondary ) {
7538                                 buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
7539                         }
7540
7541                         if ( !this.options.text ) {
7542                                 buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" );
7543
7544                                 if ( !this.hasTitle ) {
7545                                         buttonElement.attr( "title", $.trim( buttonText ) );
7546                                 }
7547                         }
7548                 } else {
7549                         buttonClasses.push( "ui-button-text-only" );
7550                 }
7551                 buttonElement.addClass( buttonClasses.join( " " ) );
7552         }
7553 });
7554
7555 $.widget( "ui.buttonset", {
7556         version: "1.10.3",
7557         options: {
7558                 items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)"
7559         },
7560
7561         _create: function() {
7562                 this.element.addClass( "ui-buttonset" );
7563         },
7564
7565         _init: function() {
7566                 this.refresh();
7567         },
7568
7569         _setOption: function( key, value ) {
7570                 if ( key === "disabled" ) {
7571                         this.buttons.button( "option", key, value );
7572                 }
7573
7574                 this._super( key, value );
7575         },
7576
7577         refresh: function() {
7578                 var rtl = this.element.css( "direction" ) === "rtl";
7579
7580                 this.buttons = this.element.find( this.options.items )
7581                         .filter( ":ui-button" )
7582                                 .button( "refresh" )
7583                         .end()
7584                         .not( ":ui-button" )
7585                                 .button()
7586                         .end()
7587                         .map(function() {
7588                                 return $( this ).button( "widget" )[ 0 ];
7589                         })
7590                                 .removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
7591                                 .filter( ":first" )
7592                                         .addClass( rtl ? "ui-corner-right" : "ui-corner-left" )
7593                                 .end()
7594                                 .filter( ":last" )
7595                                         .addClass( rtl ? "ui-corner-left" : "ui-corner-right" )
7596                                 .end()
7597                         .end();
7598         },
7599
7600         _destroy: function() {
7601                 this.element.removeClass( "ui-buttonset" );
7602                 this.buttons
7603                         .map(function() {
7604                                 return $( this ).button( "widget" )[ 0 ];
7605                         })
7606                                 .removeClass( "ui-corner-left ui-corner-right" )
7607                         .end()
7608                         .button( "destroy" );
7609         }
7610 });
7611
7612 }( jQuery ) );
7613
7614 (function( $, undefined ) {
7615
7616 $.extend($.ui, { datepicker: { version: "1.10.3" } });
7617
7618 var PROP_NAME = "datepicker",
7619         instActive;
7620
7621 /* Date picker manager.
7622    Use the singleton instance of this class, $.datepicker, to interact with the date picker.
7623    Settings for (groups of) date pickers are maintained in an instance object,
7624    allowing multiple different settings on the same page. */
7625
7626 function Datepicker() {
7627         this._curInst = null; // The current instance in use
7628         this._keyEvent = false; // If the last event was a key event
7629         this._disabledInputs = []; // List of date picker inputs that have been disabled
7630         this._datepickerShowing = false; // True if the popup picker is showing , false if not
7631         this._inDialog = false; // True if showing within a "dialog", false if not
7632         this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
7633         this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
7634         this._appendClass = "ui-datepicker-append"; // The name of the append marker class
7635         this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
7636         this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
7637         this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
7638         this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
7639         this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
7640         this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
7641         this.regional = []; // Available regional settings, indexed by language code
7642         this.regional[""] = { // Default regional settings
7643                 closeText: "Done", // Display text for close link
7644                 prevText: "Prev", // Display text for previous month link
7645                 nextText: "Next", // Display text for next month link
7646                 currentText: "Today", // Display text for current month link
7647                 monthNames: ["January","February","March","April","May","June",
7648                         "July","August","September","October","November","December"], // Names of months for drop-down and formatting
7649                 monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
7650                 dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
7651                 dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting
7652                 dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday
7653                 weekHeader: "Wk", // Column header for week of the year
7654                 dateFormat: "mm/dd/yy", // See format options on parseDate
7655                 firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
7656                 isRTL: false, // True if right-to-left language, false if left-to-right
7657                 showMonthAfterYear: false, // True if the year select precedes month, false for month then year
7658                 yearSuffix: "" // Additional text to append to the year in the month headers
7659         };
7660         this._defaults = { // Global defaults for all the date picker instances
7661                 showOn: "focus", // "focus" for popup on focus,
7662                         // "button" for trigger button, or "both" for either
7663                 showAnim: "fadeIn", // Name of jQuery animation for popup
7664                 showOptions: {}, // Options for enhanced animations
7665                 defaultDate: null, // Used when field is blank: actual date,
7666                         // +/-number for offset from today, null for today
7667                 appendText: "", // Display text following the input box, e.g. showing the format
7668                 buttonText: "...", // Text for trigger button
7669                 buttonImage: "", // URL for trigger button image
7670                 buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
7671                 hideIfNoPrevNext: false, // True to hide next/previous month links
7672                         // if not applicable, false to just disable them
7673                 navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
7674                 gotoCurrent: false, // True if today link goes back to current selection instead
7675                 changeMonth: false, // True if month can be selected directly, false if only prev/next
7676                 changeYear: false, // True if year can be selected directly, false if only prev/next
7677                 yearRange: "c-10:c+10", // Range of years to display in drop-down,
7678                         // either relative to today's year (-nn:+nn), relative to currently displayed year
7679                         // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
7680                 showOtherMonths: false, // True to show dates in other months, false to leave blank
7681                 selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
7682                 showWeek: false, // True to show week of the year, false to not show it
7683                 calculateWeek: this.iso8601Week, // How to calculate the week of the year,
7684                         // takes a Date and returns the number of the week for it
7685                 shortYearCutoff: "+10", // Short year values < this are in the current century,
7686                         // > this are in the previous century,
7687                         // string value starting with "+" for current year + value
7688                 minDate: null, // The earliest selectable date, or null for no limit
7689                 maxDate: null, // The latest selectable date, or null for no limit
7690                 duration: "fast", // Duration of display/closure
7691                 beforeShowDay: null, // Function that takes a date and returns an array with
7692                         // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
7693                         // [2] = cell title (optional), e.g. $.datepicker.noWeekends
7694                 beforeShow: null, // Function that takes an input field and
7695                         // returns a set of custom settings for the date picker
7696                 onSelect: null, // Define a callback function when a date is selected
7697                 onChangeMonthYear: null, // Define a callback function when the month or year is changed
7698                 onClose: null, // Define a callback function when the datepicker is closed
7699                 numberOfMonths: 1, // Number of months to show at a time
7700                 showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
7701                 stepMonths: 1, // Number of months to step back/forward
7702                 stepBigMonths: 12, // Number of months to step back/forward for the big links
7703                 altField: "", // Selector for an alternate field to store selected dates into
7704                 altFormat: "", // The date format to use for the alternate field
7705                 constrainInput: true, // The input is constrained by the current date format
7706                 showButtonPanel: false, // True to show button panel, false to not show it
7707                 autoSize: false, // True to size the input for the date format, false to leave as is
7708                 disabled: false // The initial disabled state
7709         };
7710         $.extend(this._defaults, this.regional[""]);
7711         this.dpDiv = bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>"));
7712 }
7713
7714 $.extend(Datepicker.prototype, {
7715         /* Class name added to elements to indicate already configured with a date picker. */
7716         markerClassName: "hasDatepicker",
7717
7718         //Keep track of the maximum number of rows displayed (see #7043)
7719         maxRows: 4,
7720
7721         // TODO rename to "widget" when switching to widget factory
7722         _widgetDatepicker: function() {
7723                 return this.dpDiv;
7724         },
7725
7726         /* Override the default settings for all instances of the date picker.
7727          * @param  settings  object - the new settings to use as defaults (anonymous object)
7728          * @return the manager object
7729          */
7730         setDefaults: function(settings) {
7731                 extendRemove(this._defaults, settings || {});
7732                 return this;
7733         },
7734
7735         /* Attach the date picker to a jQuery selection.
7736          * @param  target       element - the target input field or division or span
7737          * @param  settings  object - the new settings to use for this date picker instance (anonymous)
7738          */
7739         _attachDatepicker: function(target, settings) {
7740                 var nodeName, inline, inst;
7741                 nodeName = target.nodeName.toLowerCase();
7742                 inline = (nodeName === "div" || nodeName === "span");
7743                 if (!target.id) {
7744                         this.uuid += 1;
7745                         target.id = "dp" + this.uuid;
7746                 }
7747                 inst = this._newInst($(target), inline);
7748                 inst.settings = $.extend({}, settings || {});
7749                 if (nodeName === "input") {
7750                         this._connectDatepicker(target, inst);
7751                 } else if (inline) {
7752                         this._inlineDatepicker(target, inst);
7753                 }
7754         },
7755
7756         /* Create a new instance object. */
7757         _newInst: function(target, inline) {
7758                 var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars
7759                 return {id: id, input: target, // associated target
7760                         selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
7761                         drawMonth: 0, drawYear: 0, // month being drawn
7762                         inline: inline, // is datepicker inline or not
7763                         dpDiv: (!inline ? this.dpDiv : // presentation div
7764                         bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))};
7765         },
7766
7767         /* Attach the date picker to an input field. */
7768         _connectDatepicker: function(target, inst) {
7769                 var input = $(target);
7770                 inst.append = $([]);
7771                 inst.trigger = $([]);
7772                 if (input.hasClass(this.markerClassName)) {
7773                         return;
7774                 }
7775                 this._attachments(input, inst);
7776                 input.addClass(this.markerClassName).keydown(this._doKeyDown).
7777                         keypress(this._doKeyPress).keyup(this._doKeyUp);
7778                 this._autoSize(inst);
7779                 $.data(target, PROP_NAME, inst);
7780                 //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
7781                 if( inst.settings.disabled ) {
7782                         this._disableDatepicker( target );
7783                 }
7784         },
7785
7786         /* Make attachments based on settings. */
7787         _attachments: function(input, inst) {
7788                 var showOn, buttonText, buttonImage,
7789                         appendText = this._get(inst, "appendText"),
7790                         isRTL = this._get(inst, "isRTL");
7791
7792                 if (inst.append) {
7793                         inst.append.remove();
7794                 }
7795                 if (appendText) {
7796                         inst.append = $("<span class='" + this._appendClass + "'>" + appendText + "</span>");
7797                         input[isRTL ? "before" : "after"](inst.append);
7798                 }
7799
7800                 input.unbind("focus", this._showDatepicker);
7801
7802                 if (inst.trigger) {
7803                         inst.trigger.remove();
7804                 }
7805
7806                 showOn = this._get(inst, "showOn");
7807                 if (showOn === "focus" || showOn === "both") { // pop-up date picker when in the marked field
7808                         input.focus(this._showDatepicker);
7809                 }
7810                 if (showOn === "button" || showOn === "both") { // pop-up date picker when button clicked
7811                         buttonText = this._get(inst, "buttonText");
7812                         buttonImage = this._get(inst, "buttonImage");
7813                         inst.trigger = $(this._get(inst, "buttonImageOnly") ?
7814                                 $("<img/>").addClass(this._triggerClass).
7815                                         attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
7816                                 $("<button type='button'></button>").addClass(this._triggerClass).
7817                                         html(!buttonImage ? buttonText : $("<img/>").attr(
7818                                         { src:buttonImage, alt:buttonText, title:buttonText })));
7819                         input[isRTL ? "before" : "after"](inst.trigger);
7820                         inst.trigger.click(function() {
7821                                 if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) {
7822                                         $.datepicker._hideDatepicker();
7823                                 } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) {
7824                                         $.datepicker._hideDatepicker();
7825                                         $.datepicker._showDatepicker(input[0]);
7826                                 } else {
7827                                         $.datepicker._showDatepicker(input[0]);
7828                                 }
7829                                 return false;
7830                         });
7831                 }
7832         },
7833
7834         /* Apply the maximum length for the date format. */
7835         _autoSize: function(inst) {
7836                 if (this._get(inst, "autoSize") && !inst.inline) {
7837                         var findMax, max, maxI, i,
7838                                 date = new Date(2009, 12 - 1, 20), // Ensure double digits
7839                                 dateFormat = this._get(inst, "dateFormat");
7840
7841                         if (dateFormat.match(/[DM]/)) {
7842                                 findMax = function(names) {
7843                                         max = 0;
7844                                         maxI = 0;
7845                                         for (i = 0; i < names.length; i++) {
7846                                                 if (names[i].length > max) {
7847                                                         max = names[i].length;
7848                                                         maxI = i;
7849                                                 }
7850                                         }
7851                                         return maxI;
7852                                 };
7853                                 date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
7854                                         "monthNames" : "monthNamesShort"))));
7855                                 date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
7856                                         "dayNames" : "dayNamesShort"))) + 20 - date.getDay());
7857                         }
7858                         inst.input.attr("size", this._formatDate(inst, date).length);
7859                 }
7860         },
7861
7862         /* Attach an inline date picker to a div. */
7863         _inlineDatepicker: function(target, inst) {
7864                 var divSpan = $(target);
7865                 if (divSpan.hasClass(this.markerClassName)) {
7866                         return;
7867                 }
7868                 divSpan.addClass(this.markerClassName).append(inst.dpDiv);
7869                 $.data(target, PROP_NAME, inst);
7870                 this._setDate(inst, this._getDefaultDate(inst), true);
7871                 this._updateDatepicker(inst);
7872                 this._updateAlternate(inst);
7873                 //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
7874                 if( inst.settings.disabled ) {
7875                         this._disableDatepicker( target );
7876                 }
7877                 // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
7878                 // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
7879                 inst.dpDiv.css( "display", "block" );
7880         },
7881
7882         /* Pop-up the date picker in a "dialog" box.
7883          * @param  input element - ignored
7884          * @param  date string or Date - the initial date to display
7885          * @param  onSelect  function - the function to call when a date is selected
7886          * @param  settings  object - update the dialog date picker instance's settings (anonymous object)
7887          * @param  pos int[2] - coordinates for the dialog's position within the screen or
7888          *                                      event - with x/y coordinates or
7889          *                                      leave empty for default (screen centre)
7890          * @return the manager object
7891          */
7892         _dialogDatepicker: function(input, date, onSelect, settings, pos) {
7893                 var id, browserWidth, browserHeight, scrollX, scrollY,
7894                         inst = this._dialogInst; // internal instance
7895
7896                 if (!inst) {
7897                         this.uuid += 1;
7898                         id = "dp" + this.uuid;
7899                         this._dialogInput = $("<input type='text' id='" + id +
7900                                 "' style='position: absolute; top: -100px; width: 0px;'/>");
7901                         this._dialogInput.keydown(this._doKeyDown);
7902                         $("body").append(this._dialogInput);
7903                         inst = this._dialogInst = this._newInst(this._dialogInput, false);
7904                         inst.settings = {};
7905                         $.data(this._dialogInput[0], PROP_NAME, inst);
7906                 }
7907                 extendRemove(inst.settings, settings || {});
7908                 date = (date && date.constructor === Date ? this._formatDate(inst, date) : date);
7909                 this._dialogInput.val(date);
7910
7911                 this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
7912                 if (!this._pos) {
7913                         browserWidth = document.documentElement.clientWidth;
7914                         browserHeight = document.documentElement.clientHeight;
7915                         scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
7916                         scrollY = document.documentElement.scrollTop || document.body.scrollTop;
7917                         this._pos = // should use actual width/height below
7918                                 [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
7919                 }
7920
7921                 // move input on screen for focus, but hidden behind dialog
7922                 this._dialogInput.css("left", (this._pos[0] + 20) + "px").css("top", this._pos[1] + "px");
7923                 inst.settings.onSelect = onSelect;
7924                 this._inDialog = true;
7925                 this.dpDiv.addClass(this._dialogClass);
7926                 this._showDatepicker(this._dialogInput[0]);
7927                 if ($.blockUI) {
7928                         $.blockUI(this.dpDiv);
7929                 }
7930                 $.data(this._dialogInput[0], PROP_NAME, inst);
7931                 return this;
7932         },
7933
7934         /* Detach a datepicker from its control.
7935          * @param  target       element - the target input field or division or span
7936          */
7937         _destroyDatepicker: function(target) {
7938                 var nodeName,
7939                         $target = $(target),
7940                         inst = $.data(target, PROP_NAME);
7941
7942                 if (!$target.hasClass(this.markerClassName)) {
7943                         return;
7944                 }
7945
7946                 nodeName = target.nodeName.toLowerCase();
7947                 $.removeData(target, PROP_NAME);
7948                 if (nodeName === "input") {
7949                         inst.append.remove();
7950                         inst.trigger.remove();
7951                         $target.removeClass(this.markerClassName).
7952                                 unbind("focus", this._showDatepicker).
7953                                 unbind("keydown", this._doKeyDown).
7954                                 unbind("keypress", this._doKeyPress).
7955                                 unbind("keyup", this._doKeyUp);
7956                 } else if (nodeName === "div" || nodeName === "span") {
7957                         $target.removeClass(this.markerClassName).empty();
7958                 }
7959         },
7960
7961         /* Enable the date picker to a jQuery selection.
7962          * @param  target       element - the target input field or division or span
7963          */
7964         _enableDatepicker: function(target) {
7965                 var nodeName, inline,
7966                         $target = $(target),
7967                         inst = $.data(target, PROP_NAME);
7968
7969                 if (!$target.hasClass(this.markerClassName)) {
7970                         return;
7971                 }
7972
7973                 nodeName = target.nodeName.toLowerCase();
7974                 if (nodeName === "input") {
7975                         target.disabled = false;
7976                         inst.trigger.filter("button").
7977                                 each(function() { this.disabled = false; }).end().
7978                                 filter("img").css({opacity: "1.0", cursor: ""});
7979                 } else if (nodeName === "div" || nodeName === "span") {
7980                         inline = $target.children("." + this._inlineClass);
7981                         inline.children().removeClass("ui-state-disabled");
7982                         inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
7983                                 prop("disabled", false);
7984                 }
7985                 this._disabledInputs = $.map(this._disabledInputs,
7986                         function(value) { return (value === target ? null : value); }); // delete entry
7987         },
7988
7989         /* Disable the date picker to a jQuery selection.
7990          * @param  target       element - the target input field or division or span
7991          */
7992         _disableDatepicker: function(target) {
7993                 var nodeName, inline,
7994                         $target = $(target),
7995                         inst = $.data(target, PROP_NAME);
7996
7997                 if (!$target.hasClass(this.markerClassName)) {
7998                         return;
7999                 }
8000
8001                 nodeName = target.nodeName.toLowerCase();
8002                 if (nodeName === "input") {
8003                         target.disabled = true;
8004                         inst.trigger.filter("button").
8005                                 each(function() { this.disabled = true; }).end().
8006                                 filter("img").css({opacity: "0.5", cursor: "default"});
8007                 } else if (nodeName === "div" || nodeName === "span") {
8008                         inline = $target.children("." + this._inlineClass);
8009                         inline.children().addClass("ui-state-disabled");
8010                         inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
8011                                 prop("disabled", true);
8012                 }
8013                 this._disabledInputs = $.map(this._disabledInputs,
8014                         function(value) { return (value === target ? null : value); }); // delete entry
8015                 this._disabledInputs[this._disabledInputs.length] = target;
8016         },
8017
8018         /* Is the first field in a jQuery collection disabled as a datepicker?
8019          * @param  target       element - the target input field or division or span
8020          * @return boolean - true if disabled, false if enabled
8021          */
8022         _isDisabledDatepicker: function(target) {
8023                 if (!target) {
8024                         return false;
8025                 }
8026                 for (var i = 0; i < this._disabledInputs.length; i++) {
8027                         if (this._disabledInputs[i] === target) {
8028                                 return true;
8029                         }
8030                 }
8031                 return false;
8032         },
8033
8034         /* Retrieve the instance data for the target control.
8035          * @param  target  element - the target input field or division or span
8036          * @return  object - the associated instance data
8037          * @throws  error if a jQuery problem getting data
8038          */
8039         _getInst: function(target) {
8040                 try {
8041                         return $.data(target, PROP_NAME);
8042                 }
8043                 catch (err) {
8044                         throw "Missing instance data for this datepicker";
8045                 }
8046         },
8047
8048         /* Update or retrieve the settings for a date picker attached to an input field or division.
8049          * @param  target  element - the target input field or division or span
8050          * @param  name object - the new settings to update or
8051          *                              string - the name of the setting to change or retrieve,
8052          *                              when retrieving also "all" for all instance settings or
8053          *                              "defaults" for all global defaults
8054          * @param  value   any - the new value for the setting
8055          *                              (omit if above is an object or to retrieve a value)
8056          */
8057         _optionDatepicker: function(target, name, value) {
8058                 var settings, date, minDate, maxDate,
8059                         inst = this._getInst(target);
8060
8061                 if (arguments.length === 2 && typeof name === "string") {
8062                         return (name === "defaults" ? $.extend({}, $.datepicker._defaults) :
8063                                 (inst ? (name === "all" ? $.extend({}, inst.settings) :
8064                                 this._get(inst, name)) : null));
8065                 }
8066
8067                 settings = name || {};
8068                 if (typeof name === "string") {
8069                         settings = {};
8070                         settings[name] = value;
8071                 }
8072
8073                 if (inst) {
8074                         if (this._curInst === inst) {
8075                                 this._hideDatepicker();
8076                         }
8077
8078                         date = this._getDateDatepicker(target, true);
8079                         minDate = this._getMinMaxDate(inst, "min");
8080                         maxDate = this._getMinMaxDate(inst, "max");
8081                         extendRemove(inst.settings, settings);
8082                         // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
8083                         if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) {
8084                                 inst.settings.minDate = this._formatDate(inst, minDate);
8085                         }
8086                         if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) {
8087                                 inst.settings.maxDate = this._formatDate(inst, maxDate);
8088                         }
8089                         if ( "disabled" in settings ) {
8090                                 if ( settings.disabled ) {
8091                                         this._disableDatepicker(target);
8092                                 } else {
8093                                         this._enableDatepicker(target);
8094                                 }
8095                         }
8096                         this._attachments($(target), inst);
8097                         this._autoSize(inst);
8098                         this._setDate(inst, date);
8099                         this._updateAlternate(inst);
8100                         this._updateDatepicker(inst);
8101                 }
8102         },
8103
8104         // change method deprecated
8105         _changeDatepicker: function(target, name, value) {
8106                 this._optionDatepicker(target, name, value);
8107         },
8108
8109         /* Redraw the date picker attached to an input field or division.
8110          * @param  target  element - the target input field or division or span
8111          */
8112         _refreshDatepicker: function(target) {
8113                 var inst = this._getInst(target);
8114                 if (inst) {
8115                         this._updateDatepicker(inst);
8116                 }
8117         },
8118
8119         /* Set the dates for a jQuery selection.
8120          * @param  target element - the target input field or division or span
8121          * @param  date Date - the new date
8122          */
8123         _setDateDatepicker: function(target, date) {
8124                 var inst = this._getInst(target);
8125                 if (inst) {
8126                         this._setDate(inst, date);
8127                         this._updateDatepicker(inst);
8128                         this._updateAlternate(inst);
8129                 }
8130         },
8131
8132         /* Get the date(s) for the first entry in a jQuery selection.
8133          * @param  target element - the target input field or division or span
8134          * @param  noDefault boolean - true if no default date is to be used
8135          * @return Date - the current date
8136          */
8137         _getDateDatepicker: function(target, noDefault) {
8138                 var inst = this._getInst(target);
8139                 if (inst && !inst.inline) {
8140                         this._setDateFromField(inst, noDefault);
8141                 }
8142                 return (inst ? this._getDate(inst) : null);
8143         },
8144
8145         /* Handle keystrokes. */
8146         _doKeyDown: function(event) {
8147                 var onSelect, dateStr, sel,
8148                         inst = $.datepicker._getInst(event.target),
8149                         handled = true,
8150                         isRTL = inst.dpDiv.is(".ui-datepicker-rtl");
8151
8152                 inst._keyEvent = true;
8153                 if ($.datepicker._datepickerShowing) {
8154                         switch (event.keyCode) {
8155                                 case 9: $.datepicker._hideDatepicker();
8156                                                 handled = false;
8157                                                 break; // hide on tab out
8158                                 case 13: sel = $("td." + $.datepicker._dayOverClass + ":not(." +
8159                                                                         $.datepicker._currentClass + ")", inst.dpDiv);
8160                                                 if (sel[0]) {
8161                                                         $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
8162                                                 }
8163
8164                                                 onSelect = $.datepicker._get(inst, "onSelect");
8165                                                 if (onSelect) {
8166                                                         dateStr = $.datepicker._formatDate(inst);
8167
8168                                                         // trigger custom callback
8169                                                         onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);
8170                                                 } else {
8171                                                         $.datepicker._hideDatepicker();
8172                                                 }
8173
8174                                                 return false; // don't submit the form
8175                                 case 27: $.datepicker._hideDatepicker();
8176                                                 break; // hide on escape
8177                                 case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8178                                                         -$.datepicker._get(inst, "stepBigMonths") :
8179                                                         -$.datepicker._get(inst, "stepMonths")), "M");
8180                                                 break; // previous month/year on page up/+ ctrl
8181                                 case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8182                                                         +$.datepicker._get(inst, "stepBigMonths") :
8183                                                         +$.datepicker._get(inst, "stepMonths")), "M");
8184                                                 break; // next month/year on page down/+ ctrl
8185                                 case 35: if (event.ctrlKey || event.metaKey) {
8186                                                         $.datepicker._clearDate(event.target);
8187                                                 }
8188                                                 handled = event.ctrlKey || event.metaKey;
8189                                                 break; // clear on ctrl or command +end
8190                                 case 36: if (event.ctrlKey || event.metaKey) {
8191                                                         $.datepicker._gotoToday(event.target);
8192                                                 }
8193                                                 handled = event.ctrlKey || event.metaKey;
8194                                                 break; // current on ctrl or command +home
8195                                 case 37: if (event.ctrlKey || event.metaKey) {
8196                                                         $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), "D");
8197                                                 }
8198                                                 handled = event.ctrlKey || event.metaKey;
8199                                                 // -1 day on ctrl or command +left
8200                                                 if (event.originalEvent.altKey) {
8201                                                         $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8202                                                                 -$.datepicker._get(inst, "stepBigMonths") :
8203                                                                 -$.datepicker._get(inst, "stepMonths")), "M");
8204                                                 }
8205                                                 // next month/year on alt +left on Mac
8206                                                 break;
8207                                 case 38: if (event.ctrlKey || event.metaKey) {
8208                                                         $.datepicker._adjustDate(event.target, -7, "D");
8209                                                 }
8210                                                 handled = event.ctrlKey || event.metaKey;
8211                                                 break; // -1 week on ctrl or command +up
8212                                 case 39: if (event.ctrlKey || event.metaKey) {
8213                                                         $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), "D");
8214                                                 }
8215                                                 handled = event.ctrlKey || event.metaKey;
8216                                                 // +1 day on ctrl or command +right
8217                                                 if (event.originalEvent.altKey) {
8218                                                         $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8219                                                                 +$.datepicker._get(inst, "stepBigMonths") :
8220                                                                 +$.datepicker._get(inst, "stepMonths")), "M");
8221                                                 }
8222                                                 // next month/year on alt +right
8223                                                 break;
8224                                 case 40: if (event.ctrlKey || event.metaKey) {
8225                                                         $.datepicker._adjustDate(event.target, +7, "D");
8226                                                 }
8227                                                 handled = event.ctrlKey || event.metaKey;
8228                                                 break; // +1 week on ctrl or command +down
8229                                 default: handled = false;
8230                         }
8231                 } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home
8232                         $.datepicker._showDatepicker(this);
8233                 } else {
8234                         handled = false;
8235                 }
8236
8237                 if (handled) {
8238                         event.preventDefault();
8239                         event.stopPropagation();
8240                 }
8241         },
8242
8243         /* Filter entered characters - based on date format. */
8244         _doKeyPress: function(event) {
8245                 var chars, chr,
8246                         inst = $.datepicker._getInst(event.target);
8247
8248                 if ($.datepicker._get(inst, "constrainInput")) {
8249                         chars = $.datepicker._possibleChars($.datepicker._get(inst, "dateFormat"));
8250                         chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode);
8251                         return event.ctrlKey || event.metaKey || (chr < " " || !chars || chars.indexOf(chr) > -1);
8252                 }
8253         },
8254
8255         /* Synchronise manual entry and field/alternate field. */
8256         _doKeyUp: function(event) {
8257                 var date,
8258                         inst = $.datepicker._getInst(event.target);
8259
8260                 if (inst.input.val() !== inst.lastVal) {
8261                         try {
8262                                 date = $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
8263                                         (inst.input ? inst.input.val() : null),
8264                                         $.datepicker._getFormatConfig(inst));
8265
8266                                 if (date) { // only if valid
8267                                         $.datepicker._setDateFromField(inst);
8268                                         $.datepicker._updateAlternate(inst);
8269                                         $.datepicker._updateDatepicker(inst);
8270                                 }
8271                         }
8272                         catch (err) {
8273                         }
8274                 }
8275                 return true;
8276         },
8277
8278         /* Pop-up the date picker for a given input field.
8279          * If false returned from beforeShow event handler do not show.
8280          * @param  input  element - the input field attached to the date picker or
8281          *                                      event - if triggered by focus
8282          */
8283         _showDatepicker: function(input) {
8284                 input = input.target || input;
8285                 if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger
8286                         input = $("input", input.parentNode)[0];
8287                 }
8288
8289                 if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here
8290                         return;
8291                 }
8292
8293                 var inst, beforeShow, beforeShowSettings, isFixed,
8294                         offset, showAnim, duration;
8295
8296                 inst = $.datepicker._getInst(input);
8297                 if ($.datepicker._curInst && $.datepicker._curInst !== inst) {
8298                         $.datepicker._curInst.dpDiv.stop(true, true);
8299                         if ( inst && $.datepicker._datepickerShowing ) {
8300                                 $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] );
8301                         }
8302                 }
8303
8304                 beforeShow = $.datepicker._get(inst, "beforeShow");
8305                 beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {};
8306                 if(beforeShowSettings === false){
8307                         return;
8308                 }
8309                 extendRemove(inst.settings, beforeShowSettings);
8310
8311                 inst.lastVal = null;
8312                 $.datepicker._lastInput = input;
8313                 $.datepicker._setDateFromField(inst);
8314
8315                 if ($.datepicker._inDialog) { // hide cursor
8316                         input.value = "";
8317                 }
8318                 if (!$.datepicker._pos) { // position below input
8319                         $.datepicker._pos = $.datepicker._findPos(input);
8320                         $.datepicker._pos[1] += input.offsetHeight; // add the height
8321                 }
8322
8323                 isFixed = false;
8324                 $(input).parents().each(function() {
8325                         isFixed |= $(this).css("position") === "fixed";
8326                         return !isFixed;
8327                 });
8328
8329                 offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
8330                 $.datepicker._pos = null;
8331                 //to avoid flashes on Firefox
8332                 inst.dpDiv.empty();
8333                 // determine sizing offscreen
8334                 inst.dpDiv.css({position: "absolute", display: "block", top: "-1000px"});
8335                 $.datepicker._updateDatepicker(inst);
8336                 // fix width for dynamic number of date pickers
8337                 // and adjust position before showing
8338                 offset = $.datepicker._checkOffset(inst, offset, isFixed);
8339                 inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
8340                         "static" : (isFixed ? "fixed" : "absolute")), display: "none",
8341                         left: offset.left + "px", top: offset.top + "px"});
8342
8343                 if (!inst.inline) {
8344                         showAnim = $.datepicker._get(inst, "showAnim");
8345                         duration = $.datepicker._get(inst, "duration");
8346                         inst.dpDiv.zIndex($(input).zIndex()+1);
8347                         $.datepicker._datepickerShowing = true;
8348
8349                         if ( $.effects && $.effects.effect[ showAnim ] ) {
8350                                 inst.dpDiv.show(showAnim, $.datepicker._get(inst, "showOptions"), duration);
8351                         } else {
8352                                 inst.dpDiv[showAnim || "show"](showAnim ? duration : null);
8353                         }
8354
8355                         if ( $.datepicker._shouldFocusInput( inst ) ) {
8356                                 inst.input.focus();
8357                         }
8358
8359                         $.datepicker._curInst = inst;
8360                 }
8361         },
8362
8363         /* Generate the date picker content. */
8364         _updateDatepicker: function(inst) {
8365                 this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
8366                 instActive = inst; // for delegate hover events
8367                 inst.dpDiv.empty().append(this._generateHTML(inst));
8368                 this._attachHandlers(inst);
8369                 inst.dpDiv.find("." + this._dayOverClass + " a").mouseover();
8370
8371                 var origyearshtml,
8372                         numMonths = this._getNumberOfMonths(inst),
8373                         cols = numMonths[1],
8374                         width = 17;
8375
8376                 inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width("");
8377                 if (cols > 1) {
8378                         inst.dpDiv.addClass("ui-datepicker-multi-" + cols).css("width", (width * cols) + "em");
8379                 }
8380                 inst.dpDiv[(numMonths[0] !== 1 || numMonths[1] !== 1 ? "add" : "remove") +
8381                         "Class"]("ui-datepicker-multi");
8382                 inst.dpDiv[(this._get(inst, "isRTL") ? "add" : "remove") +
8383                         "Class"]("ui-datepicker-rtl");
8384
8385                 if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
8386                         inst.input.focus();
8387                 }
8388
8389                 // deffered render of the years select (to avoid flashes on Firefox)
8390                 if( inst.yearshtml ){
8391                         origyearshtml = inst.yearshtml;
8392                         setTimeout(function(){
8393                                 //assure that inst.yearshtml didn't change.
8394                                 if( origyearshtml === inst.yearshtml && inst.yearshtml ){
8395                                         inst.dpDiv.find("select.ui-datepicker-year:first").replaceWith(inst.yearshtml);
8396                                 }
8397                                 origyearshtml = inst.yearshtml = null;
8398                         }, 0);
8399                 }
8400         },
8401
8402         // #6694 - don't focus the input if it's already focused
8403         // this breaks the change event in IE
8404         // Support: IE and jQuery <1.9
8405         _shouldFocusInput: function( inst ) {
8406                 return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
8407         },
8408
8409         /* Check positioning to remain on screen. */
8410         _checkOffset: function(inst, offset, isFixed) {
8411                 var dpWidth = inst.dpDiv.outerWidth(),
8412                         dpHeight = inst.dpDiv.outerHeight(),
8413                         inputWidth = inst.input ? inst.input.outerWidth() : 0,
8414                         inputHeight = inst.input ? inst.input.outerHeight() : 0,
8415                         viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()),
8416                         viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop());
8417
8418                 offset.left -= (this._get(inst, "isRTL") ? (dpWidth - inputWidth) : 0);
8419                 offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0;
8420                 offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
8421
8422                 // now check if datepicker is showing outside window viewport - move to a better place if so.
8423                 offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
8424                         Math.abs(offset.left + dpWidth - viewWidth) : 0);
8425                 offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
8426                         Math.abs(dpHeight + inputHeight) : 0);
8427
8428                 return offset;
8429         },
8430
8431         /* Find an object's position on the screen. */
8432         _findPos: function(obj) {
8433                 var position,
8434                         inst = this._getInst(obj),
8435                         isRTL = this._get(inst, "isRTL");
8436
8437                 while (obj && (obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden(obj))) {
8438                         obj = obj[isRTL ? "previousSibling" : "nextSibling"];
8439                 }
8440
8441                 position = $(obj).offset();
8442                 return [position.left, position.top];
8443         },
8444
8445         /* Hide the date picker from view.
8446          * @param  input  element - the input field attached to the date picker
8447          */
8448         _hideDatepicker: function(input) {
8449                 var showAnim, duration, postProcess, onClose,
8450                         inst = this._curInst;
8451
8452                 if (!inst || (input && inst !== $.data(input, PROP_NAME))) {
8453                         return;
8454                 }
8455
8456                 if (this._datepickerShowing) {
8457                         showAnim = this._get(inst, "showAnim");
8458                         duration = this._get(inst, "duration");
8459                         postProcess = function() {
8460                                 $.datepicker._tidyDialog(inst);
8461                         };
8462
8463                         // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
8464                         if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
8465                                 inst.dpDiv.hide(showAnim, $.datepicker._get(inst, "showOptions"), duration, postProcess);
8466                         } else {
8467                                 inst.dpDiv[(showAnim === "slideDown" ? "slideUp" :
8468                                         (showAnim === "fadeIn" ? "fadeOut" : "hide"))]((showAnim ? duration : null), postProcess);
8469                         }
8470
8471                         if (!showAnim) {
8472                                 postProcess();
8473                         }
8474                         this._datepickerShowing = false;
8475
8476                         onClose = this._get(inst, "onClose");
8477                         if (onClose) {
8478                                 onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]);
8479                         }
8480
8481                         this._lastInput = null;
8482                         if (this._inDialog) {
8483                                 this._dialogInput.css({ position: "absolute", left: "0", top: "-100px" });
8484                                 if ($.blockUI) {
8485                                         $.unblockUI();
8486                                         $("body").append(this.dpDiv);
8487                                 }
8488                         }
8489                         this._inDialog = false;
8490                 }
8491         },
8492
8493         /* Tidy up after a dialog display. */
8494         _tidyDialog: function(inst) {
8495                 inst.dpDiv.removeClass(this._dialogClass).unbind(".ui-datepicker-calendar");
8496         },
8497
8498         /* Close date picker if clicked elsewhere. */
8499         _checkExternalClick: function(event) {
8500                 if (!$.datepicker._curInst) {
8501                         return;
8502                 }
8503
8504                 var $target = $(event.target),
8505                         inst = $.datepicker._getInst($target[0]);
8506
8507                 if ( ( ( $target[0].id !== $.datepicker._mainDivId &&
8508                                 $target.parents("#" + $.datepicker._mainDivId).length === 0 &&
8509                                 !$target.hasClass($.datepicker.markerClassName) &&
8510                                 !$target.closest("." + $.datepicker._triggerClass).length &&
8511                                 $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) ||
8512                         ( $target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst ) ) {
8513                                 $.datepicker._hideDatepicker();
8514                 }
8515         },
8516
8517         /* Adjust one of the date sub-fields. */
8518         _adjustDate: function(id, offset, period) {
8519                 var target = $(id),
8520                         inst = this._getInst(target[0]);
8521
8522                 if (this._isDisabledDatepicker(target[0])) {
8523                         return;
8524                 }
8525                 this._adjustInstDate(inst, offset +
8526                         (period === "M" ? this._get(inst, "showCurrentAtPos") : 0), // undo positioning
8527                         period);
8528                 this._updateDatepicker(inst);
8529         },
8530
8531         /* Action for current link. */
8532         _gotoToday: function(id) {
8533                 var date,
8534                         target = $(id),
8535                         inst = this._getInst(target[0]);
8536
8537                 if (this._get(inst, "gotoCurrent") && inst.currentDay) {
8538                         inst.selectedDay = inst.currentDay;
8539                         inst.drawMonth = inst.selectedMonth = inst.currentMonth;
8540                         inst.drawYear = inst.selectedYear = inst.currentYear;
8541                 } else {
8542                         date = new Date();
8543                         inst.selectedDay = date.getDate();
8544                         inst.drawMonth = inst.selectedMonth = date.getMonth();
8545                         inst.drawYear = inst.selectedYear = date.getFullYear();
8546                 }
8547                 this._notifyChange(inst);
8548                 this._adjustDate(target);
8549         },
8550
8551         /* Action for selecting a new month/year. */
8552         _selectMonthYear: function(id, select, period) {
8553                 var target = $(id),
8554                         inst = this._getInst(target[0]);
8555
8556                 inst["selected" + (period === "M" ? "Month" : "Year")] =
8557                 inst["draw" + (period === "M" ? "Month" : "Year")] =
8558                         parseInt(select.options[select.selectedIndex].value,10);
8559
8560                 this._notifyChange(inst);
8561                 this._adjustDate(target);
8562         },
8563
8564         /* Action for selecting a day. */
8565         _selectDay: function(id, month, year, td) {
8566                 var inst,
8567                         target = $(id);
8568
8569                 if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
8570                         return;
8571                 }
8572
8573                 inst = this._getInst(target[0]);
8574                 inst.selectedDay = inst.currentDay = $("a", td).html();
8575                 inst.selectedMonth = inst.currentMonth = month;
8576                 inst.selectedYear = inst.currentYear = year;
8577                 this._selectDate(id, this._formatDate(inst,
8578                         inst.currentDay, inst.currentMonth, inst.currentYear));
8579         },
8580
8581         /* Erase the input field and hide the date picker. */
8582         _clearDate: function(id) {
8583                 var target = $(id);
8584                 this._selectDate(target, "");
8585         },
8586
8587         /* Update the input field with the selected date. */
8588         _selectDate: function(id, dateStr) {
8589                 var onSelect,
8590                         target = $(id),
8591                         inst = this._getInst(target[0]);
8592
8593                 dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
8594                 if (inst.input) {
8595                         inst.input.val(dateStr);
8596                 }
8597                 this._updateAlternate(inst);
8598
8599                 onSelect = this._get(inst, "onSelect");
8600                 if (onSelect) {
8601                         onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);  // trigger custom callback
8602                 } else if (inst.input) {
8603                         inst.input.trigger("change"); // fire the change event
8604                 }
8605
8606                 if (inst.inline){
8607                         this._updateDatepicker(inst);
8608                 } else {
8609                         this._hideDatepicker();
8610                         this._lastInput = inst.input[0];
8611                         if (typeof(inst.input[0]) !== "object") {
8612                                 inst.input.focus(); // restore focus
8613                         }
8614                         this._lastInput = null;
8615                 }
8616         },
8617
8618         /* Update any alternate field to synchronise with the main field. */
8619         _updateAlternate: function(inst) {
8620                 var altFormat, date, dateStr,
8621                         altField = this._get(inst, "altField");
8622
8623                 if (altField) { // update alternate field too
8624                         altFormat = this._get(inst, "altFormat") || this._get(inst, "dateFormat");
8625                         date = this._getDate(inst);
8626                         dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
8627                         $(altField).each(function() { $(this).val(dateStr); });
8628                 }
8629         },
8630
8631         /* Set as beforeShowDay function to prevent selection of weekends.
8632          * @param  date  Date - the date to customise
8633          * @return [boolean, string] - is this date selectable?, what is its CSS class?
8634          */
8635         noWeekends: function(date) {
8636                 var day = date.getDay();
8637                 return [(day > 0 && day < 6), ""];
8638         },
8639
8640         /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
8641          * @param  date  Date - the date to get the week for
8642          * @return  number - the number of the week within the year that contains this date
8643          */
8644         iso8601Week: function(date) {
8645                 var time,
8646                         checkDate = new Date(date.getTime());
8647
8648                 // Find Thursday of this week starting on Monday
8649                 checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
8650
8651                 time = checkDate.getTime();
8652                 checkDate.setMonth(0); // Compare with Jan 1
8653                 checkDate.setDate(1);
8654                 return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
8655         },
8656
8657         /* Parse a string value into a date object.
8658          * See formatDate below for the possible formats.
8659          *
8660          * @param  format string - the expected format of the date
8661          * @param  value string - the date in the above format
8662          * @param  settings Object - attributes include:
8663          *                                      shortYearCutoff  number - the cutoff year for determining the century (optional)
8664          *                                      dayNamesShort   string[7] - abbreviated names of the days from Sunday (optional)
8665          *                                      dayNames                string[7] - names of the days from Sunday (optional)
8666          *                                      monthNamesShort string[12] - abbreviated names of the months (optional)
8667          *                                      monthNames              string[12] - names of the months (optional)
8668          * @return  Date - the extracted date value or null if value is blank
8669          */
8670         parseDate: function (format, value, settings) {
8671                 if (format == null || value == null) {
8672                         throw "Invalid arguments";
8673                 }
8674
8675                 value = (typeof value === "object" ? value.toString() : value + "");
8676                 if (value === "") {
8677                         return null;
8678                 }
8679
8680                 var iFormat, dim, extra,
8681                         iValue = 0,
8682                         shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff,
8683                         shortYearCutoff = (typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
8684                                 new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)),
8685                         dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
8686                         dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
8687                         monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
8688                         monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
8689                         year = -1,
8690                         month = -1,
8691                         day = -1,
8692                         doy = -1,
8693                         literal = false,
8694                         date,
8695                         // Check whether a format character is doubled
8696                         lookAhead = function(match) {
8697                                 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
8698                                 if (matches) {
8699                                         iFormat++;
8700                                 }
8701                                 return matches;
8702                         },
8703                         // Extract a number from the string value
8704                         getNumber = function(match) {
8705                                 var isDoubled = lookAhead(match),
8706                                         size = (match === "@" ? 14 : (match === "!" ? 20 :
8707                                         (match === "y" && isDoubled ? 4 : (match === "o" ? 3 : 2)))),
8708                                         digits = new RegExp("^\\d{1," + size + "}"),
8709                                         num = value.substring(iValue).match(digits);
8710                                 if (!num) {
8711                                         throw "Missing number at position " + iValue;
8712                                 }
8713                                 iValue += num[0].length;
8714                                 return parseInt(num[0], 10);
8715                         },
8716                         // Extract a name from the string value and convert to an index
8717                         getName = function(match, shortNames, longNames) {
8718                                 var index = -1,
8719                                         names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
8720                                                 return [ [k, v] ];
8721                                         }).sort(function (a, b) {
8722                                                 return -(a[1].length - b[1].length);
8723                                         });
8724
8725                                 $.each(names, function (i, pair) {
8726                                         var name = pair[1];
8727                                         if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
8728                                                 index = pair[0];
8729                                                 iValue += name.length;
8730                                                 return false;
8731                                         }
8732                                 });
8733                                 if (index !== -1) {
8734                                         return index + 1;
8735                                 } else {
8736                                         throw "Unknown name at position " + iValue;
8737                                 }
8738                         },
8739                         // Confirm that a literal character matches the string value
8740                         checkLiteral = function() {
8741                                 if (value.charAt(iValue) !== format.charAt(iFormat)) {
8742                                         throw "Unexpected literal at position " + iValue;
8743                                 }
8744                                 iValue++;
8745                         };
8746
8747                 for (iFormat = 0; iFormat < format.length; iFormat++) {
8748                         if (literal) {
8749                                 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
8750                                         literal = false;
8751                                 } else {
8752                                         checkLiteral();
8753                                 }
8754                         } else {
8755                                 switch (format.charAt(iFormat)) {
8756                                         case "d":
8757                                                 day = getNumber("d");
8758                                                 break;
8759                                         case "D":
8760                                                 getName("D", dayNamesShort, dayNames);
8761                                                 break;
8762                                         case "o":
8763                                                 doy = getNumber("o");
8764                                                 break;
8765                                         case "m":
8766                                                 month = getNumber("m");
8767                                                 break;
8768                                         case "M":
8769                                                 month = getName("M", monthNamesShort, monthNames);
8770                                                 break;
8771                                         case "y":
8772                                                 year = getNumber("y");
8773                                                 break;
8774                                         case "@":
8775                                                 date = new Date(getNumber("@"));
8776                                                 year = date.getFullYear();
8777                                                 month = date.getMonth() + 1;
8778                                                 day = date.getDate();
8779                                                 break;
8780                                         case "!":
8781                                                 date = new Date((getNumber("!") - this._ticksTo1970) / 10000);
8782                                                 year = date.getFullYear();
8783                                                 month = date.getMonth() + 1;
8784                                                 day = date.getDate();
8785                                                 break;
8786                                         case "'":
8787                                                 if (lookAhead("'")){
8788                                                         checkLiteral();
8789                                                 } else {
8790                                                         literal = true;
8791                                                 }
8792                                                 break;
8793                                         default:
8794                                                 checkLiteral();
8795                                 }
8796                         }
8797                 }
8798
8799                 if (iValue < value.length){
8800                         extra = value.substr(iValue);
8801                         if (!/^\s+/.test(extra)) {
8802                                 throw "Extra/unparsed characters found in date: " + extra;
8803                         }
8804                 }
8805
8806                 if (year === -1) {
8807                         year = new Date().getFullYear();
8808                 } else if (year < 100) {
8809                         year += new Date().getFullYear() - new Date().getFullYear() % 100 +
8810                                 (year <= shortYearCutoff ? 0 : -100);
8811                 }
8812
8813                 if (doy > -1) {
8814                         month = 1;
8815                         day = doy;
8816                         do {
8817                                 dim = this._getDaysInMonth(year, month - 1);
8818                                 if (day <= dim) {
8819                                         break;
8820                                 }
8821                                 month++;
8822                                 day -= dim;
8823                         } while (true);
8824                 }
8825
8826                 date = this._daylightSavingAdjust(new Date(year, month - 1, day));
8827                 if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
8828                         throw "Invalid date"; // E.g. 31/02/00
8829                 }
8830                 return date;
8831         },
8832
8833         /* Standard date formats. */
8834         ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
8835         COOKIE: "D, dd M yy",
8836         ISO_8601: "yy-mm-dd",
8837         RFC_822: "D, d M y",
8838         RFC_850: "DD, dd-M-y",
8839         RFC_1036: "D, d M y",
8840         RFC_1123: "D, d M yy",
8841         RFC_2822: "D, d M yy",
8842         RSS: "D, d M y", // RFC 822
8843         TICKS: "!",
8844         TIMESTAMP: "@",
8845         W3C: "yy-mm-dd", // ISO 8601
8846
8847         _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
8848                 Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
8849
8850         /* Format a date object into a string value.
8851          * The format can be combinations of the following:
8852          * d  - day of month (no leading zero)
8853          * dd - day of month (two digit)
8854          * o  - day of year (no leading zeros)
8855          * oo - day of year (three digit)
8856          * D  - day name short
8857          * DD - day name long
8858          * m  - month of year (no leading zero)
8859          * mm - month of year (two digit)
8860          * M  - month name short
8861          * MM - month name long
8862          * y  - year (two digit)
8863          * yy - year (four digit)
8864          * @ - Unix timestamp (ms since 01/01/1970)
8865          * ! - Windows ticks (100ns since 01/01/0001)
8866          * "..." - literal text
8867          * '' - single quote
8868          *
8869          * @param  format string - the desired format of the date
8870          * @param  date Date - the date value to format
8871          * @param  settings Object - attributes include:
8872          *                                      dayNamesShort   string[7] - abbreviated names of the days from Sunday (optional)
8873          *                                      dayNames                string[7] - names of the days from Sunday (optional)
8874          *                                      monthNamesShort string[12] - abbreviated names of the months (optional)
8875          *                                      monthNames              string[12] - names of the months (optional)
8876          * @return  string - the date in the above format
8877          */
8878         formatDate: function (format, date, settings) {
8879                 if (!date) {
8880                         return "";
8881                 }
8882
8883                 var iFormat,
8884                         dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
8885                         dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
8886                         monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
8887                         monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
8888                         // Check whether a format character is doubled
8889                         lookAhead = function(match) {
8890                                 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
8891                                 if (matches) {
8892                                         iFormat++;
8893                                 }
8894                                 return matches;
8895                         },
8896                         // Format a number, with leading zero if necessary
8897                         formatNumber = function(match, value, len) {
8898                                 var num = "" + value;
8899                                 if (lookAhead(match)) {
8900                                         while (num.length < len) {
8901                                                 num = "0" + num;
8902                                         }
8903                                 }
8904                                 return num;
8905                         },
8906                         // Format a name, short or long as requested
8907                         formatName = function(match, value, shortNames, longNames) {
8908                                 return (lookAhead(match) ? longNames[value] : shortNames[value]);
8909                         },
8910                         output = "",
8911                         literal = false;
8912
8913                 if (date) {
8914                         for (iFormat = 0; iFormat < format.length; iFormat++) {
8915                                 if (literal) {
8916                                         if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
8917                                                 literal = false;
8918                                         } else {
8919                                                 output += format.charAt(iFormat);
8920                                         }
8921                                 } else {
8922                                         switch (format.charAt(iFormat)) {
8923                                                 case "d":
8924                                                         output += formatNumber("d", date.getDate(), 2);
8925                                                         break;
8926                                                 case "D":
8927                                                         output += formatName("D", date.getDay(), dayNamesShort, dayNames);
8928                                                         break;
8929                                                 case "o":
8930                                                         output += formatNumber("o",
8931                                                                 Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
8932                                                         break;
8933                                                 case "m":
8934                                                         output += formatNumber("m", date.getMonth() + 1, 2);
8935                                                         break;
8936                                                 case "M":
8937                                                         output += formatName("M", date.getMonth(), monthNamesShort, monthNames);
8938                                                         break;
8939                                                 case "y":
8940                                                         output += (lookAhead("y") ? date.getFullYear() :
8941                                                                 (date.getYear() % 100 < 10 ? "0" : "") + date.getYear() % 100);
8942                                                         break;
8943                                                 case "@":
8944                                                         output += date.getTime();
8945                                                         break;
8946                                                 case "!":
8947                                                         output += date.getTime() * 10000 + this._ticksTo1970;
8948                                                         break;
8949                                                 case "'":
8950                                                         if (lookAhead("'")) {
8951                                                                 output += "'";
8952                                                         } else {
8953                                                                 literal = true;
8954                                                         }
8955                                                         break;
8956                                                 default:
8957                                                         output += format.charAt(iFormat);
8958                                         }
8959                                 }
8960                         }
8961                 }
8962                 return output;
8963         },
8964
8965         /* Extract all possible characters from the date format. */
8966         _possibleChars: function (format) {
8967                 var iFormat,
8968                         chars = "",
8969                         literal = false,
8970                         // Check whether a format character is doubled
8971                         lookAhead = function(match) {
8972                                 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
8973                                 if (matches) {
8974                                         iFormat++;
8975                                 }
8976                                 return matches;
8977                         };
8978
8979                 for (iFormat = 0; iFormat < format.length; iFormat++) {
8980                         if (literal) {
8981                                 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
8982                                         literal = false;
8983                                 } else {
8984                                         chars += format.charAt(iFormat);
8985                                 }
8986                         } else {
8987                                 switch (format.charAt(iFormat)) {
8988                                         case "d": case "m": case "y": case "@":
8989                                                 chars += "0123456789";
8990                                                 break;
8991                                         case "D": case "M":
8992                                                 return null; // Accept anything
8993                                         case "'":
8994                                                 if (lookAhead("'")) {
8995                                                         chars += "'";
8996                                                 } else {
8997                                                         literal = true;
8998                                                 }
8999                                                 break;
9000                                         default:
9001                                                 chars += format.charAt(iFormat);
9002                                 }
9003                         }
9004                 }
9005                 return chars;
9006         },
9007
9008         /* Get a setting value, defaulting if necessary. */
9009         _get: function(inst, name) {
9010                 return inst.settings[name] !== undefined ?
9011                         inst.settings[name] : this._defaults[name];
9012         },
9013
9014         /* Parse existing date and initialise date picker. */
9015         _setDateFromField: function(inst, noDefault) {
9016                 if (inst.input.val() === inst.lastVal) {
9017                         return;
9018                 }
9019
9020                 var dateFormat = this._get(inst, "dateFormat"),
9021                         dates = inst.lastVal = inst.input ? inst.input.val() : null,
9022                         defaultDate = this._getDefaultDate(inst),
9023                         date = defaultDate,
9024                         settings = this._getFormatConfig(inst);
9025
9026                 try {
9027                         date = this.parseDate(dateFormat, dates, settings) || defaultDate;
9028                 } catch (event) {
9029                         dates = (noDefault ? "" : dates);
9030                 }
9031                 inst.selectedDay = date.getDate();
9032                 inst.drawMonth = inst.selectedMonth = date.getMonth();
9033                 inst.drawYear = inst.selectedYear = date.getFullYear();
9034                 inst.currentDay = (dates ? date.getDate() : 0);
9035                 inst.currentMonth = (dates ? date.getMonth() : 0);
9036                 inst.currentYear = (dates ? date.getFullYear() : 0);
9037                 this._adjustInstDate(inst);
9038         },
9039
9040         /* Retrieve the default date shown on opening. */
9041         _getDefaultDate: function(inst) {
9042                 return this._restrictMinMax(inst,
9043                         this._determineDate(inst, this._get(inst, "defaultDate"), new Date()));
9044         },
9045
9046         /* A date may be specified as an exact value or a relative one. */
9047         _determineDate: function(inst, date, defaultDate) {
9048                 var offsetNumeric = function(offset) {
9049                                 var date = new Date();
9050                                 date.setDate(date.getDate() + offset);
9051                                 return date;
9052                         },
9053                         offsetString = function(offset) {
9054                                 try {
9055                                         return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
9056                                                 offset, $.datepicker._getFormatConfig(inst));
9057                                 }
9058                                 catch (e) {
9059                                         // Ignore
9060                                 }
9061
9062                                 var date = (offset.toLowerCase().match(/^c/) ?
9063                                         $.datepicker._getDate(inst) : null) || new Date(),
9064                                         year = date.getFullYear(),
9065                                         month = date.getMonth(),
9066                                         day = date.getDate(),
9067                                         pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
9068                                         matches = pattern.exec(offset);
9069
9070                                 while (matches) {
9071                                         switch (matches[2] || "d") {
9072                                                 case "d" : case "D" :
9073                                                         day += parseInt(matches[1],10); break;
9074                                                 case "w" : case "W" :
9075                                                         day += parseInt(matches[1],10) * 7; break;
9076                                                 case "m" : case "M" :
9077                                                         month += parseInt(matches[1],10);
9078                                                         day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
9079                                                         break;
9080                                                 case "y": case "Y" :
9081                                                         year += parseInt(matches[1],10);
9082                                                         day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
9083                                                         break;
9084                                         }
9085                                         matches = pattern.exec(offset);
9086                                 }
9087                                 return new Date(year, month, day);
9088                         },
9089                         newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) :
9090                                 (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
9091
9092                 newDate = (newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate);
9093                 if (newDate) {
9094                         newDate.setHours(0);
9095                         newDate.setMinutes(0);
9096                         newDate.setSeconds(0);
9097                         newDate.setMilliseconds(0);
9098                 }
9099                 return this._daylightSavingAdjust(newDate);
9100         },
9101
9102         /* Handle switch to/from daylight saving.
9103          * Hours may be non-zero on daylight saving cut-over:
9104          * > 12 when midnight changeover, but then cannot generate
9105          * midnight datetime, so jump to 1AM, otherwise reset.
9106          * @param  date  (Date) the date to check
9107          * @return  (Date) the corrected date
9108          */
9109         _daylightSavingAdjust: function(date) {
9110                 if (!date) {
9111                         return null;
9112                 }
9113                 date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
9114                 return date;
9115         },
9116
9117         /* Set the date(s) directly. */
9118         _setDate: function(inst, date, noChange) {
9119                 var clear = !date,
9120                         origMonth = inst.selectedMonth,
9121                         origYear = inst.selectedYear,
9122                         newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
9123
9124                 inst.selectedDay = inst.currentDay = newDate.getDate();
9125                 inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
9126                 inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
9127                 if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) {
9128                         this._notifyChange(inst);
9129                 }
9130                 this._adjustInstDate(inst);
9131                 if (inst.input) {
9132                         inst.input.val(clear ? "" : this._formatDate(inst));
9133                 }
9134         },
9135
9136         /* Retrieve the date(s) directly. */
9137         _getDate: function(inst) {
9138                 var startDate = (!inst.currentYear || (inst.input && inst.input.val() === "") ? null :
9139                         this._daylightSavingAdjust(new Date(
9140                         inst.currentYear, inst.currentMonth, inst.currentDay)));
9141                         return startDate;
9142         },
9143
9144         /* Attach the onxxx handlers.  These are declared statically so
9145          * they work with static code transformers like Caja.
9146          */
9147         _attachHandlers: function(inst) {
9148                 var stepMonths = this._get(inst, "stepMonths"),
9149                         id = "#" + inst.id.replace( /\\\\/g, "\\" );
9150                 inst.dpDiv.find("[data-handler]").map(function () {
9151                         var handler = {
9152                                 prev: function () {
9153                                         $.datepicker._adjustDate(id, -stepMonths, "M");
9154                                 },
9155                                 next: function () {
9156                                         $.datepicker._adjustDate(id, +stepMonths, "M");
9157                                 },
9158                                 hide: function () {
9159                                         $.datepicker._hideDatepicker();
9160                                 },
9161                                 today: function () {
9162                                         $.datepicker._gotoToday(id);
9163                                 },
9164                                 selectDay: function () {
9165                                         $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this);
9166                                         return false;
9167                                 },
9168                                 selectMonth: function () {
9169                                         $.datepicker._selectMonthYear(id, this, "M");
9170                                         return false;
9171                                 },
9172                                 selectYear: function () {
9173                                         $.datepicker._selectMonthYear(id, this, "Y");
9174                                         return false;
9175                                 }
9176                         };
9177                         $(this).bind(this.getAttribute("data-event"), handler[this.getAttribute("data-handler")]);
9178                 });
9179         },
9180
9181         /* Generate the HTML for the current state of the date picker. */
9182         _generateHTML: function(inst) {
9183                 var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
9184                         controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
9185                         monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
9186                         selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
9187                         cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
9188                         printDate, dRow, tbody, daySettings, otherMonth, unselectable,
9189                         tempDate = new Date(),
9190                         today = this._daylightSavingAdjust(
9191                                 new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time
9192                         isRTL = this._get(inst, "isRTL"),
9193                         showButtonPanel = this._get(inst, "showButtonPanel"),
9194                         hideIfNoPrevNext = this._get(inst, "hideIfNoPrevNext"),
9195                         navigationAsDateFormat = this._get(inst, "navigationAsDateFormat"),
9196                         numMonths = this._getNumberOfMonths(inst),
9197                         showCurrentAtPos = this._get(inst, "showCurrentAtPos"),
9198                         stepMonths = this._get(inst, "stepMonths"),
9199                         isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1),
9200                         currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
9201                                 new Date(inst.currentYear, inst.currentMonth, inst.currentDay))),
9202                         minDate = this._getMinMaxDate(inst, "min"),
9203                         maxDate = this._getMinMaxDate(inst, "max"),
9204                         drawMonth = inst.drawMonth - showCurrentAtPos,
9205                         drawYear = inst.drawYear;
9206
9207                 if (drawMonth < 0) {
9208                         drawMonth += 12;
9209                         drawYear--;
9210                 }
9211                 if (maxDate) {
9212                         maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
9213                                 maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
9214                         maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
9215                         while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
9216                                 drawMonth--;
9217                                 if (drawMonth < 0) {
9218                                         drawMonth = 11;
9219                                         drawYear--;
9220                                 }
9221                         }
9222                 }
9223                 inst.drawMonth = drawMonth;
9224                 inst.drawYear = drawYear;
9225
9226                 prevText = this._get(inst, "prevText");
9227                 prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
9228                         this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
9229                         this._getFormatConfig(inst)));
9230
9231                 prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
9232                         "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" +
9233                         " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" :
9234                         (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>"));
9235
9236                 nextText = this._get(inst, "nextText");
9237                 nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
9238                         this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
9239                         this._getFormatConfig(inst)));
9240
9241                 next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
9242                         "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" +
9243                         " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" :
9244                         (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>"));
9245
9246                 currentText = this._get(inst, "currentText");
9247                 gotoDate = (this._get(inst, "gotoCurrent") && inst.currentDay ? currentDate : today);
9248                 currentText = (!navigationAsDateFormat ? currentText :
9249                         this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
9250
9251                 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'>" +
9252                         this._get(inst, "closeText") + "</button>" : "");
9253
9254                 buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") +
9255                         (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'" +
9256                         ">" + currentText + "</button>" : "") + (isRTL ? "" : controls) + "</div>" : "";
9257
9258                 firstDay = parseInt(this._get(inst, "firstDay"),10);
9259                 firstDay = (isNaN(firstDay) ? 0 : firstDay);
9260
9261                 showWeek = this._get(inst, "showWeek");
9262                 dayNames = this._get(inst, "dayNames");
9263                 dayNamesMin = this._get(inst, "dayNamesMin");
9264                 monthNames = this._get(inst, "monthNames");
9265                 monthNamesShort = this._get(inst, "monthNamesShort");
9266                 beforeShowDay = this._get(inst, "beforeShowDay");
9267                 showOtherMonths = this._get(inst, "showOtherMonths");
9268                 selectOtherMonths = this._get(inst, "selectOtherMonths");
9269                 defaultDate = this._getDefaultDate(inst);
9270                 html = "";
9271                 dow;
9272                 for (row = 0; row < numMonths[0]; row++) {
9273                         group = "";
9274                         this.maxRows = 4;
9275                         for (col = 0; col < numMonths[1]; col++) {
9276                                 selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
9277                                 cornerClass = " ui-corner-all";
9278                                 calender = "";
9279                                 if (isMultiMonth) {
9280                                         calender += "<div class='ui-datepicker-group";
9281                                         if (numMonths[1] > 1) {
9282                                                 switch (col) {
9283                                                         case 0: calender += " ui-datepicker-group-first";
9284                                                                 cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
9285                                                         case numMonths[1]-1: calender += " ui-datepicker-group-last";
9286                                                                 cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;
9287                                                         default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
9288                                                 }
9289                                         }
9290                                         calender += "'>";
9291                                 }
9292                                 calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
9293                                         (/all|left/.test(cornerClass) && row === 0 ? (isRTL ? next : prev) : "") +
9294                                         (/all|right/.test(cornerClass) && row === 0 ? (isRTL ? prev : next) : "") +
9295                                         this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
9296                                         row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
9297                                         "</div><table class='ui-datepicker-calendar'><thead>" +
9298                                         "<tr>";
9299                                 thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : "");
9300                                 for (dow = 0; dow < 7; dow++) { // days of the week
9301                                         day = (dow + firstDay) % 7;
9302                                         thead += "<th" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" +
9303                                                 "<span title='" + dayNames[day] + "'>" + dayNamesMin[day] + "</span></th>";
9304                                 }
9305                                 calender += thead + "</tr></thead><tbody>";
9306                                 daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
9307                                 if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) {
9308                                         inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
9309                                 }
9310                                 leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
9311                                 curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
9312                                 numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043)
9313                                 this.maxRows = numRows;
9314                                 printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
9315                                 for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows
9316                                         calender += "<tr>";
9317                                         tbody = (!showWeek ? "" : "<td class='ui-datepicker-week-col'>" +
9318                                                 this._get(inst, "calculateWeek")(printDate) + "</td>");
9319                                         for (dow = 0; dow < 7; dow++) { // create date picker days
9320                                                 daySettings = (beforeShowDay ?
9321                                                         beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, ""]);
9322                                                 otherMonth = (printDate.getMonth() !== drawMonth);
9323                                                 unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
9324                                                         (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
9325                                                 tbody += "<td class='" +
9326                                                         ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends
9327                                                         (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months
9328                                                         ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key
9329                                                         (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ?
9330                                                         // or defaultDate is current printedDate and defaultDate is selectedDate
9331                                                         " " + this._dayOverClass : "") + // highlight selected day
9332                                                         (unselectable ? " " + this._unselectableClass + " ui-state-disabled": "") +  // highlight unselectable days
9333                                                         (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates
9334                                                         (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day
9335                                                         (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different)
9336                                                         ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "&#39;") + "'" : "") + // cell title
9337                                                         (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions
9338                                                         (otherMonth && !showOtherMonths ? "&#xa0;" : // display for other months
9339                                                         (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
9340                                                         (printDate.getTime() === today.getTime() ? " ui-state-highlight" : "") +
9341                                                         (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day
9342                                                         (otherMonth ? " ui-priority-secondary" : "") + // distinguish dates from other months
9343                                                         "' href='#'>" + printDate.getDate() + "</a>")) + "</td>"; // display selectable date
9344                                                 printDate.setDate(printDate.getDate() + 1);
9345                                                 printDate = this._daylightSavingAdjust(printDate);
9346                                         }
9347                                         calender += tbody + "</tr>";
9348                                 }
9349                                 drawMonth++;
9350                                 if (drawMonth > 11) {
9351                                         drawMonth = 0;
9352                                         drawYear++;
9353                                 }
9354                                 calender += "</tbody></table>" + (isMultiMonth ? "</div>" +
9355                                                         ((numMonths[0] > 0 && col === numMonths[1]-1) ? "<div class='ui-datepicker-row-break'></div>" : "") : "");
9356                                 group += calender;
9357                         }
9358                         html += group;
9359                 }
9360                 html += buttonPanel;
9361                 inst._keyEvent = false;
9362                 return html;
9363         },
9364
9365         /* Generate the month and year header. */
9366         _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
9367                         secondary, monthNames, monthNamesShort) {
9368
9369                 var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
9370                         changeMonth = this._get(inst, "changeMonth"),
9371                         changeYear = this._get(inst, "changeYear"),
9372                         showMonthAfterYear = this._get(inst, "showMonthAfterYear"),
9373                         html = "<div class='ui-datepicker-title'>",
9374                         monthHtml = "";
9375
9376                 // month selection
9377                 if (secondary || !changeMonth) {
9378                         monthHtml += "<span class='ui-datepicker-month'>" + monthNames[drawMonth] + "</span>";
9379                 } else {
9380                         inMinYear = (minDate && minDate.getFullYear() === drawYear);
9381                         inMaxYear = (maxDate && maxDate.getFullYear() === drawYear);
9382                         monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
9383                         for ( month = 0; month < 12; month++) {
9384                                 if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) {
9385                                         monthHtml += "<option value='" + month + "'" +
9386                                                 (month === drawMonth ? " selected='selected'" : "") +
9387                                                 ">" + monthNamesShort[month] + "</option>";
9388                                 }
9389                         }
9390                         monthHtml += "</select>";
9391                 }
9392
9393                 if (!showMonthAfterYear) {
9394                         html += monthHtml + (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "");
9395                 }
9396
9397                 // year selection
9398                 if ( !inst.yearshtml ) {
9399                         inst.yearshtml = "";
9400                         if (secondary || !changeYear) {
9401                                 html += "<span class='ui-datepicker-year'>" + drawYear + "</span>";
9402                         } else {
9403                                 // determine range of years to display
9404                                 years = this._get(inst, "yearRange").split(":");
9405                                 thisYear = new Date().getFullYear();
9406                                 determineYear = function(value) {
9407                                         var year = (value.match(/c[+\-].*/) ? drawYear + parseInt(value.substring(1), 10) :
9408                                                 (value.match(/[+\-].*/) ? thisYear + parseInt(value, 10) :
9409                                                 parseInt(value, 10)));
9410                                         return (isNaN(year) ? thisYear : year);
9411                                 };
9412                                 year = determineYear(years[0]);
9413                                 endYear = Math.max(year, determineYear(years[1] || ""));
9414                                 year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
9415                                 endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
9416                                 inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
9417                                 for (; year <= endYear; year++) {
9418                                         inst.yearshtml += "<option value='" + year + "'" +
9419                                                 (year === drawYear ? " selected='selected'" : "") +
9420                                                 ">" + year + "</option>";
9421                                 }
9422                                 inst.yearshtml += "</select>";
9423
9424                                 html += inst.yearshtml;
9425                                 inst.yearshtml = null;
9426                         }
9427                 }
9428
9429                 html += this._get(inst, "yearSuffix");
9430                 if (showMonthAfterYear) {
9431                         html += (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "") + monthHtml;
9432                 }
9433                 html += "</div>"; // Close datepicker_header
9434                 return html;
9435         },
9436
9437         /* Adjust one of the date sub-fields. */
9438         _adjustInstDate: function(inst, offset, period) {
9439                 var year = inst.drawYear + (period === "Y" ? offset : 0),
9440                         month = inst.drawMonth + (period === "M" ? offset : 0),
9441                         day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0),
9442                         date = this._restrictMinMax(inst, this._daylightSavingAdjust(new Date(year, month, day)));
9443
9444                 inst.selectedDay = date.getDate();
9445                 inst.drawMonth = inst.selectedMonth = date.getMonth();
9446                 inst.drawYear = inst.selectedYear = date.getFullYear();
9447                 if (period === "M" || period === "Y") {
9448                         this._notifyChange(inst);
9449                 }
9450         },
9451
9452         /* Ensure a date is within any min/max bounds. */
9453         _restrictMinMax: function(inst, date) {
9454                 var minDate = this._getMinMaxDate(inst, "min"),
9455                         maxDate = this._getMinMaxDate(inst, "max"),
9456                         newDate = (minDate && date < minDate ? minDate : date);
9457                 return (maxDate && newDate > maxDate ? maxDate : newDate);
9458         },
9459
9460         /* Notify change of month/year. */
9461         _notifyChange: function(inst) {
9462                 var onChange = this._get(inst, "onChangeMonthYear");
9463                 if (onChange) {
9464                         onChange.apply((inst.input ? inst.input[0] : null),
9465                                 [inst.selectedYear, inst.selectedMonth + 1, inst]);
9466                 }
9467         },
9468
9469         /* Determine the number of months to show. */
9470         _getNumberOfMonths: function(inst) {
9471                 var numMonths = this._get(inst, "numberOfMonths");
9472                 return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths));
9473         },
9474
9475         /* Determine the current maximum date - ensure no time components are set. */
9476         _getMinMaxDate: function(inst, minMax) {
9477                 return this._determineDate(inst, this._get(inst, minMax + "Date"), null);
9478         },
9479
9480         /* Find the number of days in a given month. */
9481         _getDaysInMonth: function(year, month) {
9482                 return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate();
9483         },
9484
9485         /* Find the day of the week of the first of a month. */
9486         _getFirstDayOfMonth: function(year, month) {
9487                 return new Date(year, month, 1).getDay();
9488         },
9489
9490         /* Determines if we should allow a "next/prev" month display change. */
9491         _canAdjustMonth: function(inst, offset, curYear, curMonth) {
9492                 var numMonths = this._getNumberOfMonths(inst),
9493                         date = this._daylightSavingAdjust(new Date(curYear,
9494                         curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
9495
9496                 if (offset < 0) {
9497                         date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
9498                 }
9499                 return this._isInRange(inst, date);
9500         },
9501
9502         /* Is the given date in the accepted range? */
9503         _isInRange: function(inst, date) {
9504                 var yearSplit, currentYear,
9505                         minDate = this._getMinMaxDate(inst, "min"),
9506                         maxDate = this._getMinMaxDate(inst, "max"),
9507                         minYear = null,
9508                         maxYear = null,
9509                         years = this._get(inst, "yearRange");
9510                         if (years){
9511                                 yearSplit = years.split(":");
9512                                 currentYear = new Date().getFullYear();
9513                                 minYear = parseInt(yearSplit[0], 10);
9514                                 maxYear = parseInt(yearSplit[1], 10);
9515                                 if ( yearSplit[0].match(/[+\-].*/) ) {
9516                                         minYear += currentYear;
9517                                 }
9518                                 if ( yearSplit[1].match(/[+\-].*/) ) {
9519                                         maxYear += currentYear;
9520                                 }
9521                         }
9522
9523                 return ((!minDate || date.getTime() >= minDate.getTime()) &&
9524                         (!maxDate || date.getTime() <= maxDate.getTime()) &&
9525                         (!minYear || date.getFullYear() >= minYear) &&
9526                         (!maxYear || date.getFullYear() <= maxYear));
9527         },
9528
9529         /* Provide the configuration settings for formatting/parsing. */
9530         _getFormatConfig: function(inst) {
9531                 var shortYearCutoff = this._get(inst, "shortYearCutoff");
9532                 shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff :
9533                         new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
9534                 return {shortYearCutoff: shortYearCutoff,
9535                         dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"),
9536                         monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")};
9537         },
9538
9539         /* Format the given date for display. */
9540         _formatDate: function(inst, day, month, year) {
9541                 if (!day) {
9542                         inst.currentDay = inst.selectedDay;
9543                         inst.currentMonth = inst.selectedMonth;
9544                         inst.currentYear = inst.selectedYear;
9545                 }
9546                 var date = (day ? (typeof day === "object" ? day :
9547                         this._daylightSavingAdjust(new Date(year, month, day))) :
9548                         this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
9549                 return this.formatDate(this._get(inst, "dateFormat"), date, this._getFormatConfig(inst));
9550         }
9551 });
9552
9553 /*
9554  * Bind hover events for datepicker elements.
9555  * Done via delegate so the binding only occurs once in the lifetime of the parent div.
9556  * Global instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
9557  */
9558 function bindHover(dpDiv) {
9559         var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
9560         return dpDiv.delegate(selector, "mouseout", function() {
9561                         $(this).removeClass("ui-state-hover");
9562                         if (this.className.indexOf("ui-datepicker-prev") !== -1) {
9563                                 $(this).removeClass("ui-datepicker-prev-hover");
9564                         }
9565                         if (this.className.indexOf("ui-datepicker-next") !== -1) {
9566                                 $(this).removeClass("ui-datepicker-next-hover");
9567                         }
9568                 })
9569                 .delegate(selector, "mouseover", function(){
9570                         if (!$.datepicker._isDisabledDatepicker( instActive.inline ? dpDiv.parent()[0] : instActive.input[0])) {
9571                                 $(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover");
9572                                 $(this).addClass("ui-state-hover");
9573                                 if (this.className.indexOf("ui-datepicker-prev") !== -1) {
9574                                         $(this).addClass("ui-datepicker-prev-hover");
9575                                 }
9576                                 if (this.className.indexOf("ui-datepicker-next") !== -1) {
9577                                         $(this).addClass("ui-datepicker-next-hover");
9578                                 }
9579                         }
9580                 });
9581 }
9582
9583 /* jQuery extend now ignores nulls! */
9584 function extendRemove(target, props) {
9585         $.extend(target, props);
9586         for (var name in props) {
9587                 if (props[name] == null) {
9588                         target[name] = props[name];
9589                 }
9590         }
9591         return target;
9592 }
9593
9594 /* Invoke the datepicker functionality.
9595    @param  options  string - a command, optionally followed by additional parameters or
9596                                         Object - settings for attaching new datepicker functionality
9597    @return  jQuery object */
9598 $.fn.datepicker = function(options){
9599
9600         /* Verify an empty collection wasn't passed - Fixes #6976 */
9601         if ( !this.length ) {
9602                 return this;
9603         }
9604
9605         /* Initialise the date picker. */
9606         if (!$.datepicker.initialized) {
9607                 $(document).mousedown($.datepicker._checkExternalClick);
9608                 $.datepicker.initialized = true;
9609         }
9610
9611         /* Append datepicker main container to body if not exist. */
9612         if ($("#"+$.datepicker._mainDivId).length === 0) {
9613                 $("body").append($.datepicker.dpDiv);
9614         }
9615
9616         var otherArgs = Array.prototype.slice.call(arguments, 1);
9617         if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) {
9618                 return $.datepicker["_" + options + "Datepicker"].
9619                         apply($.datepicker, [this[0]].concat(otherArgs));
9620         }
9621         if (options === "option" && arguments.length === 2 && typeof arguments[1] === "string") {
9622                 return $.datepicker["_" + options + "Datepicker"].
9623                         apply($.datepicker, [this[0]].concat(otherArgs));
9624         }
9625         return this.each(function() {
9626                 typeof options === "string" ?
9627                         $.datepicker["_" + options + "Datepicker"].
9628                                 apply($.datepicker, [this].concat(otherArgs)) :
9629                         $.datepicker._attachDatepicker(this, options);
9630         });
9631 };
9632
9633 $.datepicker = new Datepicker(); // singleton instance
9634 $.datepicker.initialized = false;
9635 $.datepicker.uuid = new Date().getTime();
9636 $.datepicker.version = "1.10.3";
9637
9638 })(jQuery);
9639
9640 (function( $, undefined ) {
9641
9642 var sizeRelatedOptions = {
9643                 buttons: true,
9644                 height: true,
9645                 maxHeight: true,
9646                 maxWidth: true,
9647                 minHeight: true,
9648                 minWidth: true,
9649                 width: true
9650         },
9651         resizableRelatedOptions = {
9652                 maxHeight: true,
9653                 maxWidth: true,
9654                 minHeight: true,
9655                 minWidth: true
9656         };
9657
9658 $.widget( "ui.dialog", {
9659         version: "1.10.3",
9660         options: {
9661                 appendTo: "body",
9662                 autoOpen: true,
9663                 buttons: [],
9664                 closeOnEscape: true,
9665                 closeText: "close",
9666                 dialogClass: "",
9667                 draggable: true,
9668                 hide: null,
9669                 height: "auto",
9670                 maxHeight: null,
9671                 maxWidth: null,
9672                 minHeight: 150,
9673                 minWidth: 150,
9674                 modal: false,
9675                 position: {
9676                         my: "center",
9677                         at: "center",
9678                         of: window,
9679                         collision: "fit",
9680                         // Ensure the titlebar is always visible
9681                         using: function( pos ) {
9682                                 var topOffset = $( this ).css( pos ).offset().top;
9683                                 if ( topOffset < 0 ) {
9684                                         $( this ).css( "top", pos.top - topOffset );
9685                                 }
9686                         }
9687                 },
9688                 resizable: true,
9689                 show: null,
9690                 title: null,
9691                 width: 300,
9692
9693                 // callbacks
9694                 beforeClose: null,
9695                 close: null,
9696                 drag: null,
9697                 dragStart: null,
9698                 dragStop: null,
9699                 focus: null,
9700                 open: null,
9701                 resize: null,
9702                 resizeStart: null,
9703                 resizeStop: null
9704         },
9705
9706         _create: function() {
9707                 this.originalCss = {
9708                         display: this.element[0].style.display,
9709                         width: this.element[0].style.width,
9710                         minHeight: this.element[0].style.minHeight,
9711                         maxHeight: this.element[0].style.maxHeight,
9712                         height: this.element[0].style.height
9713                 };
9714                 this.originalPosition = {
9715                         parent: this.element.parent(),
9716                         index: this.element.parent().children().index( this.element )
9717                 };
9718                 this.originalTitle = this.element.attr("title");
9719                 this.options.title = this.options.title || this.originalTitle;
9720
9721                 this._createWrapper();
9722
9723                 this.element
9724                         .show()
9725                         .removeAttr("title")
9726                         .addClass("ui-dialog-content ui-widget-content")
9727                         .appendTo( this.uiDialog );
9728
9729                 this._createTitlebar();
9730                 this._createButtonPane();
9731
9732                 if ( this.options.draggable && $.fn.draggable ) {
9733                         this._makeDraggable();
9734                 }
9735                 if ( this.options.resizable && $.fn.resizable ) {
9736                         this._makeResizable();
9737                 }
9738
9739                 this._isOpen = false;
9740         },
9741
9742         _init: function() {
9743                 if ( this.options.autoOpen ) {
9744                         this.open();
9745                 }
9746         },
9747
9748         _appendTo: function() {
9749                 var element = this.options.appendTo;
9750                 if ( element && (element.jquery || element.nodeType) ) {
9751                         return $( element );
9752                 }
9753                 return this.document.find( element || "body" ).eq( 0 );
9754         },
9755
9756         _destroy: function() {
9757                 var next,
9758                         originalPosition = this.originalPosition;
9759
9760                 this._destroyOverlay();
9761
9762                 this.element
9763                         .removeUniqueId()
9764                         .removeClass("ui-dialog-content ui-widget-content")
9765                         .css( this.originalCss )
9766                         // Without detaching first, the following becomes really slow
9767                         .detach();
9768
9769                 this.uiDialog.stop( true, true ).remove();
9770
9771                 if ( this.originalTitle ) {
9772                         this.element.attr( "title", this.originalTitle );
9773                 }
9774
9775                 next = originalPosition.parent.children().eq( originalPosition.index );
9776                 // Don't try to place the dialog next to itself (#8613)
9777                 if ( next.length && next[0] !== this.element[0] ) {
9778                         next.before( this.element );
9779                 } else {
9780                         originalPosition.parent.append( this.element );
9781                 }
9782         },
9783
9784         widget: function() {
9785                 return this.uiDialog;
9786         },
9787
9788         disable: $.noop,
9789         enable: $.noop,
9790
9791         close: function( event ) {
9792                 var that = this;
9793
9794                 if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {
9795                         return;
9796                 }
9797
9798                 this._isOpen = false;
9799                 this._destroyOverlay();
9800
9801                 if ( !this.opener.filter(":focusable").focus().length ) {
9802                         // Hiding a focused element doesn't trigger blur in WebKit
9803                         // so in case we have nothing to focus on, explicitly blur the active element
9804                         // https://bugs.webkit.org/show_bug.cgi?id=47182
9805                         $( this.document[0].activeElement ).blur();
9806                 }
9807
9808                 this._hide( this.uiDialog, this.options.hide, function() {
9809                         that._trigger( "close", event );
9810                 });
9811         },
9812
9813         isOpen: function() {
9814                 return this._isOpen;
9815         },
9816
9817         moveToTop: function() {
9818                 this._moveToTop();
9819         },
9820
9821         _moveToTop: function( event, silent ) {
9822                 var moved = !!this.uiDialog.nextAll(":visible").insertBefore( this.uiDialog ).length;
9823                 if ( moved && !silent ) {
9824                         this._trigger( "focus", event );
9825                 }
9826                 return moved;
9827         },
9828
9829         open: function() {
9830                 var that = this;
9831                 if ( this._isOpen ) {
9832                         if ( this._moveToTop() ) {
9833                                 this._focusTabbable();
9834                         }
9835                         return;
9836                 }
9837
9838                 this._isOpen = true;
9839                 this.opener = $( this.document[0].activeElement );
9840
9841                 this._size();
9842                 this._position();
9843                 this._createOverlay();
9844                 this._moveToTop( null, true );
9845                 this._show( this.uiDialog, this.options.show, function() {
9846                         that._focusTabbable();
9847                         that._trigger("focus");
9848                 });
9849
9850                 this._trigger("open");
9851         },
9852
9853         _focusTabbable: function() {
9854                 // Set focus to the first match:
9855                 // 1. First element inside the dialog matching [autofocus]
9856                 // 2. Tabbable element inside the content element
9857                 // 3. Tabbable element inside the buttonpane
9858                 // 4. The close button
9859                 // 5. The dialog itself
9860                 var hasFocus = this.element.find("[autofocus]");
9861                 if ( !hasFocus.length ) {
9862                         hasFocus = this.element.find(":tabbable");
9863                 }
9864                 if ( !hasFocus.length ) {
9865                         hasFocus = this.uiDialogButtonPane.find(":tabbable");
9866                 }
9867                 if ( !hasFocus.length ) {
9868                         hasFocus = this.uiDialogTitlebarClose.filter(":tabbable");
9869                 }
9870                 if ( !hasFocus.length ) {
9871                         hasFocus = this.uiDialog;
9872                 }
9873                 hasFocus.eq( 0 ).focus();
9874         },
9875
9876         _keepFocus: function( event ) {
9877                 function checkFocus() {
9878                         var activeElement = this.document[0].activeElement,
9879                                 isActive = this.uiDialog[0] === activeElement ||
9880                                         $.contains( this.uiDialog[0], activeElement );
9881                         if ( !isActive ) {
9882                                 this._focusTabbable();
9883                         }
9884                 }
9885                 event.preventDefault();
9886                 checkFocus.call( this );
9887                 // support: IE
9888                 // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
9889                 // so we check again later
9890                 this._delay( checkFocus );
9891         },
9892
9893         _createWrapper: function() {
9894                 this.uiDialog = $("<div>")
9895                         .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
9896                                 this.options.dialogClass )
9897                         .hide()
9898                         .attr({
9899                                 // Setting tabIndex makes the div focusable
9900                                 tabIndex: -1,
9901                                 role: "dialog"
9902                         })
9903                         .appendTo( this._appendTo() );
9904
9905                 this._on( this.uiDialog, {
9906                         keydown: function( event ) {
9907                                 if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
9908                                                 event.keyCode === $.ui.keyCode.ESCAPE ) {
9909                                         event.preventDefault();
9910                                         this.close( event );
9911                                         return;
9912                                 }
9913
9914                                 // prevent tabbing out of dialogs
9915                                 if ( event.keyCode !== $.ui.keyCode.TAB ) {
9916                                         return;
9917                                 }
9918                                 var tabbables = this.uiDialog.find(":tabbable"),
9919                                         first = tabbables.filter(":first"),
9920                                         last  = tabbables.filter(":last");
9921
9922                                 if ( ( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey ) {
9923                                         first.focus( 1 );
9924                                         event.preventDefault();
9925                                 } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) {
9926                                         last.focus( 1 );
9927                                         event.preventDefault();
9928                                 }
9929                         },
9930                         mousedown: function( event ) {
9931                                 if ( this._moveToTop( event ) ) {
9932                                         this._focusTabbable();
9933                                 }
9934                         }
9935                 });
9936
9937                 // We assume that any existing aria-describedby attribute means
9938                 // that the dialog content is marked up properly
9939                 // otherwise we brute force the content as the description
9940                 if ( !this.element.find("[aria-describedby]").length ) {
9941                         this.uiDialog.attr({
9942                                 "aria-describedby": this.element.uniqueId().attr("id")
9943                         });
9944                 }
9945         },
9946
9947         _createTitlebar: function() {
9948                 var uiDialogTitle;
9949
9950                 this.uiDialogTitlebar = $("<div>")
9951                         .addClass("ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix")
9952                         .prependTo( this.uiDialog );
9953                 this._on( this.uiDialogTitlebar, {
9954                         mousedown: function( event ) {
9955                                 // Don't prevent click on close button (#8838)
9956                                 // Focusing a dialog that is partially scrolled out of view
9957                                 // causes the browser to scroll it into view, preventing the click event
9958                                 if ( !$( event.target ).closest(".ui-dialog-titlebar-close") ) {
9959                                         // Dialog isn't getting focus when dragging (#8063)
9960                                         this.uiDialog.focus();
9961                                 }
9962                         }
9963                 });
9964
9965                 this.uiDialogTitlebarClose = $("<button></button>")
9966                         .button({
9967                                 label: this.options.closeText,
9968                                 icons: {
9969                                         primary: "ui-icon-closethick"
9970                                 },
9971                                 text: false
9972                         })
9973                         .addClass("ui-dialog-titlebar-close")
9974                         .appendTo( this.uiDialogTitlebar );
9975                 this._on( this.uiDialogTitlebarClose, {
9976                         click: function( event ) {
9977                                 event.preventDefault();
9978                                 this.close( event );
9979                         }
9980                 });
9981
9982                 uiDialogTitle = $("<span>")
9983                         .uniqueId()
9984                         .addClass("ui-dialog-title")
9985                         .prependTo( this.uiDialogTitlebar );
9986                 this._title( uiDialogTitle );
9987
9988                 this.uiDialog.attr({
9989                         "aria-labelledby": uiDialogTitle.attr("id")
9990                 });
9991         },
9992
9993         _title: function( title ) {
9994                 if ( !this.options.title ) {
9995                         title.html("&#160;");
9996                 }
9997                 title.text( this.options.title );
9998         },
9999
10000         _createButtonPane: function() {
10001                 this.uiDialogButtonPane = $("<div>")
10002                         .addClass("ui-dialog-buttonpane ui-widget-content ui-helper-clearfix");
10003
10004                 this.uiButtonSet = $("<div>")
10005                         .addClass("ui-dialog-buttonset")
10006                         .appendTo( this.uiDialogButtonPane );
10007
10008                 this._createButtons();
10009         },
10010
10011         _createButtons: function() {
10012                 var that = this,
10013                         buttons = this.options.buttons;
10014
10015                 // if we already have a button pane, remove it
10016                 this.uiDialogButtonPane.remove();
10017                 this.uiButtonSet.empty();
10018
10019                 if ( $.isEmptyObject( buttons ) || ($.isArray( buttons ) && !buttons.length) ) {
10020                         this.uiDialog.removeClass("ui-dialog-buttons");
10021                         return;
10022                 }
10023
10024                 $.each( buttons, function( name, props ) {
10025                         var click, buttonOptions;
10026                         props = $.isFunction( props ) ?
10027                                 { click: props, text: name } :
10028                                 props;
10029                         // Default to a non-submitting button
10030                         props = $.extend( { type: "button" }, props );
10031                         // Change the context for the click callback to be the main element
10032                         click = props.click;
10033                         props.click = function() {
10034                                 click.apply( that.element[0], arguments );
10035                         };
10036                         buttonOptions = {
10037                                 icons: props.icons,
10038                                 text: props.showText
10039                         };
10040                         delete props.icons;
10041                         delete props.showText;
10042                         $( "<button></button>", props )
10043                                 .button( buttonOptions )
10044                                 .appendTo( that.uiButtonSet );
10045                 });
10046                 this.uiDialog.addClass("ui-dialog-buttons");
10047                 this.uiDialogButtonPane.appendTo( this.uiDialog );
10048         },
10049
10050         _makeDraggable: function() {
10051                 var that = this,
10052                         options = this.options;
10053
10054                 function filteredUi( ui ) {
10055                         return {
10056                                 position: ui.position,
10057                                 offset: ui.offset
10058                         };
10059                 }
10060
10061                 this.uiDialog.draggable({
10062                         cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
10063                         handle: ".ui-dialog-titlebar",
10064                         containment: "document",
10065                         start: function( event, ui ) {
10066                                 $( this ).addClass("ui-dialog-dragging");
10067                                 that._blockFrames();
10068                                 that._trigger( "dragStart", event, filteredUi( ui ) );
10069                         },
10070                         drag: function( event, ui ) {
10071                                 that._trigger( "drag", event, filteredUi( ui ) );
10072                         },
10073                         stop: function( event, ui ) {
10074                                 options.position = [
10075                                         ui.position.left - that.document.scrollLeft(),
10076                                         ui.position.top - that.document.scrollTop()
10077                                 ];
10078                                 $( this ).removeClass("ui-dialog-dragging");
10079                                 that._unblockFrames();
10080                                 that._trigger( "dragStop", event, filteredUi( ui ) );
10081                         }
10082                 });
10083         },
10084
10085         _makeResizable: function() {
10086                 var that = this,
10087                         options = this.options,
10088                         handles = options.resizable,
10089                         // .ui-resizable has position: relative defined in the stylesheet
10090                         // but dialogs have to use absolute or fixed positioning
10091                         position = this.uiDialog.css("position"),
10092                         resizeHandles = typeof handles === "string" ?
10093                                 handles :
10094                                 "n,e,s,w,se,sw,ne,nw";
10095
10096                 function filteredUi( ui ) {
10097                         return {
10098                                 originalPosition: ui.originalPosition,
10099                                 originalSize: ui.originalSize,
10100                                 position: ui.position,
10101                                 size: ui.size
10102                         };
10103                 }
10104
10105                 this.uiDialog.resizable({
10106                         cancel: ".ui-dialog-content",
10107                         containment: "document",
10108                         alsoResize: this.element,
10109                         maxWidth: options.maxWidth,
10110                         maxHeight: options.maxHeight,
10111                         minWidth: options.minWidth,
10112                         minHeight: this._minHeight(),
10113                         handles: resizeHandles,
10114                         start: function( event, ui ) {
10115                                 $( this ).addClass("ui-dialog-resizing");
10116                                 that._blockFrames();
10117                                 that._trigger( "resizeStart", event, filteredUi( ui ) );
10118                         },
10119                         resize: function( event, ui ) {
10120                                 that._trigger( "resize", event, filteredUi( ui ) );
10121                         },
10122                         stop: function( event, ui ) {
10123                                 options.height = $( this ).height();
10124                                 options.width = $( this ).width();
10125                                 $( this ).removeClass("ui-dialog-resizing");
10126                                 that._unblockFrames();
10127                                 that._trigger( "resizeStop", event, filteredUi( ui ) );
10128                         }
10129                 })
10130                 .css( "position", position );
10131         },
10132
10133         _minHeight: function() {
10134                 var options = this.options;
10135
10136                 return options.height === "auto" ?
10137                         options.minHeight :
10138                         Math.min( options.minHeight, options.height );
10139         },
10140
10141         _position: function() {
10142                 // Need to show the dialog to get the actual offset in the position plugin
10143                 var isVisible = this.uiDialog.is(":visible");
10144                 if ( !isVisible ) {
10145                         this.uiDialog.show();
10146                 }
10147                 this.uiDialog.position( this.options.position );
10148                 if ( !isVisible ) {
10149                         this.uiDialog.hide();
10150                 }
10151         },
10152
10153         _setOptions: function( options ) {
10154                 var that = this,
10155                         resize = false,
10156                         resizableOptions = {};
10157
10158                 $.each( options, function( key, value ) {
10159                         that._setOption( key, value );
10160
10161                         if ( key in sizeRelatedOptions ) {
10162                                 resize = true;
10163                         }
10164                         if ( key in resizableRelatedOptions ) {
10165                                 resizableOptions[ key ] = value;
10166                         }
10167                 });
10168
10169                 if ( resize ) {
10170                         this._size();
10171                         this._position();
10172                 }
10173                 if ( this.uiDialog.is(":data(ui-resizable)") ) {
10174                         this.uiDialog.resizable( "option", resizableOptions );
10175                 }
10176         },
10177
10178         _setOption: function( key, value ) {
10179                 /*jshint maxcomplexity:15*/
10180                 var isDraggable, isResizable,
10181                         uiDialog = this.uiDialog;
10182
10183                 if ( key === "dialogClass" ) {
10184                         uiDialog
10185                                 .removeClass( this.options.dialogClass )
10186                                 .addClass( value );
10187                 }
10188
10189                 if ( key === "disabled" ) {
10190                         return;
10191                 }
10192
10193                 this._super( key, value );
10194
10195                 if ( key === "appendTo" ) {
10196                         this.uiDialog.appendTo( this._appendTo() );
10197                 }
10198
10199                 if ( key === "buttons" ) {
10200                         this._createButtons();
10201                 }
10202
10203                 if ( key === "closeText" ) {
10204                         this.uiDialogTitlebarClose.button({
10205                                 // Ensure that we always pass a string
10206                                 label: "" + value
10207                         });
10208                 }
10209
10210                 if ( key === "draggable" ) {
10211                         isDraggable = uiDialog.is(":data(ui-draggable)");
10212                         if ( isDraggable && !value ) {
10213                                 uiDialog.draggable("destroy");
10214                         }
10215
10216                         if ( !isDraggable && value ) {
10217                                 this._makeDraggable();
10218                         }
10219                 }
10220
10221                 if ( key === "position" ) {
10222                         this._position();
10223                 }
10224
10225                 if ( key === "resizable" ) {
10226                         // currently resizable, becoming non-resizable
10227                         isResizable = uiDialog.is(":data(ui-resizable)");
10228                         if ( isResizable && !value ) {
10229                                 uiDialog.resizable("destroy");
10230                         }
10231
10232                         // currently resizable, changing handles
10233                         if ( isResizable && typeof value === "string" ) {
10234                                 uiDialog.resizable( "option", "handles", value );
10235                         }
10236
10237                         // currently non-resizable, becoming resizable
10238                         if ( !isResizable && value !== false ) {
10239                                 this._makeResizable();
10240                         }
10241                 }
10242
10243                 if ( key === "title" ) {
10244                         this._title( this.uiDialogTitlebar.find(".ui-dialog-title") );
10245                 }
10246         },
10247
10248         _size: function() {
10249                 // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
10250                 // divs will both have width and height set, so we need to reset them
10251                 var nonContentHeight, minContentHeight, maxContentHeight,
10252                         options = this.options;
10253
10254                 // Reset content sizing
10255                 this.element.show().css({
10256                         width: "auto",
10257                         minHeight: 0,
10258                         maxHeight: "none",
10259                         height: 0
10260                 });
10261
10262                 if ( options.minWidth > options.width ) {
10263                         options.width = options.minWidth;
10264                 }
10265
10266                 // reset wrapper sizing
10267                 // determine the height of all the non-content elements
10268                 nonContentHeight = this.uiDialog.css({
10269                                 height: "auto",
10270                                 width: options.width
10271                         })
10272                         .outerHeight();
10273                 minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
10274                 maxContentHeight = typeof options.maxHeight === "number" ?
10275                         Math.max( 0, options.maxHeight - nonContentHeight ) :
10276                         "none";
10277
10278                 if ( options.height === "auto" ) {
10279                         this.element.css({
10280                                 minHeight: minContentHeight,
10281                                 maxHeight: maxContentHeight,
10282                                 height: "auto"
10283                         });
10284                 } else {
10285                         this.element.height( Math.max( 0, options.height - nonContentHeight ) );
10286                 }
10287
10288                 if (this.uiDialog.is(":data(ui-resizable)") ) {
10289                         this.uiDialog.resizable( "option", "minHeight", this._minHeight() );
10290                 }
10291         },
10292
10293         _blockFrames: function() {
10294                 this.iframeBlocks = this.document.find( "iframe" ).map(function() {
10295                         var iframe = $( this );
10296
10297                         return $( "<div>" )
10298                                 .css({
10299                                         position: "absolute",
10300                                         width: iframe.outerWidth(),
10301                                         height: iframe.outerHeight()
10302                                 })
10303                                 .appendTo( iframe.parent() )
10304                                 .offset( iframe.offset() )[0];
10305                 });
10306         },
10307
10308         _unblockFrames: function() {
10309                 if ( this.iframeBlocks ) {
10310                         this.iframeBlocks.remove();
10311                         delete this.iframeBlocks;
10312                 }
10313         },
10314
10315         _allowInteraction: function( event ) {
10316                 if ( $( event.target ).closest(".ui-dialog").length ) {
10317                         return true;
10318                 }
10319
10320                 // TODO: Remove hack when datepicker implements
10321                 // the .ui-front logic (#8989)
10322                 return !!$( event.target ).closest(".ui-datepicker").length;
10323         },
10324
10325         _createOverlay: function() {
10326                 if ( !this.options.modal ) {
10327                         return;
10328                 }
10329
10330                 var that = this,
10331                         widgetFullName = this.widgetFullName;
10332                 if ( !$.ui.dialog.overlayInstances ) {
10333                         // Prevent use of anchors and inputs.
10334                         // We use a delay in case the overlay is created from an
10335                         // event that we're going to be cancelling. (#2804)
10336                         this._delay(function() {
10337                                 // Handle .dialog().dialog("close") (#4065)
10338                                 if ( $.ui.dialog.overlayInstances ) {
10339                                         this.document.bind( "focusin.dialog", function( event ) {
10340                                                 if ( !that._allowInteraction( event ) ) {
10341                                                         event.preventDefault();
10342                                                         $(".ui-dialog:visible:last .ui-dialog-content")
10343                                                                 .data( widgetFullName )._focusTabbable();
10344                                                 }
10345                                         });
10346                                 }
10347                         });
10348                 }
10349
10350                 this.overlay = $("<div>")
10351                         .addClass("ui-widget-overlay ui-front")
10352                         .appendTo( this._appendTo() );
10353                 this._on( this.overlay, {
10354                         mousedown: "_keepFocus"
10355                 });
10356                 $.ui.dialog.overlayInstances++;
10357         },
10358
10359         _destroyOverlay: function() {
10360                 if ( !this.options.modal ) {
10361                         return;
10362                 }
10363
10364                 if ( this.overlay ) {
10365                         $.ui.dialog.overlayInstances--;
10366
10367                         if ( !$.ui.dialog.overlayInstances ) {
10368                                 this.document.unbind( "focusin.dialog" );
10369                         }
10370                         this.overlay.remove();
10371                         this.overlay = null;
10372                 }
10373         }
10374 });
10375
10376 $.ui.dialog.overlayInstances = 0;
10377
10378 // DEPRECATED
10379 if ( $.uiBackCompat !== false ) {
10380         // position option with array notation
10381         // just override with old implementation
10382         $.widget( "ui.dialog", $.ui.dialog, {
10383                 _position: function() {
10384                         var position = this.options.position,
10385                                 myAt = [],
10386                                 offset = [ 0, 0 ],
10387                                 isVisible;
10388
10389                         if ( position ) {
10390                                 if ( typeof position === "string" || (typeof position === "object" && "0" in position ) ) {
10391                                         myAt = position.split ? position.split(" ") : [ position[0], position[1] ];
10392                                         if ( myAt.length === 1 ) {
10393                                                 myAt[1] = myAt[0];
10394                                         }
10395
10396                                         $.each( [ "left", "top" ], function( i, offsetPosition ) {
10397                                                 if ( +myAt[ i ] === myAt[ i ] ) {
10398                                                         offset[ i ] = myAt[ i ];
10399                                                         myAt[ i ] = offsetPosition;
10400                                                 }
10401                                         });
10402
10403                                         position = {
10404                                                 my: myAt[0] + (offset[0] < 0 ? offset[0] : "+" + offset[0]) + " " +
10405                                                         myAt[1] + (offset[1] < 0 ? offset[1] : "+" + offset[1]),
10406                                                 at: myAt.join(" ")
10407                                         };
10408                                 }
10409
10410                                 position = $.extend( {}, $.ui.dialog.prototype.options.position, position );
10411                         } else {
10412                                 position = $.ui.dialog.prototype.options.position;
10413                         }
10414
10415                         // need to show the dialog to get the actual offset in the position plugin
10416                         isVisible = this.uiDialog.is(":visible");
10417                         if ( !isVisible ) {
10418                                 this.uiDialog.show();
10419                         }
10420                         this.uiDialog.position( position );
10421                         if ( !isVisible ) {
10422                                 this.uiDialog.hide();
10423                         }
10424                 }
10425         });
10426 }
10427
10428 }( jQuery ) );
10429
10430 (function( $, undefined ) {
10431
10432 var rvertical = /up|down|vertical/,
10433         rpositivemotion = /up|left|vertical|horizontal/;
10434
10435 $.effects.effect.blind = function( o, done ) {
10436         // Create element
10437         var el = $( this ),
10438                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10439                 mode = $.effects.setMode( el, o.mode || "hide" ),
10440                 direction = o.direction || "up",
10441                 vertical = rvertical.test( direction ),
10442                 ref = vertical ? "height" : "width",
10443                 ref2 = vertical ? "top" : "left",
10444                 motion = rpositivemotion.test( direction ),
10445                 animation = {},
10446                 show = mode === "show",
10447                 wrapper, distance, margin;
10448
10449         // if already wrapped, the wrapper's properties are my property. #6245
10450         if ( el.parent().is( ".ui-effects-wrapper" ) ) {
10451                 $.effects.save( el.parent(), props );
10452         } else {
10453                 $.effects.save( el, props );
10454         }
10455         el.show();
10456         wrapper = $.effects.createWrapper( el ).css({
10457                 overflow: "hidden"
10458         });
10459
10460         distance = wrapper[ ref ]();
10461         margin = parseFloat( wrapper.css( ref2 ) ) || 0;
10462
10463         animation[ ref ] = show ? distance : 0;
10464         if ( !motion ) {
10465                 el
10466                         .css( vertical ? "bottom" : "right", 0 )
10467                         .css( vertical ? "top" : "left", "auto" )
10468                         .css({ position: "absolute" });
10469
10470                 animation[ ref2 ] = show ? margin : distance + margin;
10471         }
10472
10473         // start at 0 if we are showing
10474         if ( show ) {
10475                 wrapper.css( ref, 0 );
10476                 if ( ! motion ) {
10477                         wrapper.css( ref2, margin + distance );
10478                 }
10479         }
10480
10481         // Animate
10482         wrapper.animate( animation, {
10483                 duration: o.duration,
10484                 easing: o.easing,
10485                 queue: false,
10486                 complete: function() {
10487                         if ( mode === "hide" ) {
10488                                 el.hide();
10489                         }
10490                         $.effects.restore( el, props );
10491                         $.effects.removeWrapper( el );
10492                         done();
10493                 }
10494         });
10495
10496 };
10497
10498 })(jQuery);
10499
10500 (function( $, undefined ) {
10501
10502 $.effects.effect.bounce = function( o, done ) {
10503         var el = $( this ),
10504                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10505
10506                 // defaults:
10507                 mode = $.effects.setMode( el, o.mode || "effect" ),
10508                 hide = mode === "hide",
10509                 show = mode === "show",
10510                 direction = o.direction || "up",
10511                 distance = o.distance,
10512                 times = o.times || 5,
10513
10514                 // number of internal animations
10515                 anims = times * 2 + ( show || hide ? 1 : 0 ),
10516                 speed = o.duration / anims,
10517                 easing = o.easing,
10518
10519                 // utility:
10520                 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
10521                 motion = ( direction === "up" || direction === "left" ),
10522                 i,
10523                 upAnim,
10524                 downAnim,
10525
10526                 // we will need to re-assemble the queue to stack our animations in place
10527                 queue = el.queue(),
10528                 queuelen = queue.length;
10529
10530         // Avoid touching opacity to prevent clearType and PNG issues in IE
10531         if ( show || hide ) {
10532                 props.push( "opacity" );
10533         }
10534
10535         $.effects.save( el, props );
10536         el.show();
10537         $.effects.createWrapper( el ); // Create Wrapper
10538
10539         // default distance for the BIGGEST bounce is the outer Distance / 3
10540         if ( !distance ) {
10541                 distance = el[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
10542         }
10543
10544         if ( show ) {
10545                 downAnim = { opacity: 1 };
10546                 downAnim[ ref ] = 0;
10547
10548                 // if we are showing, force opacity 0 and set the initial position
10549                 // then do the "first" animation
10550                 el.css( "opacity", 0 )
10551                         .css( ref, motion ? -distance * 2 : distance * 2 )
10552                         .animate( downAnim, speed, easing );
10553         }
10554
10555         // start at the smallest distance if we are hiding
10556         if ( hide ) {
10557                 distance = distance / Math.pow( 2, times - 1 );
10558         }
10559
10560         downAnim = {};
10561         downAnim[ ref ] = 0;
10562         // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
10563         for ( i = 0; i < times; i++ ) {
10564                 upAnim = {};
10565                 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
10566
10567                 el.animate( upAnim, speed, easing )
10568                         .animate( downAnim, speed, easing );
10569
10570                 distance = hide ? distance * 2 : distance / 2;
10571         }
10572
10573         // Last Bounce when Hiding
10574         if ( hide ) {
10575                 upAnim = { opacity: 0 };
10576                 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
10577
10578                 el.animate( upAnim, speed, easing );
10579         }
10580
10581         el.queue(function() {
10582                 if ( hide ) {
10583                         el.hide();
10584                 }
10585                 $.effects.restore( el, props );
10586                 $.effects.removeWrapper( el );
10587                 done();
10588         });
10589
10590         // inject all the animations we just queued to be first in line (after "inprogress")
10591         if ( queuelen > 1) {
10592                 queue.splice.apply( queue,
10593                         [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
10594         }
10595         el.dequeue();
10596
10597 };
10598
10599 })(jQuery);
10600
10601 (function( $, undefined ) {
10602
10603 $.effects.effect.clip = function( o, done ) {
10604         // Create element
10605         var el = $( this ),
10606                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10607                 mode = $.effects.setMode( el, o.mode || "hide" ),
10608                 show = mode === "show",
10609                 direction = o.direction || "vertical",
10610                 vert = direction === "vertical",
10611                 size = vert ? "height" : "width",
10612                 position = vert ? "top" : "left",
10613                 animation = {},
10614                 wrapper, animate, distance;
10615
10616         // Save & Show
10617         $.effects.save( el, props );
10618         el.show();
10619
10620         // Create Wrapper
10621         wrapper = $.effects.createWrapper( el ).css({
10622                 overflow: "hidden"
10623         });
10624         animate = ( el[0].tagName === "IMG" ) ? wrapper : el;
10625         distance = animate[ size ]();
10626
10627         // Shift
10628         if ( show ) {
10629                 animate.css( size, 0 );
10630                 animate.css( position, distance / 2 );
10631         }
10632
10633         // Create Animation Object:
10634         animation[ size ] = show ? distance : 0;
10635         animation[ position ] = show ? 0 : distance / 2;
10636
10637         // Animate
10638         animate.animate( animation, {
10639                 queue: false,
10640                 duration: o.duration,
10641                 easing: o.easing,
10642                 complete: function() {
10643                         if ( !show ) {
10644                                 el.hide();
10645                         }
10646                         $.effects.restore( el, props );
10647                         $.effects.removeWrapper( el );
10648                         done();
10649                 }
10650         });
10651
10652 };
10653
10654 })(jQuery);
10655
10656 (function( $, undefined ) {
10657
10658 $.effects.effect.drop = function( o, done ) {
10659
10660         var el = $( this ),
10661                 props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
10662                 mode = $.effects.setMode( el, o.mode || "hide" ),
10663                 show = mode === "show",
10664                 direction = o.direction || "left",
10665                 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
10666                 motion = ( direction === "up" || direction === "left" ) ? "pos" : "neg",
10667                 animation = {
10668                         opacity: show ? 1 : 0
10669                 },
10670                 distance;
10671
10672         // Adjust
10673         $.effects.save( el, props );
10674         el.show();
10675         $.effects.createWrapper( el );
10676
10677         distance = o.distance || el[ ref === "top" ? "outerHeight": "outerWidth" ]( true ) / 2;
10678
10679         if ( show ) {
10680                 el
10681                         .css( "opacity", 0 )
10682                         .css( ref, motion === "pos" ? -distance : distance );
10683         }
10684
10685         // Animation
10686         animation[ ref ] = ( show ?
10687                 ( motion === "pos" ? "+=" : "-=" ) :
10688                 ( motion === "pos" ? "-=" : "+=" ) ) +
10689                 distance;
10690
10691         // Animate
10692         el.animate( animation, {
10693                 queue: false,
10694                 duration: o.duration,
10695                 easing: o.easing,
10696                 complete: function() {
10697                         if ( mode === "hide" ) {
10698                                 el.hide();
10699                         }
10700                         $.effects.restore( el, props );
10701                         $.effects.removeWrapper( el );
10702                         done();
10703                 }
10704         });
10705 };
10706
10707 })(jQuery);
10708
10709 (function( $, undefined ) {
10710
10711 $.effects.effect.explode = function( o, done ) {
10712
10713         var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3,
10714                 cells = rows,
10715                 el = $( this ),
10716                 mode = $.effects.setMode( el, o.mode || "hide" ),
10717                 show = mode === "show",
10718
10719                 // show and then visibility:hidden the element before calculating offset
10720                 offset = el.show().css( "visibility", "hidden" ).offset(),
10721
10722                 // width and height of a piece
10723                 width = Math.ceil( el.outerWidth() / cells ),
10724                 height = Math.ceil( el.outerHeight() / rows ),
10725                 pieces = [],
10726
10727                 // loop
10728                 i, j, left, top, mx, my;
10729
10730         // children animate complete:
10731         function childComplete() {
10732                 pieces.push( this );
10733                 if ( pieces.length === rows * cells ) {
10734                         animComplete();
10735                 }
10736         }
10737
10738         // clone the element for each row and cell.
10739         for( i = 0; i < rows ; i++ ) { // ===>
10740                 top = offset.top + i * height;
10741                 my = i - ( rows - 1 ) / 2 ;
10742
10743                 for( j = 0; j < cells ; j++ ) { // |||
10744                         left = offset.left + j * width;
10745                         mx = j - ( cells - 1 ) / 2 ;
10746
10747                         // Create a clone of the now hidden main element that will be absolute positioned
10748                         // within a wrapper div off the -left and -top equal to size of our pieces
10749                         el
10750                                 .clone()
10751                                 .appendTo( "body" )
10752                                 .wrap( "<div></div>" )
10753                                 .css({
10754                                         position: "absolute",
10755                                         visibility: "visible",
10756                                         left: -j * width,
10757                                         top: -i * height
10758                                 })
10759
10760                         // select the wrapper - make it overflow: hidden and absolute positioned based on
10761                         // where the original was located +left and +top equal to the size of pieces
10762                                 .parent()
10763                                 .addClass( "ui-effects-explode" )
10764                                 .css({
10765                                         position: "absolute",
10766                                         overflow: "hidden",
10767                                         width: width,
10768                                         height: height,
10769                                         left: left + ( show ? mx * width : 0 ),
10770                                         top: top + ( show ? my * height : 0 ),
10771                                         opacity: show ? 0 : 1
10772                                 }).animate({
10773                                         left: left + ( show ? 0 : mx * width ),
10774                                         top: top + ( show ? 0 : my * height ),
10775                                         opacity: show ? 1 : 0
10776                                 }, o.duration || 500, o.easing, childComplete );
10777                 }
10778         }
10779
10780         function animComplete() {
10781                 el.css({
10782                         visibility: "visible"
10783                 });
10784                 $( pieces ).remove();
10785                 if ( !show ) {
10786                         el.hide();
10787                 }
10788                 done();
10789         }
10790 };
10791
10792 })(jQuery);
10793
10794 (function( $, undefined ) {
10795
10796 $.effects.effect.fade = function( o, done ) {
10797         var el = $( this ),
10798                 mode = $.effects.setMode( el, o.mode || "toggle" );
10799
10800         el.animate({
10801                 opacity: mode
10802         }, {
10803                 queue: false,
10804                 duration: o.duration,
10805                 easing: o.easing,
10806                 complete: done
10807         });
10808 };
10809
10810 })( jQuery );
10811
10812 (function( $, undefined ) {
10813
10814 $.effects.effect.fold = function( o, done ) {
10815
10816         // Create element
10817         var el = $( this ),
10818                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10819                 mode = $.effects.setMode( el, o.mode || "hide" ),
10820                 show = mode === "show",
10821                 hide = mode === "hide",
10822                 size = o.size || 15,
10823                 percent = /([0-9]+)%/.exec( size ),
10824                 horizFirst = !!o.horizFirst,
10825                 widthFirst = show !== horizFirst,
10826                 ref = widthFirst ? [ "width", "height" ] : [ "height", "width" ],
10827                 duration = o.duration / 2,
10828                 wrapper, distance,
10829                 animation1 = {},
10830                 animation2 = {};
10831
10832         $.effects.save( el, props );
10833         el.show();
10834
10835         // Create Wrapper
10836         wrapper = $.effects.createWrapper( el ).css({
10837                 overflow: "hidden"
10838         });
10839         distance = widthFirst ?
10840                 [ wrapper.width(), wrapper.height() ] :
10841                 [ wrapper.height(), wrapper.width() ];
10842
10843         if ( percent ) {
10844                 size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
10845         }
10846         if ( show ) {
10847                 wrapper.css( horizFirst ? {
10848                         height: 0,
10849                         width: size
10850                 } : {
10851                         height: size,
10852                         width: 0
10853                 });
10854         }
10855
10856         // Animation
10857         animation1[ ref[ 0 ] ] = show ? distance[ 0 ] : size;
10858         animation2[ ref[ 1 ] ] = show ? distance[ 1 ] : 0;
10859
10860         // Animate
10861         wrapper
10862                 .animate( animation1, duration, o.easing )
10863                 .animate( animation2, duration, o.easing, function() {
10864                         if ( hide ) {
10865                                 el.hide();
10866                         }
10867                         $.effects.restore( el, props );
10868                         $.effects.removeWrapper( el );
10869                         done();
10870                 });
10871
10872 };
10873
10874 })(jQuery);
10875
10876 (function( $, undefined ) {
10877
10878 $.effects.effect.highlight = function( o, done ) {
10879         var elem = $( this ),
10880                 props = [ "backgroundImage", "backgroundColor", "opacity" ],
10881                 mode = $.effects.setMode( elem, o.mode || "show" ),
10882                 animation = {
10883                         backgroundColor: elem.css( "backgroundColor" )
10884                 };
10885
10886         if (mode === "hide") {
10887                 animation.opacity = 0;
10888         }
10889
10890         $.effects.save( elem, props );
10891
10892         elem
10893                 .show()
10894                 .css({
10895                         backgroundImage: "none",
10896                         backgroundColor: o.color || "#ffff99"
10897                 })
10898                 .animate( animation, {
10899                         queue: false,
10900                         duration: o.duration,
10901                         easing: o.easing,
10902                         complete: function() {
10903                                 if ( mode === "hide" ) {
10904                                         elem.hide();
10905                                 }
10906                                 $.effects.restore( elem, props );
10907                                 done();
10908                         }
10909                 });
10910 };
10911
10912 })(jQuery);
10913
10914 (function( $, undefined ) {
10915
10916 $.effects.effect.pulsate = function( o, done ) {
10917         var elem = $( this ),
10918                 mode = $.effects.setMode( elem, o.mode || "show" ),
10919                 show = mode === "show",
10920                 hide = mode === "hide",
10921                 showhide = ( show || mode === "hide" ),
10922
10923                 // showing or hiding leaves of the "last" animation
10924                 anims = ( ( o.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
10925                 duration = o.duration / anims,
10926                 animateTo = 0,
10927                 queue = elem.queue(),
10928                 queuelen = queue.length,
10929                 i;
10930
10931         if ( show || !elem.is(":visible")) {
10932                 elem.css( "opacity", 0 ).show();
10933                 animateTo = 1;
10934         }
10935
10936         // anims - 1 opacity "toggles"
10937         for ( i = 1; i < anims; i++ ) {
10938                 elem.animate({
10939                         opacity: animateTo
10940                 }, duration, o.easing );
10941                 animateTo = 1 - animateTo;
10942         }
10943
10944         elem.animate({
10945                 opacity: animateTo
10946         }, duration, o.easing);
10947
10948         elem.queue(function() {
10949                 if ( hide ) {
10950                         elem.hide();
10951                 }
10952                 done();
10953         });
10954
10955         // We just queued up "anims" animations, we need to put them next in the queue
10956         if ( queuelen > 1 ) {
10957                 queue.splice.apply( queue,
10958                         [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
10959         }
10960         elem.dequeue();
10961 };
10962
10963 })(jQuery);
10964
10965 (function( $, undefined ) {
10966
10967 $.effects.effect.puff = function( o, done ) {
10968         var elem = $( this ),
10969                 mode = $.effects.setMode( elem, o.mode || "hide" ),
10970                 hide = mode === "hide",
10971                 percent = parseInt( o.percent, 10 ) || 150,
10972                 factor = percent / 100,
10973                 original = {
10974                         height: elem.height(),
10975                         width: elem.width(),
10976                         outerHeight: elem.outerHeight(),
10977                         outerWidth: elem.outerWidth()
10978                 };
10979
10980         $.extend( o, {
10981                 effect: "scale",
10982                 queue: false,
10983                 fade: true,
10984                 mode: mode,
10985                 complete: done,
10986                 percent: hide ? percent : 100,
10987                 from: hide ?
10988                         original :
10989                         {
10990                                 height: original.height * factor,
10991                                 width: original.width * factor,
10992                                 outerHeight: original.outerHeight * factor,
10993                                 outerWidth: original.outerWidth * factor
10994                         }
10995         });
10996
10997         elem.effect( o );
10998 };
10999
11000 $.effects.effect.scale = function( o, done ) {
11001
11002         // Create element
11003         var el = $( this ),
11004                 options = $.extend( true, {}, o ),
11005                 mode = $.effects.setMode( el, o.mode || "effect" ),
11006                 percent = parseInt( o.percent, 10 ) ||
11007                         ( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ),
11008                 direction = o.direction || "both",
11009                 origin = o.origin,
11010                 original = {
11011                         height: el.height(),
11012                         width: el.width(),
11013                         outerHeight: el.outerHeight(),
11014                         outerWidth: el.outerWidth()
11015                 },
11016                 factor = {
11017                         y: direction !== "horizontal" ? (percent / 100) : 1,
11018                         x: direction !== "vertical" ? (percent / 100) : 1
11019                 };
11020
11021         // We are going to pass this effect to the size effect:
11022         options.effect = "size";
11023         options.queue = false;
11024         options.complete = done;
11025
11026         // Set default origin and restore for show/hide
11027         if ( mode !== "effect" ) {
11028                 options.origin = origin || ["middle","center"];
11029                 options.restore = true;
11030         }
11031
11032         options.from = o.from || ( mode === "show" ? {
11033                 height: 0,
11034                 width: 0,
11035                 outerHeight: 0,
11036                 outerWidth: 0
11037         } : original );
11038         options.to = {
11039                 height: original.height * factor.y,
11040                 width: original.width * factor.x,
11041                 outerHeight: original.outerHeight * factor.y,
11042                 outerWidth: original.outerWidth * factor.x
11043         };
11044
11045         // Fade option to support puff
11046         if ( options.fade ) {
11047                 if ( mode === "show" ) {
11048                         options.from.opacity = 0;
11049                         options.to.opacity = 1;
11050                 }
11051                 if ( mode === "hide" ) {
11052                         options.from.opacity = 1;
11053                         options.to.opacity = 0;
11054                 }
11055         }
11056
11057         // Animate
11058         el.effect( options );
11059
11060 };
11061
11062 $.effects.effect.size = function( o, done ) {
11063
11064         // Create element
11065         var original, baseline, factor,
11066                 el = $( this ),
11067                 props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
11068
11069                 // Always restore
11070                 props1 = [ "position", "top", "bottom", "left", "right", "overflow", "opacity" ],
11071
11072                 // Copy for children
11073                 props2 = [ "width", "height", "overflow" ],
11074                 cProps = [ "fontSize" ],
11075                 vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
11076                 hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
11077
11078                 // Set options
11079                 mode = $.effects.setMode( el, o.mode || "effect" ),
11080                 restore = o.restore || mode !== "effect",
11081                 scale = o.scale || "both",
11082                 origin = o.origin || [ "middle", "center" ],
11083                 position = el.css( "position" ),
11084                 props = restore ? props0 : props1,
11085                 zero = {
11086                         height: 0,
11087                         width: 0,
11088                         outerHeight: 0,
11089                         outerWidth: 0
11090                 };
11091
11092         if ( mode === "show" ) {
11093                 el.show();
11094         }
11095         original = {
11096                 height: el.height(),
11097                 width: el.width(),
11098                 outerHeight: el.outerHeight(),
11099                 outerWidth: el.outerWidth()
11100         };
11101
11102         if ( o.mode === "toggle" && mode === "show" ) {
11103                 el.from = o.to || zero;
11104                 el.to = o.from || original;
11105         } else {
11106                 el.from = o.from || ( mode === "show" ? zero : original );
11107                 el.to = o.to || ( mode === "hide" ? zero : original );
11108         }
11109
11110         // Set scaling factor
11111         factor = {
11112                 from: {
11113                         y: el.from.height / original.height,
11114                         x: el.from.width / original.width
11115                 },
11116                 to: {
11117                         y: el.to.height / original.height,
11118                         x: el.to.width / original.width
11119                 }
11120         };
11121
11122         // Scale the css box
11123         if ( scale === "box" || scale === "both" ) {
11124
11125                 // Vertical props scaling
11126                 if ( factor.from.y !== factor.to.y ) {
11127                         props = props.concat( vProps );
11128                         el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from );
11129                         el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to );
11130                 }
11131
11132                 // Horizontal props scaling
11133                 if ( factor.from.x !== factor.to.x ) {
11134                         props = props.concat( hProps );
11135                         el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from );
11136                         el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to );
11137                 }
11138         }
11139
11140         // Scale the content
11141         if ( scale === "content" || scale === "both" ) {
11142
11143                 // Vertical props scaling
11144                 if ( factor.from.y !== factor.to.y ) {
11145                         props = props.concat( cProps ).concat( props2 );
11146                         el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from );
11147                         el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to );
11148                 }
11149         }
11150
11151         $.effects.save( el, props );
11152         el.show();
11153         $.effects.createWrapper( el );
11154         el.css( "overflow", "hidden" ).css( el.from );
11155
11156         // Adjust
11157         if (origin) { // Calculate baseline shifts
11158                 baseline = $.effects.getBaseline( origin, original );
11159                 el.from.top = ( original.outerHeight - el.outerHeight() ) * baseline.y;
11160                 el.from.left = ( original.outerWidth - el.outerWidth() ) * baseline.x;
11161                 el.to.top = ( original.outerHeight - el.to.outerHeight ) * baseline.y;
11162                 el.to.left = ( original.outerWidth - el.to.outerWidth ) * baseline.x;
11163         }
11164         el.css( el.from ); // set top & left
11165
11166         // Animate
11167         if ( scale === "content" || scale === "both" ) { // Scale the children
11168
11169                 // Add margins/font-size
11170                 vProps = vProps.concat([ "marginTop", "marginBottom" ]).concat(cProps);
11171                 hProps = hProps.concat([ "marginLeft", "marginRight" ]);
11172                 props2 = props0.concat(vProps).concat(hProps);
11173
11174                 el.find( "*[width]" ).each( function(){
11175                         var child = $( this ),
11176                                 c_original = {
11177                                         height: child.height(),
11178                                         width: child.width(),
11179                                         outerHeight: child.outerHeight(),
11180                                         outerWidth: child.outerWidth()
11181                                 };
11182                         if (restore) {
11183                                 $.effects.save(child, props2);
11184                         }
11185
11186                         child.from = {
11187                                 height: c_original.height * factor.from.y,
11188                                 width: c_original.width * factor.from.x,
11189                                 outerHeight: c_original.outerHeight * factor.from.y,
11190                                 outerWidth: c_original.outerWidth * factor.from.x
11191                         };
11192                         child.to = {
11193                                 height: c_original.height * factor.to.y,
11194                                 width: c_original.width * factor.to.x,
11195                                 outerHeight: c_original.height * factor.to.y,
11196                                 outerWidth: c_original.width * factor.to.x
11197                         };
11198
11199                         // Vertical props scaling
11200                         if ( factor.from.y !== factor.to.y ) {
11201                                 child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from );
11202                                 child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to );
11203                         }
11204
11205                         // Horizontal props scaling
11206                         if ( factor.from.x !== factor.to.x ) {
11207                                 child.from = $.effects.setTransition( child, hProps, factor.from.x, child.from );
11208                                 child.to = $.effects.setTransition( child, hProps, factor.to.x, child.to );
11209                         }
11210
11211                         // Animate children
11212                         child.css( child.from );
11213                         child.animate( child.to, o.duration, o.easing, function() {
11214
11215                                 // Restore children
11216                                 if ( restore ) {
11217                                         $.effects.restore( child, props2 );
11218                                 }
11219                         });
11220                 });
11221         }
11222
11223         // Animate
11224         el.animate( el.to, {
11225                 queue: false,
11226                 duration: o.duration,
11227                 easing: o.easing,
11228                 complete: function() {
11229                         if ( el.to.opacity === 0 ) {
11230                                 el.css( "opacity", el.from.opacity );
11231                         }
11232                         if( mode === "hide" ) {
11233                                 el.hide();
11234                         }
11235                         $.effects.restore( el, props );
11236                         if ( !restore ) {
11237
11238                                 // we need to calculate our new positioning based on the scaling
11239                                 if ( position === "static" ) {
11240                                         el.css({
11241                                                 position: "relative",
11242                                                 top: el.to.top,
11243                                                 left: el.to.left
11244                                         });
11245                                 } else {
11246                                         $.each([ "top", "left" ], function( idx, pos ) {
11247                                                 el.css( pos, function( _, str ) {
11248                                                         var val = parseInt( str, 10 ),
11249                                                                 toRef = idx ? el.to.left : el.to.top;
11250
11251                                                         // if original was "auto", recalculate the new value from wrapper
11252                                                         if ( str === "auto" ) {
11253                                                                 return toRef + "px";
11254                                                         }
11255
11256                                                         return val + toRef + "px";
11257                                                 });
11258                                         });
11259                                 }
11260                         }
11261
11262                         $.effects.removeWrapper( el );
11263                         done();
11264                 }
11265         });
11266
11267 };
11268
11269 })(jQuery);
11270
11271 (function( $, undefined ) {
11272
11273 $.effects.effect.shake = function( o, done ) {
11274
11275         var el = $( this ),
11276                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
11277                 mode = $.effects.setMode( el, o.mode || "effect" ),
11278                 direction = o.direction || "left",
11279                 distance = o.distance || 20,
11280                 times = o.times || 3,
11281                 anims = times * 2 + 1,
11282                 speed = Math.round(o.duration/anims),
11283                 ref = (direction === "up" || direction === "down") ? "top" : "left",
11284                 positiveMotion = (direction === "up" || direction === "left"),
11285                 animation = {},
11286                 animation1 = {},
11287                 animation2 = {},
11288                 i,
11289
11290                 // we will need to re-assemble the queue to stack our animations in place
11291                 queue = el.queue(),
11292                 queuelen = queue.length;
11293
11294         $.effects.save( el, props );
11295         el.show();
11296         $.effects.createWrapper( el );
11297
11298         // Animation
11299         animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
11300         animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
11301         animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
11302
11303         // Animate
11304         el.animate( animation, speed, o.easing );
11305
11306         // Shakes
11307         for ( i = 1; i < times; i++ ) {
11308                 el.animate( animation1, speed, o.easing ).animate( animation2, speed, o.easing );
11309         }
11310         el
11311                 .animate( animation1, speed, o.easing )
11312                 .animate( animation, speed / 2, o.easing )
11313                 .queue(function() {
11314                         if ( mode === "hide" ) {
11315                                 el.hide();
11316                         }
11317                         $.effects.restore( el, props );
11318                         $.effects.removeWrapper( el );
11319                         done();
11320                 });
11321
11322         // inject all the animations we just queued to be first in line (after "inprogress")
11323         if ( queuelen > 1) {
11324                 queue.splice.apply( queue,
11325                         [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
11326         }
11327         el.dequeue();
11328
11329 };
11330
11331 })(jQuery);
11332
11333 (function( $, undefined ) {
11334
11335 $.effects.effect.slide = function( o, done ) {
11336
11337         // Create element
11338         var el = $( this ),
11339                 props = [ "position", "top", "bottom", "left", "right", "width", "height" ],
11340                 mode = $.effects.setMode( el, o.mode || "show" ),
11341                 show = mode === "show",
11342                 direction = o.direction || "left",
11343                 ref = (direction === "up" || direction === "down") ? "top" : "left",
11344                 positiveMotion = (direction === "up" || direction === "left"),
11345                 distance,
11346                 animation = {};
11347
11348         // Adjust
11349         $.effects.save( el, props );
11350         el.show();
11351         distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true );
11352
11353         $.effects.createWrapper( el ).css({
11354                 overflow: "hidden"
11355         });
11356
11357         if ( show ) {
11358                 el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance );
11359         }
11360
11361         // Animation
11362         animation[ ref ] = ( show ?
11363                 ( positiveMotion ? "+=" : "-=") :
11364                 ( positiveMotion ? "-=" : "+=")) +
11365                 distance;
11366
11367         // Animate
11368         el.animate( animation, {
11369                 queue: false,
11370                 duration: o.duration,
11371                 easing: o.easing,
11372                 complete: function() {
11373                         if ( mode === "hide" ) {
11374                                 el.hide();
11375                         }
11376                         $.effects.restore( el, props );
11377                         $.effects.removeWrapper( el );
11378                         done();
11379                 }
11380         });
11381 };
11382
11383 })(jQuery);
11384
11385 (function( $, undefined ) {
11386
11387 $.effects.effect.transfer = function( o, done ) {
11388         var elem = $( this ),
11389                 target = $( o.to ),
11390                 targetFixed = target.css( "position" ) === "fixed",
11391                 body = $("body"),
11392                 fixTop = targetFixed ? body.scrollTop() : 0,
11393                 fixLeft = targetFixed ? body.scrollLeft() : 0,
11394                 endPosition = target.offset(),
11395                 animation = {
11396                         top: endPosition.top - fixTop ,
11397                         left: endPosition.left - fixLeft ,
11398                         height: target.innerHeight(),
11399                         width: target.innerWidth()
11400                 },
11401                 startPosition = elem.offset(),
11402                 transfer = $( "<div class='ui-effects-transfer'></div>" )
11403                         .appendTo( document.body )
11404                         .addClass( o.className )
11405                         .css({
11406                                 top: startPosition.top - fixTop ,
11407                                 left: startPosition.left - fixLeft ,
11408                                 height: elem.innerHeight(),
11409                                 width: elem.innerWidth(),
11410                                 position: targetFixed ? "fixed" : "absolute"
11411                         })
11412                         .animate( animation, o.duration, o.easing, function() {
11413                                 transfer.remove();
11414                                 done();
11415                         });
11416 };
11417
11418 })(jQuery);
11419
11420 (function( $, undefined ) {
11421
11422 $.widget( "ui.menu", {
11423         version: "1.10.3",
11424         defaultElement: "<ul>",
11425         delay: 300,
11426         options: {
11427                 icons: {
11428                         submenu: "ui-icon-carat-1-e"
11429                 },
11430                 menus: "ul",
11431                 position: {
11432                         my: "left top",
11433                         at: "right top"
11434                 },
11435                 role: "menu",
11436
11437                 // callbacks
11438                 blur: null,
11439                 focus: null,
11440                 select: null
11441         },
11442
11443         _create: function() {
11444                 this.activeMenu = this.element;
11445                 // flag used to prevent firing of the click handler
11446                 // as the event bubbles up through nested menus
11447                 this.mouseHandled = false;
11448                 this.element
11449                         .uniqueId()
11450                         .addClass( "ui-menu ui-widget ui-widget-content ui-corner-all" )
11451                         .toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
11452                         .attr({
11453                                 role: this.options.role,
11454                                 tabIndex: 0
11455                         })
11456                         // need to catch all clicks on disabled menu
11457                         // not possible through _on
11458                         .bind( "click" + this.eventNamespace, $.proxy(function( event ) {
11459                                 if ( this.options.disabled ) {
11460                                         event.preventDefault();
11461                                 }
11462                         }, this ));
11463
11464                 if ( this.options.disabled ) {
11465                         this.element
11466                                 .addClass( "ui-state-disabled" )
11467                                 .attr( "aria-disabled", "true" );
11468                 }
11469
11470                 this._on({
11471                         // Prevent focus from sticking to links inside menu after clicking
11472                         // them (focus should always stay on UL during navigation).
11473                         "mousedown .ui-menu-item > a": function( event ) {
11474                                 event.preventDefault();
11475                         },
11476                         "click .ui-state-disabled > a": function( event ) {
11477                                 event.preventDefault();
11478                         },
11479                         "click .ui-menu-item:has(a)": function( event ) {
11480                                 var target = $( event.target ).closest( ".ui-menu-item" );
11481                                 if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
11482                                         this.mouseHandled = true;
11483
11484                                         this.select( event );
11485                                         // Open submenu on click
11486                                         if ( target.has( ".ui-menu" ).length ) {
11487                                                 this.expand( event );
11488                                         } else if ( !this.element.is( ":focus" ) ) {
11489                                                 // Redirect focus to the menu
11490                                                 this.element.trigger( "focus", [ true ] );
11491
11492                                                 // If the active item is on the top level, let it stay active.
11493                                                 // Otherwise, blur the active item since it is no longer visible.
11494                                                 if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
11495                                                         clearTimeout( this.timer );
11496                                                 }
11497                                         }
11498                                 }
11499                         },
11500                         "mouseenter .ui-menu-item": function( event ) {
11501                                 var target = $( event.currentTarget );
11502                                 // Remove ui-state-active class from siblings of the newly focused menu item
11503                                 // to avoid a jump caused by adjacent elements both having a class with a border
11504                                 target.siblings().children( ".ui-state-active" ).removeClass( "ui-state-active" );
11505                                 this.focus( event, target );
11506                         },
11507                         mouseleave: "collapseAll",
11508                         "mouseleave .ui-menu": "collapseAll",
11509                         focus: function( event, keepActiveItem ) {
11510                                 // If there's already an active item, keep it active
11511                                 // If not, activate the first item
11512                                 var item = this.active || this.element.children( ".ui-menu-item" ).eq( 0 );
11513
11514                                 if ( !keepActiveItem ) {
11515                                         this.focus( event, item );
11516                                 }
11517                         },
11518                         blur: function( event ) {
11519                                 this._delay(function() {
11520                                         if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
11521                                                 this.collapseAll( event );
11522                                         }
11523                                 });
11524                         },
11525                         keydown: "_keydown"
11526                 });
11527
11528                 this.refresh();
11529
11530                 // Clicks outside of a menu collapse any open menus
11531                 this._on( this.document, {
11532                         click: function( event ) {
11533                                 if ( !$( event.target ).closest( ".ui-menu" ).length ) {
11534                                         this.collapseAll( event );
11535                                 }
11536
11537                                 // Reset the mouseHandled flag
11538                                 this.mouseHandled = false;
11539                         }
11540                 });
11541         },
11542
11543         _destroy: function() {
11544                 // Destroy (sub)menus
11545                 this.element
11546                         .removeAttr( "aria-activedescendant" )
11547                         .find( ".ui-menu" ).addBack()
11548                                 .removeClass( "ui-menu ui-widget ui-widget-content ui-corner-all ui-menu-icons" )
11549                                 .removeAttr( "role" )
11550                                 .removeAttr( "tabIndex" )
11551                                 .removeAttr( "aria-labelledby" )
11552                                 .removeAttr( "aria-expanded" )
11553                                 .removeAttr( "aria-hidden" )
11554                                 .removeAttr( "aria-disabled" )
11555                                 .removeUniqueId()
11556                                 .show();
11557
11558                 // Destroy menu items
11559                 this.element.find( ".ui-menu-item" )
11560                         .removeClass( "ui-menu-item" )
11561                         .removeAttr( "role" )
11562                         .removeAttr( "aria-disabled" )
11563                         .children( "a" )
11564                                 .removeUniqueId()
11565                                 .removeClass( "ui-corner-all ui-state-hover" )
11566                                 .removeAttr( "tabIndex" )
11567                                 .removeAttr( "role" )
11568                                 .removeAttr( "aria-haspopup" )
11569                                 .children().each( function() {
11570                                         var elem = $( this );
11571                                         if ( elem.data( "ui-menu-submenu-carat" ) ) {
11572                                                 elem.remove();
11573                                         }
11574                                 });
11575
11576                 // Destroy menu dividers
11577                 this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
11578         },
11579
11580         _keydown: function( event ) {
11581                 /*jshint maxcomplexity:20*/
11582                 var match, prev, character, skip, regex,
11583                         preventDefault = true;
11584
11585                 function escape( value ) {
11586                         return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
11587                 }
11588
11589                 switch ( event.keyCode ) {
11590                 case $.ui.keyCode.PAGE_UP:
11591                         this.previousPage( event );
11592                         break;
11593                 case $.ui.keyCode.PAGE_DOWN:
11594                         this.nextPage( event );
11595                         break;
11596                 case $.ui.keyCode.HOME:
11597                         this._move( "first", "first", event );
11598                         break;
11599                 case $.ui.keyCode.END:
11600                         this._move( "last", "last", event );
11601                         break;
11602                 case $.ui.keyCode.UP:
11603                         this.previous( event );
11604                         break;
11605                 case $.ui.keyCode.DOWN:
11606                         this.next( event );
11607                         break;
11608                 case $.ui.keyCode.LEFT:
11609                         this.collapse( event );
11610                         break;
11611                 case $.ui.keyCode.RIGHT:
11612                         if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
11613                                 this.expand( event );
11614                         }
11615                         break;
11616                 case $.ui.keyCode.ENTER:
11617                 case $.ui.keyCode.SPACE:
11618                         this._activate( event );
11619                         break;
11620                 case $.ui.keyCode.ESCAPE:
11621                         this.collapse( event );
11622                         break;
11623                 default:
11624                         preventDefault = false;
11625                         prev = this.previousFilter || "";
11626                         character = String.fromCharCode( event.keyCode );
11627                         skip = false;
11628
11629                         clearTimeout( this.filterTimer );
11630
11631                         if ( character === prev ) {
11632                                 skip = true;
11633                         } else {
11634                                 character = prev + character;
11635                         }
11636
11637                         regex = new RegExp( "^" + escape( character ), "i" );
11638                         match = this.activeMenu.children( ".ui-menu-item" ).filter(function() {
11639                                 return regex.test( $( this ).children( "a" ).text() );
11640                         });
11641                         match = skip && match.index( this.active.next() ) !== -1 ?
11642                                 this.active.nextAll( ".ui-menu-item" ) :
11643                                 match;
11644
11645                         // If no matches on the current filter, reset to the last character pressed
11646                         // to move down the menu to the first item that starts with that character
11647                         if ( !match.length ) {
11648                                 character = String.fromCharCode( event.keyCode );
11649                                 regex = new RegExp( "^" + escape( character ), "i" );
11650                                 match = this.activeMenu.children( ".ui-menu-item" ).filter(function() {
11651                                         return regex.test( $( this ).children( "a" ).text() );
11652                                 });
11653                         }
11654
11655                         if ( match.length ) {
11656                                 this.focus( event, match );
11657                                 if ( match.length > 1 ) {
11658                                         this.previousFilter = character;
11659                                         this.filterTimer = this._delay(function() {
11660                                                 delete this.previousFilter;
11661                                         }, 1000 );
11662                                 } else {
11663                                         delete this.previousFilter;
11664                                 }
11665                         } else {
11666                                 delete this.previousFilter;
11667                         }
11668                 }
11669
11670                 if ( preventDefault ) {
11671                         event.preventDefault();
11672                 }
11673         },
11674
11675         _activate: function( event ) {
11676                 if ( !this.active.is( ".ui-state-disabled" ) ) {
11677                         if ( this.active.children( "a[aria-haspopup='true']" ).length ) {
11678                                 this.expand( event );
11679                         } else {
11680                                 this.select( event );
11681                         }
11682                 }
11683         },
11684
11685         refresh: function() {
11686                 var menus,
11687                         icon = this.options.icons.submenu,
11688                         submenus = this.element.find( this.options.menus );
11689
11690                 // Initialize nested menus
11691                 submenus.filter( ":not(.ui-menu)" )
11692                         .addClass( "ui-menu ui-widget ui-widget-content ui-corner-all" )
11693                         .hide()
11694                         .attr({
11695                                 role: this.options.role,
11696                                 "aria-hidden": "true",
11697                                 "aria-expanded": "false"
11698                         })
11699                         .each(function() {
11700                                 var menu = $( this ),
11701                                         item = menu.prev( "a" ),
11702                                         submenuCarat = $( "<span>" )
11703                                                 .addClass( "ui-menu-icon ui-icon " + icon )
11704                                                 .data( "ui-menu-submenu-carat", true );
11705
11706                                 item
11707                                         .attr( "aria-haspopup", "true" )
11708                                         .prepend( submenuCarat );
11709                                 menu.attr( "aria-labelledby", item.attr( "id" ) );
11710                         });
11711
11712                 menus = submenus.add( this.element );
11713
11714                 // Don't refresh list items that are already adapted
11715                 menus.children( ":not(.ui-menu-item):has(a)" )
11716                         .addClass( "ui-menu-item" )
11717                         .attr( "role", "presentation" )
11718                         .children( "a" )
11719                                 .uniqueId()
11720                                 .addClass( "ui-corner-all" )
11721                                 .attr({
11722                                         tabIndex: -1,
11723                                         role: this._itemRole()
11724                                 });
11725
11726                 // Initialize unlinked menu-items containing spaces and/or dashes only as dividers
11727                 menus.children( ":not(.ui-menu-item)" ).each(function() {
11728                         var item = $( this );
11729                         // hyphen, em dash, en dash
11730                         if ( !/[^\-\u2014\u2013\s]/.test( item.text() ) ) {
11731                                 item.addClass( "ui-widget-content ui-menu-divider" );
11732                         }
11733                 });
11734
11735                 // Add aria-disabled attribute to any disabled menu item
11736                 menus.children( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
11737
11738                 // If the active item has been removed, blur the menu
11739                 if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
11740                         this.blur();
11741                 }
11742         },
11743
11744         _itemRole: function() {
11745                 return {
11746                         menu: "menuitem",
11747                         listbox: "option"
11748                 }[ this.options.role ];
11749         },
11750
11751         _setOption: function( key, value ) {
11752                 if ( key === "icons" ) {
11753                         this.element.find( ".ui-menu-icon" )
11754                                 .removeClass( this.options.icons.submenu )
11755                                 .addClass( value.submenu );
11756                 }
11757                 this._super( key, value );
11758         },
11759
11760         focus: function( event, item ) {
11761                 var nested, focused;
11762                 this.blur( event, event && event.type === "focus" );
11763
11764                 this._scrollIntoView( item );
11765
11766                 this.active = item.first();
11767                 focused = this.active.children( "a" ).addClass( "ui-state-focus" );
11768                 // Only update aria-activedescendant if there's a role
11769                 // otherwise we assume focus is managed elsewhere
11770                 if ( this.options.role ) {
11771                         this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
11772                 }
11773
11774                 // Highlight active parent menu item, if any
11775                 this.active
11776                         .parent()
11777                         .closest( ".ui-menu-item" )
11778                         .children( "a:first" )
11779                         .addClass( "ui-state-active" );
11780
11781                 if ( event && event.type === "keydown" ) {
11782                         this._close();
11783                 } else {
11784                         this.timer = this._delay(function() {
11785                                 this._close();
11786                         }, this.delay );
11787                 }
11788
11789                 nested = item.children( ".ui-menu" );
11790                 if ( nested.length && ( /^mouse/.test( event.type ) ) ) {
11791                         this._startOpening(nested);
11792                 }
11793                 this.activeMenu = item.parent();
11794
11795                 this._trigger( "focus", event, { item: item } );
11796         },
11797
11798         _scrollIntoView: function( item ) {
11799                 var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
11800                 if ( this._hasScroll() ) {
11801                         borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
11802                         paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
11803                         offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
11804                         scroll = this.activeMenu.scrollTop();
11805                         elementHeight = this.activeMenu.height();
11806                         itemHeight = item.height();
11807
11808                         if ( offset < 0 ) {
11809                                 this.activeMenu.scrollTop( scroll + offset );
11810                         } else if ( offset + itemHeight > elementHeight ) {
11811                                 this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
11812                         }
11813                 }
11814         },
11815
11816         blur: function( event, fromFocus ) {
11817                 if ( !fromFocus ) {
11818                         clearTimeout( this.timer );
11819                 }
11820
11821                 if ( !this.active ) {
11822                         return;
11823                 }
11824
11825                 this.active.children( "a" ).removeClass( "ui-state-focus" );
11826                 this.active = null;
11827
11828                 this._trigger( "blur", event, { item: this.active } );
11829         },
11830
11831         _startOpening: function( submenu ) {
11832                 clearTimeout( this.timer );
11833
11834                 // Don't open if already open fixes a Firefox bug that caused a .5 pixel
11835                 // shift in the submenu position when mousing over the carat icon
11836                 if ( submenu.attr( "aria-hidden" ) !== "true" ) {
11837                         return;
11838                 }
11839
11840                 this.timer = this._delay(function() {
11841                         this._close();
11842                         this._open( submenu );
11843                 }, this.delay );
11844         },
11845
11846         _open: function( submenu ) {
11847                 var position = $.extend({
11848                         of: this.active
11849                 }, this.options.position );
11850
11851                 clearTimeout( this.timer );
11852                 this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
11853                         .hide()
11854                         .attr( "aria-hidden", "true" );
11855
11856                 submenu
11857                         .show()
11858                         .removeAttr( "aria-hidden" )
11859                         .attr( "aria-expanded", "true" )
11860                         .position( position );
11861         },
11862
11863         collapseAll: function( event, all ) {
11864                 clearTimeout( this.timer );
11865                 this.timer = this._delay(function() {
11866                         // If we were passed an event, look for the submenu that contains the event
11867                         var currentMenu = all ? this.element :
11868                                 $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
11869
11870                         // If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
11871                         if ( !currentMenu.length ) {
11872                                 currentMenu = this.element;
11873                         }
11874
11875                         this._close( currentMenu );
11876
11877                         this.blur( event );
11878                         this.activeMenu = currentMenu;
11879                 }, this.delay );
11880         },
11881
11882         // With no arguments, closes the currently active menu - if nothing is active
11883         // it closes all menus.  If passed an argument, it will search for menus BELOW
11884         _close: function( startMenu ) {
11885                 if ( !startMenu ) {
11886                         startMenu = this.active ? this.active.parent() : this.element;
11887                 }
11888
11889                 startMenu
11890                         .find( ".ui-menu" )
11891                                 .hide()
11892                                 .attr( "aria-hidden", "true" )
11893                                 .attr( "aria-expanded", "false" )
11894                         .end()
11895                         .find( "a.ui-state-active" )
11896                                 .removeClass( "ui-state-active" );
11897         },
11898
11899         collapse: function( event ) {
11900                 var newItem = this.active &&
11901                         this.active.parent().closest( ".ui-menu-item", this.element );
11902                 if ( newItem && newItem.length ) {
11903                         this._close();
11904                         this.focus( event, newItem );
11905                 }
11906         },
11907
11908         expand: function( event ) {
11909                 var newItem = this.active &&
11910                         this.active
11911                                 .children( ".ui-menu " )
11912                                 .children( ".ui-menu-item" )
11913                                 .first();
11914
11915                 if ( newItem && newItem.length ) {
11916                         this._open( newItem.parent() );
11917
11918                         // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
11919                         this._delay(function() {
11920                                 this.focus( event, newItem );
11921                         });
11922                 }
11923         },
11924
11925         next: function( event ) {
11926                 this._move( "next", "first", event );
11927         },
11928
11929         previous: function( event ) {
11930                 this._move( "prev", "last", event );
11931         },
11932
11933         isFirstItem: function() {
11934                 return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
11935         },
11936
11937         isLastItem: function() {
11938                 return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
11939         },
11940
11941         _move: function( direction, filter, event ) {
11942                 var next;
11943                 if ( this.active ) {
11944                         if ( direction === "first" || direction === "last" ) {
11945                                 next = this.active
11946                                         [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
11947                                         .eq( -1 );
11948                         } else {
11949                                 next = this.active
11950                                         [ direction + "All" ]( ".ui-menu-item" )
11951                                         .eq( 0 );
11952                         }
11953                 }
11954                 if ( !next || !next.length || !this.active ) {
11955                         next = this.activeMenu.children( ".ui-menu-item" )[ filter ]();
11956                 }
11957
11958                 this.focus( event, next );
11959         },
11960
11961         nextPage: function( event ) {
11962                 var item, base, height;
11963
11964                 if ( !this.active ) {
11965                         this.next( event );
11966                         return;
11967                 }
11968                 if ( this.isLastItem() ) {
11969                         return;
11970                 }
11971                 if ( this._hasScroll() ) {
11972                         base = this.active.offset().top;
11973                         height = this.element.height();
11974                         this.active.nextAll( ".ui-menu-item" ).each(function() {
11975                                 item = $( this );
11976                                 return item.offset().top - base - height < 0;
11977                         });
11978
11979                         this.focus( event, item );
11980                 } else {
11981                         this.focus( event, this.activeMenu.children( ".ui-menu-item" )
11982                                 [ !this.active ? "first" : "last" ]() );
11983                 }
11984         },
11985
11986         previousPage: function( event ) {
11987                 var item, base, height;
11988                 if ( !this.active ) {
11989                         this.next( event );
11990                         return;
11991                 }
11992                 if ( this.isFirstItem() ) {
11993                         return;
11994                 }
11995                 if ( this._hasScroll() ) {
11996                         base = this.active.offset().top;
11997                         height = this.element.height();
11998                         this.active.prevAll( ".ui-menu-item" ).each(function() {
11999                                 item = $( this );
12000                                 return item.offset().top - base + height > 0;
12001                         });
12002
12003                         this.focus( event, item );
12004                 } else {
12005                         this.focus( event, this.activeMenu.children( ".ui-menu-item" ).first() );
12006                 }
12007         },
12008
12009         _hasScroll: function() {
12010                 return this.element.outerHeight() < this.element.prop( "scrollHeight" );
12011         },
12012
12013         select: function( event ) {
12014                 // TODO: It should never be possible to not have an active item at this
12015                 // point, but the tests don't trigger mouseenter before click.
12016                 this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
12017                 var ui = { item: this.active };
12018                 if ( !this.active.has( ".ui-menu" ).length ) {
12019                         this.collapseAll( event, true );
12020                 }
12021                 this._trigger( "select", event, ui );
12022         }
12023 });
12024
12025 }( jQuery ));
12026
12027 (function( $, undefined ) {
12028
12029 $.ui = $.ui || {};
12030
12031 var cachedScrollbarWidth,
12032         max = Math.max,
12033         abs = Math.abs,
12034         round = Math.round,
12035         rhorizontal = /left|center|right/,
12036         rvertical = /top|center|bottom/,
12037         roffset = /[\+\-]\d+(\.[\d]+)?%?/,
12038         rposition = /^\w+/,
12039         rpercent = /%$/,
12040         _position = $.fn.position;
12041
12042 function getOffsets( offsets, width, height ) {
12043         return [
12044                 parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
12045                 parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
12046         ];
12047 }
12048
12049 function parseCss( element, property ) {
12050         return parseInt( $.css( element, property ), 10 ) || 0;
12051 }
12052
12053 function getDimensions( elem ) {
12054         var raw = elem[0];
12055         if ( raw.nodeType === 9 ) {
12056                 return {
12057                         width: elem.width(),
12058                         height: elem.height(),
12059                         offset: { top: 0, left: 0 }
12060                 };
12061         }
12062         if ( $.isWindow( raw ) ) {
12063                 return {
12064                         width: elem.width(),
12065                         height: elem.height(),
12066                         offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
12067                 };
12068         }
12069         if ( raw.preventDefault ) {
12070                 return {
12071                         width: 0,
12072                         height: 0,
12073                         offset: { top: raw.pageY, left: raw.pageX }
12074                 };
12075         }
12076         return {
12077                 width: elem.outerWidth(),
12078                 height: elem.outerHeight(),
12079                 offset: elem.offset()
12080         };
12081 }
12082
12083 $.position = {
12084         scrollbarWidth: function() {
12085                 if ( cachedScrollbarWidth !== undefined ) {
12086                         return cachedScrollbarWidth;
12087                 }
12088                 var w1, w2,
12089                         div = $( "<div style='display:block;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
12090                         innerDiv = div.children()[0];
12091
12092                 $( "body" ).append( div );
12093                 w1 = innerDiv.offsetWidth;
12094                 div.css( "overflow", "scroll" );
12095
12096                 w2 = innerDiv.offsetWidth;
12097
12098                 if ( w1 === w2 ) {
12099                         w2 = div[0].clientWidth;
12100                 }
12101
12102                 div.remove();
12103
12104                 return (cachedScrollbarWidth = w1 - w2);
12105         },
12106         getScrollInfo: function( within ) {
12107                 var overflowX = within.isWindow ? "" : within.element.css( "overflow-x" ),
12108                         overflowY = within.isWindow ? "" : within.element.css( "overflow-y" ),
12109                         hasOverflowX = overflowX === "scroll" ||
12110                                 ( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
12111                         hasOverflowY = overflowY === "scroll" ||
12112                                 ( overflowY === "auto" && within.height < within.element[0].scrollHeight );
12113                 return {
12114                         width: hasOverflowY ? $.position.scrollbarWidth() : 0,
12115                         height: hasOverflowX ? $.position.scrollbarWidth() : 0
12116                 };
12117         },
12118         getWithinInfo: function( element ) {
12119                 var withinElement = $( element || window ),
12120                         isWindow = $.isWindow( withinElement[0] );
12121                 return {
12122                         element: withinElement,
12123                         isWindow: isWindow,
12124                         offset: withinElement.offset() || { left: 0, top: 0 },
12125                         scrollLeft: withinElement.scrollLeft(),
12126                         scrollTop: withinElement.scrollTop(),
12127                         width: isWindow ? withinElement.width() : withinElement.outerWidth(),
12128                         height: isWindow ? withinElement.height() : withinElement.outerHeight()
12129                 };
12130         }
12131 };
12132
12133 $.fn.position = function( options ) {
12134         if ( !options || !options.of ) {
12135                 return _position.apply( this, arguments );
12136         }
12137
12138         // make a copy, we don't want to modify arguments
12139         options = $.extend( {}, options );
12140
12141         var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
12142                 target = $( options.of ),
12143                 within = $.position.getWithinInfo( options.within ),
12144                 scrollInfo = $.position.getScrollInfo( within ),
12145                 collision = ( options.collision || "flip" ).split( " " ),
12146                 offsets = {};
12147
12148         dimensions = getDimensions( target );
12149         if ( target[0].preventDefault ) {
12150                 // force left top to allow flipping
12151                 options.at = "left top";
12152         }
12153         targetWidth = dimensions.width;
12154         targetHeight = dimensions.height;
12155         targetOffset = dimensions.offset;
12156         // clone to reuse original targetOffset later
12157         basePosition = $.extend( {}, targetOffset );
12158
12159         // force my and at to have valid horizontal and vertical positions
12160         // if a value is missing or invalid, it will be converted to center
12161         $.each( [ "my", "at" ], function() {
12162                 var pos = ( options[ this ] || "" ).split( " " ),
12163                         horizontalOffset,
12164                         verticalOffset;
12165
12166                 if ( pos.length === 1) {
12167                         pos = rhorizontal.test( pos[ 0 ] ) ?
12168                                 pos.concat( [ "center" ] ) :
12169                                 rvertical.test( pos[ 0 ] ) ?
12170                                         [ "center" ].concat( pos ) :
12171                                         [ "center", "center" ];
12172                 }
12173                 pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
12174                 pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
12175
12176                 // calculate offsets
12177                 horizontalOffset = roffset.exec( pos[ 0 ] );
12178                 verticalOffset = roffset.exec( pos[ 1 ] );
12179                 offsets[ this ] = [
12180                         horizontalOffset ? horizontalOffset[ 0 ] : 0,
12181                         verticalOffset ? verticalOffset[ 0 ] : 0
12182                 ];
12183
12184                 // reduce to just the positions without the offsets
12185                 options[ this ] = [
12186                         rposition.exec( pos[ 0 ] )[ 0 ],
12187                         rposition.exec( pos[ 1 ] )[ 0 ]
12188                 ];
12189         });
12190
12191         // normalize collision option
12192         if ( collision.length === 1 ) {
12193                 collision[ 1 ] = collision[ 0 ];
12194         }
12195
12196         if ( options.at[ 0 ] === "right" ) {
12197                 basePosition.left += targetWidth;
12198         } else if ( options.at[ 0 ] === "center" ) {
12199                 basePosition.left += targetWidth / 2;
12200         }
12201
12202         if ( options.at[ 1 ] === "bottom" ) {
12203                 basePosition.top += targetHeight;
12204         } else if ( options.at[ 1 ] === "center" ) {
12205                 basePosition.top += targetHeight / 2;
12206         }
12207
12208         atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
12209         basePosition.left += atOffset[ 0 ];
12210         basePosition.top += atOffset[ 1 ];
12211
12212         return this.each(function() {
12213                 var collisionPosition, using,
12214                         elem = $( this ),
12215                         elemWidth = elem.outerWidth(),
12216                         elemHeight = elem.outerHeight(),
12217                         marginLeft = parseCss( this, "marginLeft" ),
12218                         marginTop = parseCss( this, "marginTop" ),
12219                         collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
12220                         collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
12221                         position = $.extend( {}, basePosition ),
12222                         myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
12223
12224                 if ( options.my[ 0 ] === "right" ) {
12225                         position.left -= elemWidth;
12226                 } else if ( options.my[ 0 ] === "center" ) {
12227                         position.left -= elemWidth / 2;
12228                 }
12229
12230                 if ( options.my[ 1 ] === "bottom" ) {
12231                         position.top -= elemHeight;
12232                 } else if ( options.my[ 1 ] === "center" ) {
12233                         position.top -= elemHeight / 2;
12234                 }
12235
12236                 position.left += myOffset[ 0 ];
12237                 position.top += myOffset[ 1 ];
12238
12239                 // if the browser doesn't support fractions, then round for consistent results
12240                 if ( !$.support.offsetFractions ) {
12241                         position.left = round( position.left );
12242                         position.top = round( position.top );
12243                 }
12244
12245                 collisionPosition = {
12246                         marginLeft: marginLeft,
12247                         marginTop: marginTop
12248                 };
12249
12250                 $.each( [ "left", "top" ], function( i, dir ) {
12251                         if ( $.ui.position[ collision[ i ] ] ) {
12252                                 $.ui.position[ collision[ i ] ][ dir ]( position, {
12253                                         targetWidth: targetWidth,
12254                                         targetHeight: targetHeight,
12255                                         elemWidth: elemWidth,
12256                                         elemHeight: elemHeight,
12257                                         collisionPosition: collisionPosition,
12258                                         collisionWidth: collisionWidth,
12259                                         collisionHeight: collisionHeight,
12260                                         offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
12261                                         my: options.my,
12262                                         at: options.at,
12263                                         within: within,
12264                                         elem : elem
12265                                 });
12266                         }
12267                 });
12268
12269                 if ( options.using ) {
12270                         // adds feedback as second argument to using callback, if present
12271                         using = function( props ) {
12272                                 var left = targetOffset.left - position.left,
12273                                         right = left + targetWidth - elemWidth,
12274                                         top = targetOffset.top - position.top,
12275                                         bottom = top + targetHeight - elemHeight,
12276                                         feedback = {
12277                                                 target: {
12278                                                         element: target,
12279                                                         left: targetOffset.left,
12280                                                         top: targetOffset.top,
12281                                                         width: targetWidth,
12282                                                         height: targetHeight
12283                                                 },
12284                                                 element: {
12285                                                         element: elem,
12286                                                         left: position.left,
12287                                                         top: position.top,
12288                                                         width: elemWidth,
12289                                                         height: elemHeight
12290                                                 },
12291                                                 horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
12292                                                 vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
12293                                         };
12294                                 if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
12295                                         feedback.horizontal = "center";
12296                                 }
12297                                 if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
12298                                         feedback.vertical = "middle";
12299                                 }
12300                                 if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
12301                                         feedback.important = "horizontal";
12302                                 } else {
12303                                         feedback.important = "vertical";
12304                                 }
12305                                 options.using.call( this, props, feedback );
12306                         };
12307                 }
12308
12309                 elem.offset( $.extend( position, { using: using } ) );
12310         });
12311 };
12312
12313 $.ui.position = {
12314         fit: {
12315                 left: function( position, data ) {
12316                         var within = data.within,
12317                                 withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
12318                                 outerWidth = within.width,
12319                                 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
12320                                 overLeft = withinOffset - collisionPosLeft,
12321                                 overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
12322                                 newOverRight;
12323
12324                         // element is wider than within
12325                         if ( data.collisionWidth > outerWidth ) {
12326                                 // element is initially over the left side of within
12327                                 if ( overLeft > 0 && overRight <= 0 ) {
12328                                         newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
12329                                         position.left += overLeft - newOverRight;
12330                                 // element is initially over right side of within
12331                                 } else if ( overRight > 0 && overLeft <= 0 ) {
12332                                         position.left = withinOffset;
12333                                 // element is initially over both left and right sides of within
12334                                 } else {
12335                                         if ( overLeft > overRight ) {
12336                                                 position.left = withinOffset + outerWidth - data.collisionWidth;
12337                                         } else {
12338                                                 position.left = withinOffset;
12339                                         }
12340                                 }
12341                         // too far left -> align with left edge
12342                         } else if ( overLeft > 0 ) {
12343                                 position.left += overLeft;
12344                         // too far right -> align with right edge
12345                         } else if ( overRight > 0 ) {
12346                                 position.left -= overRight;
12347                         // adjust based on position and margin
12348                         } else {
12349                                 position.left = max( position.left - collisionPosLeft, position.left );
12350                         }
12351                 },
12352                 top: function( position, data ) {
12353                         var within = data.within,
12354                                 withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
12355                                 outerHeight = data.within.height,
12356                                 collisionPosTop = position.top - data.collisionPosition.marginTop,
12357                                 overTop = withinOffset - collisionPosTop,
12358                                 overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
12359                                 newOverBottom;
12360
12361                         // element is taller than within
12362                         if ( data.collisionHeight > outerHeight ) {
12363                                 // element is initially over the top of within
12364                                 if ( overTop > 0 && overBottom <= 0 ) {
12365                                         newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
12366                                         position.top += overTop - newOverBottom;
12367                                 // element is initially over bottom of within
12368                                 } else if ( overBottom > 0 && overTop <= 0 ) {
12369                                         position.top = withinOffset;
12370                                 // element is initially over both top and bottom of within
12371                                 } else {
12372                                         if ( overTop > overBottom ) {
12373                                                 position.top = withinOffset + outerHeight - data.collisionHeight;
12374                                         } else {
12375                                                 position.top = withinOffset;
12376                                         }
12377                                 }
12378                         // too far up -> align with top
12379                         } else if ( overTop > 0 ) {
12380                                 position.top += overTop;
12381                         // too far down -> align with bottom edge
12382                         } else if ( overBottom > 0 ) {
12383                                 position.top -= overBottom;
12384                         // adjust based on position and margin
12385                         } else {
12386                                 position.top = max( position.top - collisionPosTop, position.top );
12387                         }
12388                 }
12389         },
12390         flip: {
12391                 left: function( position, data ) {
12392                         var within = data.within,
12393                                 withinOffset = within.offset.left + within.scrollLeft,
12394                                 outerWidth = within.width,
12395                                 offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
12396                                 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
12397                                 overLeft = collisionPosLeft - offsetLeft,
12398                                 overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
12399                                 myOffset = data.my[ 0 ] === "left" ?
12400                                         -data.elemWidth :
12401                                         data.my[ 0 ] === "right" ?
12402                                                 data.elemWidth :
12403                                                 0,
12404                                 atOffset = data.at[ 0 ] === "left" ?
12405                                         data.targetWidth :
12406                                         data.at[ 0 ] === "right" ?
12407                                                 -data.targetWidth :
12408                                                 0,
12409                                 offset = -2 * data.offset[ 0 ],
12410                                 newOverRight,
12411                                 newOverLeft;
12412
12413                         if ( overLeft < 0 ) {
12414                                 newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
12415                                 if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
12416                                         position.left += myOffset + atOffset + offset;
12417                                 }
12418                         }
12419                         else if ( overRight > 0 ) {
12420                                 newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
12421                                 if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
12422                                         position.left += myOffset + atOffset + offset;
12423                                 }
12424                         }
12425                 },
12426                 top: function( position, data ) {
12427                         var within = data.within,
12428                                 withinOffset = within.offset.top + within.scrollTop,
12429                                 outerHeight = within.height,
12430                                 offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
12431                                 collisionPosTop = position.top - data.collisionPosition.marginTop,
12432                                 overTop = collisionPosTop - offsetTop,
12433                                 overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
12434                                 top = data.my[ 1 ] === "top",
12435                                 myOffset = top ?
12436                                         -data.elemHeight :
12437                                         data.my[ 1 ] === "bottom" ?
12438                                                 data.elemHeight :
12439                                                 0,
12440                                 atOffset = data.at[ 1 ] === "top" ?
12441                                         data.targetHeight :
12442                                         data.at[ 1 ] === "bottom" ?
12443                                                 -data.targetHeight :
12444                                                 0,
12445                                 offset = -2 * data.offset[ 1 ],
12446                                 newOverTop,
12447                                 newOverBottom;
12448                         if ( overTop < 0 ) {
12449                                 newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
12450                                 if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
12451                                         position.top += myOffset + atOffset + offset;
12452                                 }
12453                         }
12454                         else if ( overBottom > 0 ) {
12455                                 newOverTop = position.top -  data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
12456                                 if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
12457                                         position.top += myOffset + atOffset + offset;
12458                                 }
12459                         }
12460                 }
12461         },
12462         flipfit: {
12463                 left: function() {
12464                         $.ui.position.flip.left.apply( this, arguments );
12465                         $.ui.position.fit.left.apply( this, arguments );
12466                 },
12467                 top: function() {
12468                         $.ui.position.flip.top.apply( this, arguments );
12469                         $.ui.position.fit.top.apply( this, arguments );
12470                 }
12471         }
12472 };
12473
12474 // fraction support test
12475 (function () {
12476         var testElement, testElementParent, testElementStyle, offsetLeft, i,
12477                 body = document.getElementsByTagName( "body" )[ 0 ],
12478                 div = document.createElement( "div" );
12479
12480         //Create a "fake body" for testing based on method used in jQuery.support
12481         testElement = document.createElement( body ? "div" : "body" );
12482         testElementStyle = {
12483                 visibility: "hidden",
12484                 width: 0,
12485                 height: 0,
12486                 border: 0,
12487                 margin: 0,
12488                 background: "none"
12489         };
12490         if ( body ) {
12491                 $.extend( testElementStyle, {
12492                         position: "absolute",
12493                         left: "-1000px",
12494                         top: "-1000px"
12495                 });
12496         }
12497         for ( i in testElementStyle ) {
12498                 testElement.style[ i ] = testElementStyle[ i ];
12499         }
12500         testElement.appendChild( div );
12501         testElementParent = body || document.documentElement;
12502         testElementParent.insertBefore( testElement, testElementParent.firstChild );
12503
12504         div.style.cssText = "position: absolute; left: 10.7432222px;";
12505
12506         offsetLeft = $( div ).offset().left;
12507         $.support.offsetFractions = offsetLeft > 10 && offsetLeft < 11;
12508
12509         testElement.innerHTML = "";
12510         testElementParent.removeChild( testElement );
12511 })();
12512
12513 }( jQuery ) );
12514
12515 (function( $, undefined ) {
12516
12517 $.widget( "ui.progressbar", {
12518         version: "1.10.3",
12519         options: {
12520                 max: 100,
12521                 value: 0,
12522
12523                 change: null,
12524                 complete: null
12525         },
12526
12527         min: 0,
12528
12529         _create: function() {
12530                 // Constrain initial value
12531                 this.oldValue = this.options.value = this._constrainedValue();
12532
12533                 this.element
12534                         .addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
12535                         .attr({
12536                                 // Only set static values, aria-valuenow and aria-valuemax are
12537                                 // set inside _refreshValue()
12538                                 role: "progressbar",
12539                                 "aria-valuemin": this.min
12540                         });
12541
12542                 this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
12543                         .appendTo( this.element );
12544
12545                 this._refreshValue();
12546         },
12547
12548         _destroy: function() {
12549                 this.element
12550                         .removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
12551                         .removeAttr( "role" )
12552                         .removeAttr( "aria-valuemin" )
12553                         .removeAttr( "aria-valuemax" )
12554                         .removeAttr( "aria-valuenow" );
12555
12556                 this.valueDiv.remove();
12557         },
12558
12559         value: function( newValue ) {
12560                 if ( newValue === undefined ) {
12561                         return this.options.value;
12562                 }
12563
12564                 this.options.value = this._constrainedValue( newValue );
12565                 this._refreshValue();
12566         },
12567
12568         _constrainedValue: function( newValue ) {
12569                 if ( newValue === undefined ) {
12570                         newValue = this.options.value;
12571                 }
12572
12573                 this.indeterminate = newValue === false;
12574
12575                 // sanitize value
12576                 if ( typeof newValue !== "number" ) {
12577                         newValue = 0;
12578                 }
12579
12580                 return this.indeterminate ? false :
12581                         Math.min( this.options.max, Math.max( this.min, newValue ) );
12582         },
12583
12584         _setOptions: function( options ) {
12585                 // Ensure "value" option is set after other values (like max)
12586                 var value = options.value;
12587                 delete options.value;
12588
12589                 this._super( options );
12590
12591                 this.options.value = this._constrainedValue( value );
12592                 this._refreshValue();
12593         },
12594
12595         _setOption: function( key, value ) {
12596                 if ( key === "max" ) {
12597                         // Don't allow a max less than min
12598                         value = Math.max( this.min, value );
12599                 }
12600
12601                 this._super( key, value );
12602         },
12603
12604         _percentage: function() {
12605                 return this.indeterminate ? 100 : 100 * ( this.options.value - this.min ) / ( this.options.max - this.min );
12606         },
12607
12608         _refreshValue: function() {
12609                 var value = this.options.value,
12610                         percentage = this._percentage();
12611
12612                 this.valueDiv
12613                         .toggle( this.indeterminate || value > this.min )
12614                         .toggleClass( "ui-corner-right", value === this.options.max )
12615                         .width( percentage.toFixed(0) + "%" );
12616
12617                 this.element.toggleClass( "ui-progressbar-indeterminate", this.indeterminate );
12618
12619                 if ( this.indeterminate ) {
12620                         this.element.removeAttr( "aria-valuenow" );
12621                         if ( !this.overlayDiv ) {
12622                                 this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv );
12623                         }
12624                 } else {
12625                         this.element.attr({
12626                                 "aria-valuemax": this.options.max,
12627                                 "aria-valuenow": value
12628                         });
12629                         if ( this.overlayDiv ) {
12630                                 this.overlayDiv.remove();
12631                                 this.overlayDiv = null;
12632                         }
12633                 }
12634
12635                 if ( this.oldValue !== value ) {
12636                         this.oldValue = value;
12637                         this._trigger( "change" );
12638                 }
12639                 if ( value === this.options.max ) {
12640                         this._trigger( "complete" );
12641                 }
12642         }
12643 });
12644
12645 })( jQuery );
12646
12647 (function( $, undefined ) {
12648
12649 // number of pages in a slider
12650 // (how many times can you page up/down to go through the whole range)
12651 var numPages = 5;
12652
12653 $.widget( "ui.slider", $.ui.mouse, {
12654         version: "1.10.3",
12655         widgetEventPrefix: "slide",
12656
12657         options: {
12658                 animate: false,
12659                 distance: 0,
12660                 max: 100,
12661                 min: 0,
12662                 orientation: "horizontal",
12663                 range: false,
12664                 step: 1,
12665                 value: 0,
12666                 values: null,
12667
12668                 // callbacks
12669                 change: null,
12670                 slide: null,
12671                 start: null,
12672                 stop: null
12673         },
12674
12675         _create: function() {
12676                 this._keySliding = false;
12677                 this._mouseSliding = false;
12678                 this._animateOff = true;
12679                 this._handleIndex = null;
12680                 this._detectOrientation();
12681                 this._mouseInit();
12682
12683                 this.element
12684                         .addClass( "ui-slider" +
12685                                 " ui-slider-" + this.orientation +
12686                                 " ui-widget" +
12687                                 " ui-widget-content" +
12688                                 " ui-corner-all");
12689
12690                 this._refresh();
12691                 this._setOption( "disabled", this.options.disabled );
12692
12693                 this._animateOff = false;
12694         },
12695
12696         _refresh: function() {
12697                 this._createRange();
12698                 this._createHandles();
12699                 this._setupEvents();
12700                 this._refreshValue();
12701         },
12702
12703         _createHandles: function() {
12704                 var i, handleCount,
12705                         options = this.options,
12706                         existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
12707                         handle = "<a class='ui-slider-handle ui-state-default ui-corner-all' href='#'></a>",
12708                         handles = [];
12709
12710                 handleCount = ( options.values && options.values.length ) || 1;
12711
12712                 if ( existingHandles.length > handleCount ) {
12713                         existingHandles.slice( handleCount ).remove();
12714                         existingHandles = existingHandles.slice( 0, handleCount );
12715                 }
12716
12717                 for ( i = existingHandles.length; i < handleCount; i++ ) {
12718                         handles.push( handle );
12719                 }
12720
12721                 this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
12722
12723                 this.handle = this.handles.eq( 0 );
12724
12725                 this.handles.each(function( i ) {
12726                         $( this ).data( "ui-slider-handle-index", i );
12727                 });
12728         },
12729
12730         _createRange: function() {
12731                 var options = this.options,
12732                         classes = "";
12733
12734                 if ( options.range ) {
12735                         if ( options.range === true ) {
12736                                 if ( !options.values ) {
12737                                         options.values = [ this._valueMin(), this._valueMin() ];
12738                                 } else if ( options.values.length && options.values.length !== 2 ) {
12739                                         options.values = [ options.values[0], options.values[0] ];
12740                                 } else if ( $.isArray( options.values ) ) {
12741                                         options.values = options.values.slice(0);
12742                                 }
12743                         }
12744
12745                         if ( !this.range || !this.range.length ) {
12746                                 this.range = $( "<div></div>" )
12747                                         .appendTo( this.element );
12748
12749                                 classes = "ui-slider-range" +
12750                                 // note: this isn't the most fittingly semantic framework class for this element,
12751                                 // but worked best visually with a variety of themes
12752                                 " ui-widget-header ui-corner-all";
12753                         } else {
12754                                 this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
12755                                         // Handle range switching from true to min/max
12756                                         .css({
12757                                                 "left": "",
12758                                                 "bottom": ""
12759                                         });
12760                         }
12761
12762                         this.range.addClass( classes +
12763                                 ( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
12764                 } else {
12765                         this.range = $([]);
12766                 }
12767         },
12768
12769         _setupEvents: function() {
12770                 var elements = this.handles.add( this.range ).filter( "a" );
12771                 this._off( elements );
12772                 this._on( elements, this._handleEvents );
12773                 this._hoverable( elements );
12774                 this._focusable( elements );
12775         },
12776
12777         _destroy: function() {
12778                 this.handles.remove();
12779                 this.range.remove();
12780
12781                 this.element
12782                         .removeClass( "ui-slider" +
12783                                 " ui-slider-horizontal" +
12784                                 " ui-slider-vertical" +
12785                                 " ui-widget" +
12786                                 " ui-widget-content" +
12787                                 " ui-corner-all" );
12788
12789                 this._mouseDestroy();
12790         },
12791
12792         _mouseCapture: function( event ) {
12793                 var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
12794                         that = this,
12795                         o = this.options;
12796
12797                 if ( o.disabled ) {
12798                         return false;
12799                 }
12800
12801                 this.elementSize = {
12802                         width: this.element.outerWidth(),
12803                         height: this.element.outerHeight()
12804                 };
12805                 this.elementOffset = this.element.offset();
12806
12807                 position = { x: event.pageX, y: event.pageY };
12808                 normValue = this._normValueFromMouse( position );
12809                 distance = this._valueMax() - this._valueMin() + 1;
12810                 this.handles.each(function( i ) {
12811                         var thisDistance = Math.abs( normValue - that.values(i) );
12812                         if (( distance > thisDistance ) ||
12813                                 ( distance === thisDistance &&
12814                                         (i === that._lastChangedValue || that.values(i) === o.min ))) {
12815                                 distance = thisDistance;
12816                                 closestHandle = $( this );
12817                                 index = i;
12818                         }
12819                 });
12820
12821                 allowed = this._start( event, index );
12822                 if ( allowed === false ) {
12823                         return false;
12824                 }
12825                 this._mouseSliding = true;
12826
12827                 this._handleIndex = index;
12828
12829                 closestHandle
12830                         .addClass( "ui-state-active" )
12831                         .focus();
12832
12833                 offset = closestHandle.offset();
12834                 mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );
12835                 this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
12836                         left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
12837                         top: event.pageY - offset.top -
12838                                 ( closestHandle.height() / 2 ) -
12839                                 ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
12840                                 ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
12841                                 ( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
12842                 };
12843
12844                 if ( !this.handles.hasClass( "ui-state-hover" ) ) {
12845                         this._slide( event, index, normValue );
12846                 }
12847                 this._animateOff = true;
12848                 return true;
12849         },
12850
12851         _mouseStart: function() {
12852                 return true;
12853         },
12854
12855         _mouseDrag: function( event ) {
12856                 var position = { x: event.pageX, y: event.pageY },
12857                         normValue = this._normValueFromMouse( position );
12858
12859                 this._slide( event, this._handleIndex, normValue );
12860
12861                 return false;
12862         },
12863
12864         _mouseStop: function( event ) {
12865                 this.handles.removeClass( "ui-state-active" );
12866                 this._mouseSliding = false;
12867
12868                 this._stop( event, this._handleIndex );
12869                 this._change( event, this._handleIndex );
12870
12871                 this._handleIndex = null;
12872                 this._clickOffset = null;
12873                 this._animateOff = false;
12874
12875                 return false;
12876         },
12877
12878         _detectOrientation: function() {
12879                 this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
12880         },
12881
12882         _normValueFromMouse: function( position ) {
12883                 var pixelTotal,
12884                         pixelMouse,
12885                         percentMouse,
12886                         valueTotal,
12887                         valueMouse;
12888
12889                 if ( this.orientation === "horizontal" ) {
12890                         pixelTotal = this.elementSize.width;
12891                         pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
12892                 } else {
12893                         pixelTotal = this.elementSize.height;
12894                         pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
12895                 }
12896
12897                 percentMouse = ( pixelMouse / pixelTotal );
12898                 if ( percentMouse > 1 ) {
12899                         percentMouse = 1;
12900                 }
12901                 if ( percentMouse < 0 ) {
12902                         percentMouse = 0;
12903                 }
12904                 if ( this.orientation === "vertical" ) {
12905                         percentMouse = 1 - percentMouse;
12906                 }
12907
12908                 valueTotal = this._valueMax() - this._valueMin();
12909                 valueMouse = this._valueMin() + percentMouse * valueTotal;
12910
12911                 return this._trimAlignValue( valueMouse );
12912         },
12913
12914         _start: function( event, index ) {
12915                 var uiHash = {
12916                         handle: this.handles[ index ],
12917                         value: this.value()
12918                 };
12919                 if ( this.options.values && this.options.values.length ) {
12920                         uiHash.value = this.values( index );
12921                         uiHash.values = this.values();
12922                 }
12923                 return this._trigger( "start", event, uiHash );
12924         },
12925
12926         _slide: function( event, index, newVal ) {
12927                 var otherVal,
12928                         newValues,
12929                         allowed;
12930
12931                 if ( this.options.values && this.options.values.length ) {
12932                         otherVal = this.values( index ? 0 : 1 );
12933
12934                         if ( ( this.options.values.length === 2 && this.options.range === true ) &&
12935                                         ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
12936                                 ) {
12937                                 newVal = otherVal;
12938                         }
12939
12940                         if ( newVal !== this.values( index ) ) {
12941                                 newValues = this.values();
12942                                 newValues[ index ] = newVal;
12943                                 // A slide can be canceled by returning false from the slide callback
12944                                 allowed = this._trigger( "slide", event, {
12945                                         handle: this.handles[ index ],
12946                                         value: newVal,
12947                                         values: newValues
12948                                 } );
12949                                 otherVal = this.values( index ? 0 : 1 );
12950                                 if ( allowed !== false ) {
12951                                         this.values( index, newVal, true );
12952                                 }
12953                         }
12954                 } else {
12955                         if ( newVal !== this.value() ) {
12956                                 // A slide can be canceled by returning false from the slide callback
12957                                 allowed = this._trigger( "slide", event, {
12958                                         handle: this.handles[ index ],
12959                                         value: newVal
12960                                 } );
12961                                 if ( allowed !== false ) {
12962                                         this.value( newVal );
12963                                 }
12964                         }
12965                 }
12966         },
12967
12968         _stop: function( event, index ) {
12969                 var uiHash = {
12970                         handle: this.handles[ index ],
12971                         value: this.value()
12972                 };
12973                 if ( this.options.values && this.options.values.length ) {
12974                         uiHash.value = this.values( index );
12975                         uiHash.values = this.values();
12976                 }
12977
12978                 this._trigger( "stop", event, uiHash );
12979         },
12980
12981         _change: function( event, index ) {
12982                 if ( !this._keySliding && !this._mouseSliding ) {
12983                         var uiHash = {
12984                                 handle: this.handles[ index ],
12985                                 value: this.value()
12986                         };
12987                         if ( this.options.values && this.options.values.length ) {
12988                                 uiHash.value = this.values( index );
12989                                 uiHash.values = this.values();
12990                         }
12991
12992                         //store the last changed value index for reference when handles overlap
12993                         this._lastChangedValue = index;
12994
12995                         this._trigger( "change", event, uiHash );
12996                 }
12997         },
12998
12999         value: function( newValue ) {
13000                 if ( arguments.length ) {
13001                         this.options.value = this._trimAlignValue( newValue );
13002                         this._refreshValue();
13003                         this._change( null, 0 );
13004                         return;
13005                 }
13006
13007                 return this._value();
13008         },
13009
13010         values: function( index, newValue ) {
13011                 var vals,
13012                         newValues,
13013                         i;
13014
13015                 if ( arguments.length > 1 ) {
13016                         this.options.values[ index ] = this._trimAlignValue( newValue );
13017                         this._refreshValue();
13018                         this._change( null, index );
13019                         return;
13020                 }
13021
13022                 if ( arguments.length ) {
13023                         if ( $.isArray( arguments[ 0 ] ) ) {
13024                                 vals = this.options.values;
13025                                 newValues = arguments[ 0 ];
13026                                 for ( i = 0; i < vals.length; i += 1 ) {
13027                                         vals[ i ] = this._trimAlignValue( newValues[ i ] );
13028                                         this._change( null, i );
13029                                 }
13030                                 this._refreshValue();
13031                         } else {
13032                                 if ( this.options.values && this.options.values.length ) {
13033                                         return this._values( index );
13034                                 } else {
13035                                         return this.value();
13036                                 }
13037                         }
13038                 } else {
13039                         return this._values();
13040                 }
13041         },
13042
13043         _setOption: function( key, value ) {
13044                 var i,
13045                         valsLength = 0;
13046
13047                 if ( key === "range" && this.options.range === true ) {
13048                         if ( value === "min" ) {
13049                                 this.options.value = this._values( 0 );
13050                                 this.options.values = null;
13051                         } else if ( value === "max" ) {
13052                                 this.options.value = this._values( this.options.values.length-1 );
13053                                 this.options.values = null;
13054                         }
13055                 }
13056
13057                 if ( $.isArray( this.options.values ) ) {
13058                         valsLength = this.options.values.length;
13059                 }
13060
13061                 $.Widget.prototype._setOption.apply( this, arguments );
13062
13063                 switch ( key ) {
13064                         case "orientation":
13065                                 this._detectOrientation();
13066                                 this.element
13067                                         .removeClass( "ui-slider-horizontal ui-slider-vertical" )
13068                                         .addClass( "ui-slider-" + this.orientation );
13069                                 this._refreshValue();
13070                                 break;
13071                         case "value":
13072                                 this._animateOff = true;
13073                                 this._refreshValue();
13074                                 this._change( null, 0 );
13075                                 this._animateOff = false;
13076                                 break;
13077                         case "values":
13078                                 this._animateOff = true;
13079                                 this._refreshValue();
13080                                 for ( i = 0; i < valsLength; i += 1 ) {
13081                                         this._change( null, i );
13082                                 }
13083                                 this._animateOff = false;
13084                                 break;
13085                         case "min":
13086                         case "max":
13087                                 this._animateOff = true;
13088                                 this._refreshValue();
13089                                 this._animateOff = false;
13090                                 break;
13091                         case "range":
13092                                 this._animateOff = true;
13093                                 this._refresh();
13094                                 this._animateOff = false;
13095                                 break;
13096                 }
13097         },
13098
13099         //internal value getter
13100         // _value() returns value trimmed by min and max, aligned by step
13101         _value: function() {
13102                 var val = this.options.value;
13103                 val = this._trimAlignValue( val );
13104
13105                 return val;
13106         },
13107
13108         //internal values getter
13109         // _values() returns array of values trimmed by min and max, aligned by step
13110         // _values( index ) returns single value trimmed by min and max, aligned by step
13111         _values: function( index ) {
13112                 var val,
13113                         vals,
13114                         i;
13115
13116                 if ( arguments.length ) {
13117                         val = this.options.values[ index ];
13118                         val = this._trimAlignValue( val );
13119
13120                         return val;
13121                 } else if ( this.options.values && this.options.values.length ) {
13122                         // .slice() creates a copy of the array
13123                         // this copy gets trimmed by min and max and then returned
13124                         vals = this.options.values.slice();
13125                         for ( i = 0; i < vals.length; i+= 1) {
13126                                 vals[ i ] = this._trimAlignValue( vals[ i ] );
13127                         }
13128
13129                         return vals;
13130                 } else {
13131                         return [];
13132                 }
13133         },
13134
13135         // returns the step-aligned value that val is closest to, between (inclusive) min and max
13136         _trimAlignValue: function( val ) {
13137                 if ( val <= this._valueMin() ) {
13138                         return this._valueMin();
13139                 }
13140                 if ( val >= this._valueMax() ) {
13141                         return this._valueMax();
13142                 }
13143                 var step = ( this.options.step > 0 ) ? this.options.step : 1,
13144                         valModStep = (val - this._valueMin()) % step,
13145                         alignValue = val - valModStep;
13146
13147                 if ( Math.abs(valModStep) * 2 >= step ) {
13148                         alignValue += ( valModStep > 0 ) ? step : ( -step );
13149                 }
13150
13151                 // Since JavaScript has problems with large floats, round
13152                 // the final value to 5 digits after the decimal point (see #4124)
13153                 return parseFloat( alignValue.toFixed(5) );
13154         },
13155
13156         _valueMin: function() {
13157                 return this.options.min;
13158         },
13159
13160         _valueMax: function() {
13161                 return this.options.max;
13162         },
13163
13164         _refreshValue: function() {
13165                 var lastValPercent, valPercent, value, valueMin, valueMax,
13166                         oRange = this.options.range,
13167                         o = this.options,
13168                         that = this,
13169                         animate = ( !this._animateOff ) ? o.animate : false,
13170                         _set = {};
13171
13172                 if ( this.options.values && this.options.values.length ) {
13173                         this.handles.each(function( i ) {
13174                                 valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
13175                                 _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
13176                                 $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
13177                                 if ( that.options.range === true ) {
13178                                         if ( that.orientation === "horizontal" ) {
13179                                                 if ( i === 0 ) {
13180                                                         that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
13181                                                 }
13182                                                 if ( i === 1 ) {
13183                                                         that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13184                                                 }
13185                                         } else {
13186                                                 if ( i === 0 ) {
13187                                                         that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
13188                                                 }
13189                                                 if ( i === 1 ) {
13190                                                         that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13191                                                 }
13192                                         }
13193                                 }
13194                                 lastValPercent = valPercent;
13195                         });
13196                 } else {
13197                         value = this.value();
13198                         valueMin = this._valueMin();
13199                         valueMax = this._valueMax();
13200                         valPercent = ( valueMax !== valueMin ) ?
13201                                         ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
13202                                         0;
13203                         _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
13204                         this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
13205
13206                         if ( oRange === "min" && this.orientation === "horizontal" ) {
13207                                 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
13208                         }
13209                         if ( oRange === "max" && this.orientation === "horizontal" ) {
13210                                 this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13211                         }
13212                         if ( oRange === "min" && this.orientation === "vertical" ) {
13213                                 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
13214                         }
13215                         if ( oRange === "max" && this.orientation === "vertical" ) {
13216                                 this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13217                         }
13218                 }
13219         },
13220
13221         _handleEvents: {
13222                 keydown: function( event ) {
13223                         /*jshint maxcomplexity:25*/
13224                         var allowed, curVal, newVal, step,
13225                                 index = $( event.target ).data( "ui-slider-handle-index" );
13226
13227                         switch ( event.keyCode ) {
13228                                 case $.ui.keyCode.HOME:
13229                                 case $.ui.keyCode.END:
13230                                 case $.ui.keyCode.PAGE_UP:
13231                                 case $.ui.keyCode.PAGE_DOWN:
13232                                 case $.ui.keyCode.UP:
13233                                 case $.ui.keyCode.RIGHT:
13234                                 case $.ui.keyCode.DOWN:
13235                                 case $.ui.keyCode.LEFT:
13236                                         event.preventDefault();
13237                                         if ( !this._keySliding ) {
13238                                                 this._keySliding = true;
13239                                                 $( event.target ).addClass( "ui-state-active" );
13240                                                 allowed = this._start( event, index );
13241                                                 if ( allowed === false ) {
13242                                                         return;
13243                                                 }
13244                                         }
13245                                         break;
13246                         }
13247
13248                         step = this.options.step;
13249                         if ( this.options.values && this.options.values.length ) {
13250                                 curVal = newVal = this.values( index );
13251                         } else {
13252                                 curVal = newVal = this.value();
13253                         }
13254
13255                         switch ( event.keyCode ) {
13256                                 case $.ui.keyCode.HOME:
13257                                         newVal = this._valueMin();
13258                                         break;
13259                                 case $.ui.keyCode.END:
13260                                         newVal = this._valueMax();
13261                                         break;
13262                                 case $.ui.keyCode.PAGE_UP:
13263                                         newVal = this._trimAlignValue( curVal + ( (this._valueMax() - this._valueMin()) / numPages ) );
13264                                         break;
13265                                 case $.ui.keyCode.PAGE_DOWN:
13266                                         newVal = this._trimAlignValue( curVal - ( (this._valueMax() - this._valueMin()) / numPages ) );
13267                                         break;
13268                                 case $.ui.keyCode.UP:
13269                                 case $.ui.keyCode.RIGHT:
13270                                         if ( curVal === this._valueMax() ) {
13271                                                 return;
13272                                         }
13273                                         newVal = this._trimAlignValue( curVal + step );
13274                                         break;
13275                                 case $.ui.keyCode.DOWN:
13276                                 case $.ui.keyCode.LEFT:
13277                                         if ( curVal === this._valueMin() ) {
13278                                                 return;
13279                                         }
13280                                         newVal = this._trimAlignValue( curVal - step );
13281                                         break;
13282                         }
13283
13284                         this._slide( event, index, newVal );
13285                 },
13286                 click: function( event ) {
13287                         event.preventDefault();
13288                 },
13289                 keyup: function( event ) {
13290                         var index = $( event.target ).data( "ui-slider-handle-index" );
13291
13292                         if ( this._keySliding ) {
13293                                 this._keySliding = false;
13294                                 this._stop( event, index );
13295                                 this._change( event, index );
13296                                 $( event.target ).removeClass( "ui-state-active" );
13297                         }
13298                 }
13299         }
13300
13301 });
13302
13303 }(jQuery));
13304
13305 (function( $ ) {
13306
13307 function modifier( fn ) {
13308         return function() {
13309                 var previous = this.element.val();
13310                 fn.apply( this, arguments );
13311                 this._refresh();
13312                 if ( previous !== this.element.val() ) {
13313                         this._trigger( "change" );
13314                 }
13315         };
13316 }
13317
13318 $.widget( "ui.spinner", {
13319         version: "1.10.3",
13320         defaultElement: "<input>",
13321         widgetEventPrefix: "spin",
13322         options: {
13323                 culture: null,
13324                 icons: {
13325                         down: "ui-icon-triangle-1-s",
13326                         up: "ui-icon-triangle-1-n"
13327                 },
13328                 incremental: true,
13329                 max: null,
13330                 min: null,
13331                 numberFormat: null,
13332                 page: 10,
13333                 step: 1,
13334
13335                 change: null,
13336                 spin: null,
13337                 start: null,
13338                 stop: null
13339         },
13340
13341         _create: function() {
13342                 // handle string values that need to be parsed
13343                 this._setOption( "max", this.options.max );
13344                 this._setOption( "min", this.options.min );
13345                 this._setOption( "step", this.options.step );
13346
13347                 // format the value, but don't constrain
13348                 this._value( this.element.val(), true );
13349
13350                 this._draw();
13351                 this._on( this._events );
13352                 this._refresh();
13353
13354                 // turning off autocomplete prevents the browser from remembering the
13355                 // value when navigating through history, so we re-enable autocomplete
13356                 // if the page is unloaded before the widget is destroyed. #7790
13357                 this._on( this.window, {
13358                         beforeunload: function() {
13359                                 this.element.removeAttr( "autocomplete" );
13360                         }
13361                 });
13362         },
13363
13364         _getCreateOptions: function() {
13365                 var options = {},
13366                         element = this.element;
13367
13368                 $.each( [ "min", "max", "step" ], function( i, option ) {
13369                         var value = element.attr( option );
13370                         if ( value !== undefined && value.length ) {
13371                                 options[ option ] = value;
13372                         }
13373                 });
13374
13375                 return options;
13376         },
13377
13378         _events: {
13379                 keydown: function( event ) {
13380                         if ( this._start( event ) && this._keydown( event ) ) {
13381                                 event.preventDefault();
13382                         }
13383                 },
13384                 keyup: "_stop",
13385                 focus: function() {
13386                         this.previous = this.element.val();
13387                 },
13388                 blur: function( event ) {
13389                         if ( this.cancelBlur ) {
13390                                 delete this.cancelBlur;
13391                                 return;
13392                         }
13393
13394                         this._stop();
13395                         this._refresh();
13396                         if ( this.previous !== this.element.val() ) {
13397                                 this._trigger( "change", event );
13398                         }
13399                 },
13400                 mousewheel: function( event, delta ) {
13401                         if ( !delta ) {
13402                                 return;
13403                         }
13404                         if ( !this.spinning && !this._start( event ) ) {
13405                                 return false;
13406                         }
13407
13408                         this._spin( (delta > 0 ? 1 : -1) * this.options.step, event );
13409                         clearTimeout( this.mousewheelTimer );
13410                         this.mousewheelTimer = this._delay(function() {
13411                                 if ( this.spinning ) {
13412                                         this._stop( event );
13413                                 }
13414                         }, 100 );
13415                         event.preventDefault();
13416                 },
13417                 "mousedown .ui-spinner-button": function( event ) {
13418                         var previous;
13419
13420                         // We never want the buttons to have focus; whenever the user is
13421                         // interacting with the spinner, the focus should be on the input.
13422                         // If the input is focused then this.previous is properly set from
13423                         // when the input first received focus. If the input is not focused
13424                         // then we need to set this.previous based on the value before spinning.
13425                         previous = this.element[0] === this.document[0].activeElement ?
13426                                 this.previous : this.element.val();
13427                         function checkFocus() {
13428                                 var isActive = this.element[0] === this.document[0].activeElement;
13429                                 if ( !isActive ) {
13430                                         this.element.focus();
13431                                         this.previous = previous;
13432                                         // support: IE
13433                                         // IE sets focus asynchronously, so we need to check if focus
13434                                         // moved off of the input because the user clicked on the button.
13435                                         this._delay(function() {
13436                                                 this.previous = previous;
13437                                         });
13438                                 }
13439                         }
13440
13441                         // ensure focus is on (or stays on) the text field
13442                         event.preventDefault();
13443                         checkFocus.call( this );
13444
13445                         // support: IE
13446                         // IE doesn't prevent moving focus even with event.preventDefault()
13447                         // so we set a flag to know when we should ignore the blur event
13448                         // and check (again) if focus moved off of the input.
13449                         this.cancelBlur = true;
13450                         this._delay(function() {
13451                                 delete this.cancelBlur;
13452                                 checkFocus.call( this );
13453                         });
13454
13455                         if ( this._start( event ) === false ) {
13456                                 return;
13457                         }
13458
13459                         this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
13460                 },
13461                 "mouseup .ui-spinner-button": "_stop",
13462                 "mouseenter .ui-spinner-button": function( event ) {
13463                         // button will add ui-state-active if mouse was down while mouseleave and kept down
13464                         if ( !$( event.currentTarget ).hasClass( "ui-state-active" ) ) {
13465                                 return;
13466                         }
13467
13468                         if ( this._start( event ) === false ) {
13469                                 return false;
13470                         }
13471                         this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
13472                 },
13473                 // TODO: do we really want to consider this a stop?
13474                 // shouldn't we just stop the repeater and wait until mouseup before
13475                 // we trigger the stop event?
13476                 "mouseleave .ui-spinner-button": "_stop"
13477         },
13478
13479         _draw: function() {
13480                 var uiSpinner = this.uiSpinner = this.element
13481                         .addClass( "ui-spinner-input" )
13482                         .attr( "autocomplete", "off" )
13483                         .wrap( this._uiSpinnerHtml() )
13484                         .parent()
13485                                 // add buttons
13486                                 .append( this._buttonHtml() );
13487
13488                 this.element.attr( "role", "spinbutton" );
13489
13490                 // button bindings
13491                 this.buttons = uiSpinner.find( ".ui-spinner-button" )
13492                         .attr( "tabIndex", -1 )
13493                         .button()
13494                         .removeClass( "ui-corner-all" );
13495
13496                 // IE 6 doesn't understand height: 50% for the buttons
13497                 // unless the wrapper has an explicit height
13498                 if ( this.buttons.height() > Math.ceil( uiSpinner.height() * 0.5 ) &&
13499                                 uiSpinner.height() > 0 ) {
13500                         uiSpinner.height( uiSpinner.height() );
13501                 }
13502
13503                 // disable spinner if element was already disabled
13504                 if ( this.options.disabled ) {
13505                         this.disable();
13506                 }
13507         },
13508
13509         _keydown: function( event ) {
13510                 var options = this.options,
13511                         keyCode = $.ui.keyCode;
13512
13513                 switch ( event.keyCode ) {
13514                 case keyCode.UP:
13515                         this._repeat( null, 1, event );
13516                         return true;
13517                 case keyCode.DOWN:
13518                         this._repeat( null, -1, event );
13519                         return true;
13520                 case keyCode.PAGE_UP:
13521                         this._repeat( null, options.page, event );
13522                         return true;
13523                 case keyCode.PAGE_DOWN:
13524                         this._repeat( null, -options.page, event );
13525                         return true;
13526                 }
13527
13528                 return false;
13529         },
13530
13531         _uiSpinnerHtml: function() {
13532                 return "<span class='ui-spinner ui-widget ui-widget-content ui-corner-all'></span>";
13533         },
13534
13535         _buttonHtml: function() {
13536                 return "" +
13537                         "<a class='ui-spinner-button ui-spinner-up ui-corner-tr'>" +
13538                                 "<span class='ui-icon " + this.options.icons.up + "'>&#9650;</span>" +
13539                         "</a>" +
13540                         "<a class='ui-spinner-button ui-spinner-down ui-corner-br'>" +
13541                                 "<span class='ui-icon " + this.options.icons.down + "'>&#9660;</span>" +
13542                         "</a>";
13543         },
13544
13545         _start: function( event ) {
13546                 if ( !this.spinning && this._trigger( "start", event ) === false ) {
13547                         return false;
13548                 }
13549
13550                 if ( !this.counter ) {
13551                         this.counter = 1;
13552                 }
13553                 this.spinning = true;
13554                 return true;
13555         },
13556
13557         _repeat: function( i, steps, event ) {
13558                 i = i || 500;
13559
13560                 clearTimeout( this.timer );
13561                 this.timer = this._delay(function() {
13562                         this._repeat( 40, steps, event );
13563                 }, i );
13564
13565                 this._spin( steps * this.options.step, event );
13566         },
13567
13568         _spin: function( step, event ) {
13569                 var value = this.value() || 0;
13570
13571                 if ( !this.counter ) {
13572                         this.counter = 1;
13573                 }
13574
13575                 value = this._adjustValue( value + step * this._increment( this.counter ) );
13576
13577                 if ( !this.spinning || this._trigger( "spin", event, { value: value } ) !== false) {
13578                         this._value( value );
13579                         this.counter++;
13580                 }
13581         },
13582
13583         _increment: function( i ) {
13584                 var incremental = this.options.incremental;
13585
13586                 if ( incremental ) {
13587                         return $.isFunction( incremental ) ?
13588                                 incremental( i ) :
13589                                 Math.floor( i*i*i/50000 - i*i/500 + 17*i/200 + 1 );
13590                 }
13591
13592                 return 1;
13593         },
13594
13595         _precision: function() {
13596                 var precision = this._precisionOf( this.options.step );
13597                 if ( this.options.min !== null ) {
13598                         precision = Math.max( precision, this._precisionOf( this.options.min ) );
13599                 }
13600                 return precision;
13601         },
13602
13603         _precisionOf: function( num ) {
13604                 var str = num.toString(),
13605                         decimal = str.indexOf( "." );
13606                 return decimal === -1 ? 0 : str.length - decimal - 1;
13607         },
13608
13609         _adjustValue: function( value ) {
13610                 var base, aboveMin,
13611                         options = this.options;
13612
13613                 // make sure we're at a valid step
13614                 // - find out where we are relative to the base (min or 0)
13615                 base = options.min !== null ? options.min : 0;
13616                 aboveMin = value - base;
13617                 // - round to the nearest step
13618                 aboveMin = Math.round(aboveMin / options.step) * options.step;
13619                 // - rounding is based on 0, so adjust back to our base
13620                 value = base + aboveMin;
13621
13622                 // fix precision from bad JS floating point math
13623                 value = parseFloat( value.toFixed( this._precision() ) );
13624
13625                 // clamp the value
13626                 if ( options.max !== null && value > options.max) {
13627                         return options.max;
13628                 }
13629                 if ( options.min !== null && value < options.min ) {
13630                         return options.min;
13631                 }
13632
13633                 return value;
13634         },
13635
13636         _stop: function( event ) {
13637                 if ( !this.spinning ) {
13638                         return;
13639                 }
13640
13641                 clearTimeout( this.timer );
13642                 clearTimeout( this.mousewheelTimer );
13643                 this.counter = 0;
13644                 this.spinning = false;
13645                 this._trigger( "stop", event );
13646         },
13647
13648         _setOption: function( key, value ) {
13649                 if ( key === "culture" || key === "numberFormat" ) {
13650                         var prevValue = this._parse( this.element.val() );
13651                         this.options[ key ] = value;
13652                         this.element.val( this._format( prevValue ) );
13653                         return;
13654                 }
13655
13656                 if ( key === "max" || key === "min" || key === "step" ) {
13657                         if ( typeof value === "string" ) {
13658                                 value = this._parse( value );
13659                         }
13660                 }
13661                 if ( key === "icons" ) {
13662                         this.buttons.first().find( ".ui-icon" )
13663                                 .removeClass( this.options.icons.up )
13664                                 .addClass( value.up );
13665                         this.buttons.last().find( ".ui-icon" )
13666                                 .removeClass( this.options.icons.down )
13667                                 .addClass( value.down );
13668                 }
13669
13670                 this._super( key, value );
13671
13672                 if ( key === "disabled" ) {
13673                         if ( value ) {
13674                                 this.element.prop( "disabled", true );
13675                                 this.buttons.button( "disable" );
13676                         } else {
13677                                 this.element.prop( "disabled", false );
13678                                 this.buttons.button( "enable" );
13679                         }
13680                 }
13681         },
13682
13683         _setOptions: modifier(function( options ) {
13684                 this._super( options );
13685                 this._value( this.element.val() );
13686         }),
13687
13688         _parse: function( val ) {
13689                 if ( typeof val === "string" && val !== "" ) {
13690                         val = window.Globalize && this.options.numberFormat ?
13691                                 Globalize.parseFloat( val, 10, this.options.culture ) : +val;
13692                 }
13693                 return val === "" || isNaN( val ) ? null : val;
13694         },
13695
13696         _format: function( value ) {
13697                 if ( value === "" ) {
13698                         return "";
13699                 }
13700                 return window.Globalize && this.options.numberFormat ?
13701                         Globalize.format( value, this.options.numberFormat, this.options.culture ) :
13702                         value;
13703         },
13704
13705         _refresh: function() {
13706                 this.element.attr({
13707                         "aria-valuemin": this.options.min,
13708                         "aria-valuemax": this.options.max,
13709                         // TODO: what should we do with values that can't be parsed?
13710                         "aria-valuenow": this._parse( this.element.val() )
13711                 });
13712         },
13713
13714         // update the value without triggering change
13715         _value: function( value, allowAny ) {
13716                 var parsed;
13717                 if ( value !== "" ) {
13718                         parsed = this._parse( value );
13719                         if ( parsed !== null ) {
13720                                 if ( !allowAny ) {
13721                                         parsed = this._adjustValue( parsed );
13722                                 }
13723                                 value = this._format( parsed );
13724                         }
13725                 }
13726                 this.element.val( value );
13727                 this._refresh();
13728         },
13729
13730         _destroy: function() {
13731                 this.element
13732                         .removeClass( "ui-spinner-input" )
13733                         .prop( "disabled", false )
13734                         .removeAttr( "autocomplete" )
13735                         .removeAttr( "role" )
13736                         .removeAttr( "aria-valuemin" )
13737                         .removeAttr( "aria-valuemax" )
13738                         .removeAttr( "aria-valuenow" );
13739                 this.uiSpinner.replaceWith( this.element );
13740         },
13741
13742         stepUp: modifier(function( steps ) {
13743                 this._stepUp( steps );
13744         }),
13745         _stepUp: function( steps ) {
13746                 if ( this._start() ) {
13747                         this._spin( (steps || 1) * this.options.step );
13748                         this._stop();
13749                 }
13750         },
13751
13752         stepDown: modifier(function( steps ) {
13753                 this._stepDown( steps );
13754         }),
13755         _stepDown: function( steps ) {
13756                 if ( this._start() ) {
13757                         this._spin( (steps || 1) * -this.options.step );
13758                         this._stop();
13759                 }
13760         },
13761
13762         pageUp: modifier(function( pages ) {
13763                 this._stepUp( (pages || 1) * this.options.page );
13764         }),
13765
13766         pageDown: modifier(function( pages ) {
13767                 this._stepDown( (pages || 1) * this.options.page );
13768         }),
13769
13770         value: function( newVal ) {
13771                 if ( !arguments.length ) {
13772                         return this._parse( this.element.val() );
13773                 }
13774                 modifier( this._value ).call( this, newVal );
13775         },
13776
13777         widget: function() {
13778                 return this.uiSpinner;
13779         }
13780 });
13781
13782 }( jQuery ) );
13783
13784 (function( $, undefined ) {
13785
13786 var tabId = 0,
13787         rhash = /#.*$/;
13788
13789 function getNextTabId() {
13790         return ++tabId;
13791 }
13792
13793 function isLocal( anchor ) {
13794         return anchor.hash.length > 1 &&
13795                 decodeURIComponent( anchor.href.replace( rhash, "" ) ) ===
13796                         decodeURIComponent( location.href.replace( rhash, "" ) );
13797 }
13798
13799 $.widget( "ui.tabs", {
13800         version: "1.10.3",
13801         delay: 300,
13802         options: {
13803                 active: null,
13804                 collapsible: false,
13805                 event: "click",
13806                 heightStyle: "content",
13807                 hide: null,
13808                 show: null,
13809
13810                 // callbacks
13811                 activate: null,
13812                 beforeActivate: null,
13813                 beforeLoad: null,
13814                 load: null
13815         },
13816
13817         _create: function() {
13818                 var that = this,
13819                         options = this.options;
13820
13821                 this.running = false;
13822
13823                 this.element
13824                         .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
13825                         .toggleClass( "ui-tabs-collapsible", options.collapsible )
13826                         // Prevent users from focusing disabled tabs via click
13827                         .delegate( ".ui-tabs-nav > li", "mousedown" + this.eventNamespace, function( event ) {
13828                                 if ( $( this ).is( ".ui-state-disabled" ) ) {
13829                                         event.preventDefault();
13830                                 }
13831                         })
13832                         // support: IE <9
13833                         // Preventing the default action in mousedown doesn't prevent IE
13834                         // from focusing the element, so if the anchor gets focused, blur.
13835                         // We don't have to worry about focusing the previously focused
13836                         // element since clicking on a non-focusable element should focus
13837                         // the body anyway.
13838                         .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
13839                                 if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
13840                                         this.blur();
13841                                 }
13842                         });
13843
13844                 this._processTabs();
13845                 options.active = this._initialActive();
13846
13847                 // Take disabling tabs via class attribute from HTML
13848                 // into account and update option properly.
13849                 if ( $.isArray( options.disabled ) ) {
13850                         options.disabled = $.unique( options.disabled.concat(
13851                                 $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
13852                                         return that.tabs.index( li );
13853                                 })
13854                         ) ).sort();
13855                 }
13856
13857                 // check for length avoids error when initializing empty list
13858                 if ( this.options.active !== false && this.anchors.length ) {
13859                         this.active = this._findActive( options.active );
13860                 } else {
13861                         this.active = $();
13862                 }
13863
13864                 this._refresh();
13865
13866                 if ( this.active.length ) {
13867                         this.load( options.active );
13868                 }
13869         },
13870
13871         _initialActive: function() {
13872                 var active = this.options.active,
13873                         collapsible = this.options.collapsible,
13874                         locationHash = location.hash.substring( 1 );
13875
13876                 if ( active === null ) {
13877                         // check the fragment identifier in the URL
13878                         if ( locationHash ) {
13879                                 this.tabs.each(function( i, tab ) {
13880                                         if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
13881                                                 active = i;
13882                                                 return false;
13883                                         }
13884                                 });
13885                         }
13886
13887                         // check for a tab marked active via a class
13888                         if ( active === null ) {
13889                                 active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
13890                         }
13891
13892                         // no active tab, set to false
13893                         if ( active === null || active === -1 ) {
13894                                 active = this.tabs.length ? 0 : false;
13895                         }
13896                 }
13897
13898                 // handle numbers: negative, out of range
13899                 if ( active !== false ) {
13900                         active = this.tabs.index( this.tabs.eq( active ) );
13901                         if ( active === -1 ) {
13902                                 active = collapsible ? false : 0;
13903                         }
13904                 }
13905
13906                 // don't allow collapsible: false and active: false
13907                 if ( !collapsible && active === false && this.anchors.length ) {
13908                         active = 0;
13909                 }
13910
13911                 return active;
13912         },
13913
13914         _getCreateEventData: function() {
13915                 return {
13916                         tab: this.active,
13917                         panel: !this.active.length ? $() : this._getPanelForTab( this.active )
13918                 };
13919         },
13920
13921         _tabKeydown: function( event ) {
13922                 /*jshint maxcomplexity:15*/
13923                 var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
13924                         selectedIndex = this.tabs.index( focusedTab ),
13925                         goingForward = true;
13926
13927                 if ( this._handlePageNav( event ) ) {
13928                         return;
13929                 }
13930
13931                 switch ( event.keyCode ) {
13932                         case $.ui.keyCode.RIGHT:
13933                         case $.ui.keyCode.DOWN:
13934                                 selectedIndex++;
13935                                 break;
13936                         case $.ui.keyCode.UP:
13937                         case $.ui.keyCode.LEFT:
13938                                 goingForward = false;
13939                                 selectedIndex--;
13940                                 break;
13941                         case $.ui.keyCode.END:
13942                                 selectedIndex = this.anchors.length - 1;
13943                                 break;
13944                         case $.ui.keyCode.HOME:
13945                                 selectedIndex = 0;
13946                                 break;
13947                         case $.ui.keyCode.SPACE:
13948                                 // Activate only, no collapsing
13949                                 event.preventDefault();
13950                                 clearTimeout( this.activating );
13951                                 this._activate( selectedIndex );
13952                                 return;
13953                         case $.ui.keyCode.ENTER:
13954                                 // Toggle (cancel delayed activation, allow collapsing)
13955                                 event.preventDefault();
13956                                 clearTimeout( this.activating );
13957                                 // Determine if we should collapse or activate
13958                                 this._activate( selectedIndex === this.options.active ? false : selectedIndex );
13959                                 return;
13960                         default:
13961                                 return;
13962                 }
13963
13964                 // Focus the appropriate tab, based on which key was pressed
13965                 event.preventDefault();
13966                 clearTimeout( this.activating );
13967                 selectedIndex = this._focusNextTab( selectedIndex, goingForward );
13968
13969                 // Navigating with control key will prevent automatic activation
13970                 if ( !event.ctrlKey ) {
13971                         // Update aria-selected immediately so that AT think the tab is already selected.
13972                         // Otherwise AT may confuse the user by stating that they need to activate the tab,
13973                         // but the tab will already be activated by the time the announcement finishes.
13974                         focusedTab.attr( "aria-selected", "false" );
13975                         this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
13976
13977                         this.activating = this._delay(function() {
13978                                 this.option( "active", selectedIndex );
13979                         }, this.delay );
13980                 }
13981         },
13982
13983         _panelKeydown: function( event ) {
13984                 if ( this._handlePageNav( event ) ) {
13985                         return;
13986                 }
13987
13988                 // Ctrl+up moves focus to the current tab
13989                 if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
13990                         event.preventDefault();
13991                         this.active.focus();
13992                 }
13993         },
13994
13995         // Alt+page up/down moves focus to the previous/next tab (and activates)
13996         _handlePageNav: function( event ) {
13997                 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
13998                         this._activate( this._focusNextTab( this.options.active - 1, false ) );
13999                         return true;
14000                 }
14001                 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
14002                         this._activate( this._focusNextTab( this.options.active + 1, true ) );
14003                         return true;
14004                 }
14005         },
14006
14007         _findNextTab: function( index, goingForward ) {
14008                 var lastTabIndex = this.tabs.length - 1;
14009
14010                 function constrain() {
14011                         if ( index > lastTabIndex ) {
14012                                 index = 0;
14013                         }
14014                         if ( index < 0 ) {
14015                                 index = lastTabIndex;
14016                         }
14017                         return index;
14018                 }
14019
14020                 while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
14021                         index = goingForward ? index + 1 : index - 1;
14022                 }
14023
14024                 return index;
14025         },
14026
14027         _focusNextTab: function( index, goingForward ) {
14028                 index = this._findNextTab( index, goingForward );
14029                 this.tabs.eq( index ).focus();
14030                 return index;
14031         },
14032
14033         _setOption: function( key, value ) {
14034                 if ( key === "active" ) {
14035                         // _activate() will handle invalid values and update this.options
14036                         this._activate( value );
14037                         return;
14038                 }
14039
14040                 if ( key === "disabled" ) {
14041                         // don't use the widget factory's disabled handling
14042                         this._setupDisabled( value );
14043                         return;
14044                 }
14045
14046                 this._super( key, value);
14047
14048                 if ( key === "collapsible" ) {
14049                         this.element.toggleClass( "ui-tabs-collapsible", value );
14050                         // Setting collapsible: false while collapsed; open first panel
14051                         if ( !value && this.options.active === false ) {
14052                                 this._activate( 0 );
14053                         }
14054                 }
14055
14056                 if ( key === "event" ) {
14057                         this._setupEvents( value );
14058                 }
14059
14060                 if ( key === "heightStyle" ) {
14061                         this._setupHeightStyle( value );
14062                 }
14063         },
14064
14065         _tabId: function( tab ) {
14066                 return tab.attr( "aria-controls" ) || "ui-tabs-" + getNextTabId();
14067         },
14068
14069         _sanitizeSelector: function( hash ) {
14070                 return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
14071         },
14072
14073         refresh: function() {
14074                 var options = this.options,
14075                         lis = this.tablist.children( ":has(a[href])" );
14076
14077                 // get disabled tabs from class attribute from HTML
14078                 // this will get converted to a boolean if needed in _refresh()
14079                 options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
14080                         return lis.index( tab );
14081                 });
14082
14083                 this._processTabs();
14084
14085                 // was collapsed or no tabs
14086                 if ( options.active === false || !this.anchors.length ) {
14087                         options.active = false;
14088                         this.active = $();
14089                 // was active, but active tab is gone
14090                 } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
14091                         // all remaining tabs are disabled
14092                         if ( this.tabs.length === options.disabled.length ) {
14093                                 options.active = false;
14094                                 this.active = $();
14095                         // activate previous tab
14096                         } else {
14097                                 this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
14098                         }
14099                 // was active, active tab still exists
14100                 } else {
14101                         // make sure active index is correct
14102                         options.active = this.tabs.index( this.active );
14103                 }
14104
14105                 this._refresh();
14106         },
14107
14108         _refresh: function() {
14109                 this._setupDisabled( this.options.disabled );
14110                 this._setupEvents( this.options.event );
14111                 this._setupHeightStyle( this.options.heightStyle );
14112
14113                 this.tabs.not( this.active ).attr({
14114                         "aria-selected": "false",
14115                         tabIndex: -1
14116                 });
14117                 this.panels.not( this._getPanelForTab( this.active ) )
14118                         .hide()
14119                         .attr({
14120                                 "aria-expanded": "false",
14121                                 "aria-hidden": "true"
14122                         });
14123
14124                 // Make sure one tab is in the tab order
14125                 if ( !this.active.length ) {
14126                         this.tabs.eq( 0 ).attr( "tabIndex", 0 );
14127                 } else {
14128                         this.active
14129                                 .addClass( "ui-tabs-active ui-state-active" )
14130                                 .attr({
14131                                         "aria-selected": "true",
14132                                         tabIndex: 0
14133                                 });
14134                         this._getPanelForTab( this.active )
14135                                 .show()
14136                                 .attr({
14137                                         "aria-expanded": "true",
14138                                         "aria-hidden": "false"
14139                                 });
14140                 }
14141         },
14142
14143         _processTabs: function() {
14144                 var that = this;
14145
14146                 this.tablist = this._getList()
14147                         .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
14148                         .attr( "role", "tablist" );
14149
14150                 this.tabs = this.tablist.find( "> li:has(a[href])" )
14151                         .addClass( "ui-state-default ui-corner-top" )
14152                         .attr({
14153                                 role: "tab",
14154                                 tabIndex: -1
14155                         });
14156
14157                 this.anchors = this.tabs.map(function() {
14158                                 return $( "a", this )[ 0 ];
14159                         })
14160                         .addClass( "ui-tabs-anchor" )
14161                         .attr({
14162                                 role: "presentation",
14163                                 tabIndex: -1
14164                         });
14165
14166                 this.panels = $();
14167
14168                 this.anchors.each(function( i, anchor ) {
14169                         var selector, panel, panelId,
14170                                 anchorId = $( anchor ).uniqueId().attr( "id" ),
14171                                 tab = $( anchor ).closest( "li" ),
14172                                 originalAriaControls = tab.attr( "aria-controls" );
14173
14174                         // inline tab
14175                         if ( isLocal( anchor ) ) {
14176                                 selector = anchor.hash;
14177                                 panel = that.element.find( that._sanitizeSelector( selector ) );
14178                         // remote tab
14179                         } else {
14180                                 panelId = that._tabId( tab );
14181                                 selector = "#" + panelId;
14182                                 panel = that.element.find( selector );
14183                                 if ( !panel.length ) {
14184                                         panel = that._createPanel( panelId );
14185                                         panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
14186                                 }
14187                                 panel.attr( "aria-live", "polite" );
14188                         }
14189
14190                         if ( panel.length) {
14191                                 that.panels = that.panels.add( panel );
14192                         }
14193                         if ( originalAriaControls ) {
14194                                 tab.data( "ui-tabs-aria-controls", originalAriaControls );
14195                         }
14196                         tab.attr({
14197                                 "aria-controls": selector.substring( 1 ),
14198                                 "aria-labelledby": anchorId
14199                         });
14200                         panel.attr( "aria-labelledby", anchorId );
14201                 });
14202
14203                 this.panels
14204                         .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
14205                         .attr( "role", "tabpanel" );
14206         },
14207
14208         // allow overriding how to find the list for rare usage scenarios (#7715)
14209         _getList: function() {
14210                 return this.element.find( "ol,ul" ).eq( 0 );
14211         },
14212
14213         _createPanel: function( id ) {
14214                 return $( "<div>" )
14215                         .attr( "id", id )
14216                         .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
14217                         .data( "ui-tabs-destroy", true );
14218         },
14219
14220         _setupDisabled: function( disabled ) {
14221                 if ( $.isArray( disabled ) ) {
14222                         if ( !disabled.length ) {
14223                                 disabled = false;
14224                         } else if ( disabled.length === this.anchors.length ) {
14225                                 disabled = true;
14226                         }
14227                 }
14228
14229                 // disable tabs
14230                 for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
14231                         if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
14232                                 $( li )
14233                                         .addClass( "ui-state-disabled" )
14234                                         .attr( "aria-disabled", "true" );
14235                         } else {
14236                                 $( li )
14237                                         .removeClass( "ui-state-disabled" )
14238                                         .removeAttr( "aria-disabled" );
14239                         }
14240                 }
14241
14242                 this.options.disabled = disabled;
14243         },
14244
14245         _setupEvents: function( event ) {
14246                 var events = {
14247                         click: function( event ) {
14248                                 event.preventDefault();
14249                         }
14250                 };
14251                 if ( event ) {
14252                         $.each( event.split(" "), function( index, eventName ) {
14253                                 events[ eventName ] = "_eventHandler";
14254                         });
14255                 }
14256
14257                 this._off( this.anchors.add( this.tabs ).add( this.panels ) );
14258                 this._on( this.anchors, events );
14259                 this._on( this.tabs, { keydown: "_tabKeydown" } );
14260                 this._on( this.panels, { keydown: "_panelKeydown" } );
14261
14262                 this._focusable( this.tabs );
14263                 this._hoverable( this.tabs );
14264         },
14265
14266         _setupHeightStyle: function( heightStyle ) {
14267                 var maxHeight,
14268                         parent = this.element.parent();
14269
14270                 if ( heightStyle === "fill" ) {
14271                         maxHeight = parent.height();
14272                         maxHeight -= this.element.outerHeight() - this.element.height();
14273
14274                         this.element.siblings( ":visible" ).each(function() {
14275                                 var elem = $( this ),
14276                                         position = elem.css( "position" );
14277
14278                                 if ( position === "absolute" || position === "fixed" ) {
14279                                         return;
14280                                 }
14281                                 maxHeight -= elem.outerHeight( true );
14282                         });
14283
14284                         this.element.children().not( this.panels ).each(function() {
14285                                 maxHeight -= $( this ).outerHeight( true );
14286                         });
14287
14288                         this.panels.each(function() {
14289                                 $( this ).height( Math.max( 0, maxHeight -
14290                                         $( this ).innerHeight() + $( this ).height() ) );
14291                         })
14292                         .css( "overflow", "auto" );
14293                 } else if ( heightStyle === "auto" ) {
14294                         maxHeight = 0;
14295                         this.panels.each(function() {
14296                                 maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
14297                         }).height( maxHeight );
14298                 }
14299         },
14300
14301         _eventHandler: function( event ) {
14302                 var options = this.options,
14303                         active = this.active,
14304                         anchor = $( event.currentTarget ),
14305                         tab = anchor.closest( "li" ),
14306                         clickedIsActive = tab[ 0 ] === active[ 0 ],
14307                         collapsing = clickedIsActive && options.collapsible,
14308                         toShow = collapsing ? $() : this._getPanelForTab( tab ),
14309                         toHide = !active.length ? $() : this._getPanelForTab( active ),
14310                         eventData = {
14311                                 oldTab: active,
14312                                 oldPanel: toHide,
14313                                 newTab: collapsing ? $() : tab,
14314                                 newPanel: toShow
14315                         };
14316
14317                 event.preventDefault();
14318
14319                 if ( tab.hasClass( "ui-state-disabled" ) ||
14320                                 // tab is already loading
14321                                 tab.hasClass( "ui-tabs-loading" ) ||
14322                                 // can't switch durning an animation
14323                                 this.running ||
14324                                 // click on active header, but not collapsible
14325                                 ( clickedIsActive && !options.collapsible ) ||
14326                                 // allow canceling activation
14327                                 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
14328                         return;
14329                 }
14330
14331                 options.active = collapsing ? false : this.tabs.index( tab );
14332
14333                 this.active = clickedIsActive ? $() : tab;
14334                 if ( this.xhr ) {
14335                         this.xhr.abort();
14336                 }
14337
14338                 if ( !toHide.length && !toShow.length ) {
14339                         $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
14340                 }
14341
14342                 if ( toShow.length ) {
14343                         this.load( this.tabs.index( tab ), event );
14344                 }
14345                 this._toggle( event, eventData );
14346         },
14347
14348         // handles show/hide for selecting tabs
14349         _toggle: function( event, eventData ) {
14350                 var that = this,
14351                         toShow = eventData.newPanel,
14352                         toHide = eventData.oldPanel;
14353
14354                 this.running = true;
14355
14356                 function complete() {
14357                         that.running = false;
14358                         that._trigger( "activate", event, eventData );
14359                 }
14360
14361                 function show() {
14362                         eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
14363
14364                         if ( toShow.length && that.options.show ) {
14365                                 that._show( toShow, that.options.show, complete );
14366                         } else {
14367                                 toShow.show();
14368                                 complete();
14369                         }
14370                 }
14371
14372                 // start out by hiding, then showing, then completing
14373                 if ( toHide.length && this.options.hide ) {
14374                         this._hide( toHide, this.options.hide, function() {
14375                                 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
14376                                 show();
14377                         });
14378                 } else {
14379                         eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
14380                         toHide.hide();
14381                         show();
14382                 }
14383
14384                 toHide.attr({
14385                         "aria-expanded": "false",
14386                         "aria-hidden": "true"
14387                 });
14388                 eventData.oldTab.attr( "aria-selected", "false" );
14389                 // If we're switching tabs, remove the old tab from the tab order.
14390                 // If we're opening from collapsed state, remove the previous tab from the tab order.
14391                 // If we're collapsing, then keep the collapsing tab in the tab order.
14392                 if ( toShow.length && toHide.length ) {
14393                         eventData.oldTab.attr( "tabIndex", -1 );
14394                 } else if ( toShow.length ) {
14395                         this.tabs.filter(function() {
14396                                 return $( this ).attr( "tabIndex" ) === 0;
14397                         })
14398                         .attr( "tabIndex", -1 );
14399                 }
14400
14401                 toShow.attr({
14402                         "aria-expanded": "true",
14403                         "aria-hidden": "false"
14404                 });
14405                 eventData.newTab.attr({
14406                         "aria-selected": "true",
14407                         tabIndex: 0
14408                 });
14409         },
14410
14411         _activate: function( index ) {
14412                 var anchor,
14413                         active = this._findActive( index );
14414
14415                 // trying to activate the already active panel
14416                 if ( active[ 0 ] === this.active[ 0 ] ) {
14417                         return;
14418                 }
14419
14420                 // trying to collapse, simulate a click on the current active header
14421                 if ( !active.length ) {
14422                         active = this.active;
14423                 }
14424
14425                 anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
14426                 this._eventHandler({
14427                         target: anchor,
14428                         currentTarget: anchor,
14429                         preventDefault: $.noop
14430                 });
14431         },
14432
14433         _findActive: function( index ) {
14434                 return index === false ? $() : this.tabs.eq( index );
14435         },
14436
14437         _getIndex: function( index ) {
14438                 // meta-function to give users option to provide a href string instead of a numerical index.
14439                 if ( typeof index === "string" ) {
14440                         index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
14441                 }
14442
14443                 return index;
14444         },
14445
14446         _destroy: function() {
14447                 if ( this.xhr ) {
14448                         this.xhr.abort();
14449                 }
14450
14451                 this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
14452
14453                 this.tablist
14454                         .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
14455                         .removeAttr( "role" );
14456
14457                 this.anchors
14458                         .removeClass( "ui-tabs-anchor" )
14459                         .removeAttr( "role" )
14460                         .removeAttr( "tabIndex" )
14461                         .removeUniqueId();
14462
14463                 this.tabs.add( this.panels ).each(function() {
14464                         if ( $.data( this, "ui-tabs-destroy" ) ) {
14465                                 $( this ).remove();
14466                         } else {
14467                                 $( this )
14468                                         .removeClass( "ui-state-default ui-state-active ui-state-disabled " +
14469                                                 "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
14470                                         .removeAttr( "tabIndex" )
14471                                         .removeAttr( "aria-live" )
14472                                         .removeAttr( "aria-busy" )
14473                                         .removeAttr( "aria-selected" )
14474                                         .removeAttr( "aria-labelledby" )
14475                                         .removeAttr( "aria-hidden" )
14476                                         .removeAttr( "aria-expanded" )
14477                                         .removeAttr( "role" );
14478                         }
14479                 });
14480
14481                 this.tabs.each(function() {
14482                         var li = $( this ),
14483                                 prev = li.data( "ui-tabs-aria-controls" );
14484                         if ( prev ) {
14485                                 li
14486                                         .attr( "aria-controls", prev )
14487                                         .removeData( "ui-tabs-aria-controls" );
14488                         } else {
14489                                 li.removeAttr( "aria-controls" );
14490                         }
14491                 });
14492
14493                 this.panels.show();
14494
14495                 if ( this.options.heightStyle !== "content" ) {
14496                         this.panels.css( "height", "" );
14497                 }
14498         },
14499
14500         enable: function( index ) {
14501                 var disabled = this.options.disabled;
14502                 if ( disabled === false ) {
14503                         return;
14504                 }
14505
14506                 if ( index === undefined ) {
14507                         disabled = false;
14508                 } else {
14509                         index = this._getIndex( index );
14510                         if ( $.isArray( disabled ) ) {
14511                                 disabled = $.map( disabled, function( num ) {
14512                                         return num !== index ? num : null;
14513                                 });
14514                         } else {
14515                                 disabled = $.map( this.tabs, function( li, num ) {
14516                                         return num !== index ? num : null;
14517                                 });
14518                         }
14519                 }
14520                 this._setupDisabled( disabled );
14521         },
14522
14523         disable: function( index ) {
14524                 var disabled = this.options.disabled;
14525                 if ( disabled === true ) {
14526                         return;
14527                 }
14528
14529                 if ( index === undefined ) {
14530                         disabled = true;
14531                 } else {
14532                         index = this._getIndex( index );
14533                         if ( $.inArray( index, disabled ) !== -1 ) {
14534                                 return;
14535                         }
14536                         if ( $.isArray( disabled ) ) {
14537                                 disabled = $.merge( [ index ], disabled ).sort();
14538                         } else {
14539                                 disabled = [ index ];
14540                         }
14541                 }
14542                 this._setupDisabled( disabled );
14543         },
14544
14545         load: function( index, event ) {
14546                 index = this._getIndex( index );
14547                 var that = this,
14548                         tab = this.tabs.eq( index ),
14549                         anchor = tab.find( ".ui-tabs-anchor" ),
14550                         panel = this._getPanelForTab( tab ),
14551                         eventData = {
14552                                 tab: tab,
14553                                 panel: panel
14554                         };
14555
14556                 // not remote
14557                 if ( isLocal( anchor[ 0 ] ) ) {
14558                         return;
14559                 }
14560
14561                 this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
14562
14563                 // support: jQuery <1.8
14564                 // jQuery <1.8 returns false if the request is canceled in beforeSend,
14565                 // but as of 1.8, $.ajax() always returns a jqXHR object.
14566                 if ( this.xhr && this.xhr.statusText !== "canceled" ) {
14567                         tab.addClass( "ui-tabs-loading" );
14568                         panel.attr( "aria-busy", "true" );
14569
14570                         this.xhr
14571                                 .success(function( response ) {
14572                                         // support: jQuery <1.8
14573                                         // http://bugs.jquery.com/ticket/11778
14574                                         setTimeout(function() {
14575                                                 panel.html( response );
14576                                                 that._trigger( "load", event, eventData );
14577                                         }, 1 );
14578                                 })
14579                                 .complete(function( jqXHR, status ) {
14580                                         // support: jQuery <1.8
14581                                         // http://bugs.jquery.com/ticket/11778
14582                                         setTimeout(function() {
14583                                                 if ( status === "abort" ) {
14584                                                         that.panels.stop( false, true );
14585                                                 }
14586
14587                                                 tab.removeClass( "ui-tabs-loading" );
14588                                                 panel.removeAttr( "aria-busy" );
14589
14590                                                 if ( jqXHR === that.xhr ) {
14591                                                         delete that.xhr;
14592                                                 }
14593                                         }, 1 );
14594                                 });
14595                 }
14596         },
14597
14598         _ajaxSettings: function( anchor, event, eventData ) {
14599                 var that = this;
14600                 return {
14601                         url: anchor.attr( "href" ),
14602                         beforeSend: function( jqXHR, settings ) {
14603                                 return that._trigger( "beforeLoad", event,
14604                                         $.extend( { jqXHR : jqXHR, ajaxSettings: settings }, eventData ) );
14605                         }
14606                 };
14607         },
14608
14609         _getPanelForTab: function( tab ) {
14610                 var id = $( tab ).attr( "aria-controls" );
14611                 return this.element.find( this._sanitizeSelector( "#" + id ) );
14612         }
14613 });
14614
14615 })( jQuery );
14616
14617 (function( $ ) {
14618
14619 var increments = 0;
14620
14621 function addDescribedBy( elem, id ) {
14622         var describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ );
14623         describedby.push( id );
14624         elem
14625                 .data( "ui-tooltip-id", id )
14626                 .attr( "aria-describedby", $.trim( describedby.join( " " ) ) );
14627 }
14628
14629 function removeDescribedBy( elem ) {
14630         var id = elem.data( "ui-tooltip-id" ),
14631                 describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ ),
14632                 index = $.inArray( id, describedby );
14633         if ( index !== -1 ) {
14634                 describedby.splice( index, 1 );
14635         }
14636
14637         elem.removeData( "ui-tooltip-id" );
14638         describedby = $.trim( describedby.join( " " ) );
14639         if ( describedby ) {
14640                 elem.attr( "aria-describedby", describedby );
14641         } else {
14642                 elem.removeAttr( "aria-describedby" );
14643         }
14644 }
14645
14646 $.widget( "ui.tooltip", {
14647         version: "1.10.3",
14648         options: {
14649                 content: function() {
14650                         // support: IE<9, Opera in jQuery <1.7
14651                         // .text() can't accept undefined, so coerce to a string
14652                         var title = $( this ).attr( "title" ) || "";
14653                         // Escape title, since we're going from an attribute to raw HTML
14654                         return $( "<a>" ).text( title ).html();
14655                 },
14656                 hide: true,
14657                 // Disabled elements have inconsistent behavior across browsers (#8661)
14658                 items: "[title]:not([disabled])",
14659                 position: {
14660                         my: "left top+15",
14661                         at: "left bottom",
14662                         collision: "flipfit flip"
14663                 },
14664                 show: true,
14665                 tooltipClass: null,
14666                 track: false,
14667
14668                 // callbacks
14669                 close: null,
14670                 open: null
14671         },
14672
14673         _create: function() {
14674                 this._on({
14675                         mouseover: "open",
14676                         focusin: "open"
14677                 });
14678
14679                 // IDs of generated tooltips, needed for destroy
14680                 this.tooltips = {};
14681                 // IDs of parent tooltips where we removed the title attribute
14682                 this.parents = {};
14683
14684                 if ( this.options.disabled ) {
14685                         this._disable();
14686                 }
14687         },
14688
14689         _setOption: function( key, value ) {
14690                 var that = this;
14691
14692                 if ( key === "disabled" ) {
14693                         this[ value ? "_disable" : "_enable" ]();
14694                         this.options[ key ] = value;
14695                         // disable element style changes
14696                         return;
14697                 }
14698
14699                 this._super( key, value );
14700
14701                 if ( key === "content" ) {
14702                         $.each( this.tooltips, function( id, element ) {
14703                                 that._updateContent( element );
14704                         });
14705                 }
14706         },
14707
14708         _disable: function() {
14709                 var that = this;
14710
14711                 // close open tooltips
14712                 $.each( this.tooltips, function( id, element ) {
14713                         var event = $.Event( "blur" );
14714                         event.target = event.currentTarget = element[0];
14715                         that.close( event, true );
14716                 });
14717
14718                 // remove title attributes to prevent native tooltips
14719                 this.element.find( this.options.items ).addBack().each(function() {
14720                         var element = $( this );
14721                         if ( element.is( "[title]" ) ) {
14722                                 element
14723                                         .data( "ui-tooltip-title", element.attr( "title" ) )
14724                                         .attr( "title", "" );
14725                         }
14726                 });
14727         },
14728
14729         _enable: function() {
14730                 // restore title attributes
14731                 this.element.find( this.options.items ).addBack().each(function() {
14732                         var element = $( this );
14733                         if ( element.data( "ui-tooltip-title" ) ) {
14734                                 element.attr( "title", element.data( "ui-tooltip-title" ) );
14735                         }
14736                 });
14737         },
14738
14739         open: function( event ) {
14740                 var that = this,
14741                         target = $( event ? event.target : this.element )
14742                                 // we need closest here due to mouseover bubbling,
14743                                 // but always pointing at the same event target
14744                                 .closest( this.options.items );
14745
14746                 // No element to show a tooltip for or the tooltip is already open
14747                 if ( !target.length || target.data( "ui-tooltip-id" ) ) {
14748                         return;
14749                 }
14750
14751                 if ( target.attr( "title" ) ) {
14752                         target.data( "ui-tooltip-title", target.attr( "title" ) );
14753                 }
14754
14755                 target.data( "ui-tooltip-open", true );
14756
14757                 // kill parent tooltips, custom or native, for hover
14758                 if ( event && event.type === "mouseover" ) {
14759                         target.parents().each(function() {
14760                                 var parent = $( this ),
14761                                         blurEvent;
14762                                 if ( parent.data( "ui-tooltip-open" ) ) {
14763                                         blurEvent = $.Event( "blur" );
14764                                         blurEvent.target = blurEvent.currentTarget = this;
14765                                         that.close( blurEvent, true );
14766                                 }
14767                                 if ( parent.attr( "title" ) ) {
14768                                         parent.uniqueId();
14769                                         that.parents[ this.id ] = {
14770                                                 element: this,
14771                                                 title: parent.attr( "title" )
14772                                         };
14773                                         parent.attr( "title", "" );
14774                                 }
14775                         });
14776                 }
14777
14778                 this._updateContent( target, event );
14779         },
14780
14781         _updateContent: function( target, event ) {
14782                 var content,
14783                         contentOption = this.options.content,
14784                         that = this,
14785                         eventType = event ? event.type : null;
14786
14787                 if ( typeof contentOption === "string" ) {
14788                         return this._open( event, target, contentOption );
14789                 }
14790
14791                 content = contentOption.call( target[0], function( response ) {
14792                         // ignore async response if tooltip was closed already
14793                         if ( !target.data( "ui-tooltip-open" ) ) {
14794                                 return;
14795                         }
14796                         // IE may instantly serve a cached response for ajax requests
14797                         // delay this call to _open so the other call to _open runs first
14798                         that._delay(function() {
14799                                 // jQuery creates a special event for focusin when it doesn't
14800                                 // exist natively. To improve performance, the native event
14801                                 // object is reused and the type is changed. Therefore, we can't
14802                                 // rely on the type being correct after the event finished
14803                                 // bubbling, so we set it back to the previous value. (#8740)
14804                                 if ( event ) {
14805                                         event.type = eventType;
14806                                 }
14807                                 this._open( event, target, response );
14808                         });
14809                 });
14810                 if ( content ) {
14811                         this._open( event, target, content );
14812                 }
14813         },
14814
14815         _open: function( event, target, content ) {
14816                 var tooltip, events, delayedShow,
14817                         positionOption = $.extend( {}, this.options.position );
14818
14819                 if ( !content ) {
14820                         return;
14821                 }
14822
14823                 // Content can be updated multiple times. If the tooltip already
14824                 // exists, then just update the content and bail.
14825                 tooltip = this._find( target );
14826                 if ( tooltip.length ) {
14827                         tooltip.find( ".ui-tooltip-content" ).html( content );
14828                         return;
14829                 }
14830
14831                 // if we have a title, clear it to prevent the native tooltip
14832                 // we have to check first to avoid defining a title if none exists
14833                 // (we don't want to cause an element to start matching [title])
14834                 //
14835                 // We use removeAttr only for key events, to allow IE to export the correct
14836                 // accessible attributes. For mouse events, set to empty string to avoid
14837                 // native tooltip showing up (happens only when removing inside mouseover).
14838                 if ( target.is( "[title]" ) ) {
14839                         if ( event && event.type === "mouseover" ) {
14840                                 target.attr( "title", "" );
14841                         } else {
14842                                 target.removeAttr( "title" );
14843                         }
14844                 }
14845
14846                 tooltip = this._tooltip( target );
14847                 addDescribedBy( target, tooltip.attr( "id" ) );
14848                 tooltip.find( ".ui-tooltip-content" ).html( content );
14849
14850                 function position( event ) {
14851                         positionOption.of = event;
14852                         if ( tooltip.is( ":hidden" ) ) {
14853                                 return;
14854                         }
14855                         tooltip.position( positionOption );
14856                 }
14857                 if ( this.options.track && event && /^mouse/.test( event.type ) ) {
14858                         this._on( this.document, {
14859                                 mousemove: position
14860                         });
14861                         // trigger once to override element-relative positioning
14862                         position( event );
14863                 } else {
14864                         tooltip.position( $.extend({
14865                                 of: target
14866                         }, this.options.position ) );
14867                 }
14868
14869                 tooltip.hide();
14870
14871                 this._show( tooltip, this.options.show );
14872                 // Handle tracking tooltips that are shown with a delay (#8644). As soon
14873                 // as the tooltip is visible, position the tooltip using the most recent
14874                 // event.
14875                 if ( this.options.show && this.options.show.delay ) {
14876                         delayedShow = this.delayedShow = setInterval(function() {
14877                                 if ( tooltip.is( ":visible" ) ) {
14878                                         position( positionOption.of );
14879                                         clearInterval( delayedShow );
14880                                 }
14881                         }, $.fx.interval );
14882                 }
14883
14884                 this._trigger( "open", event, { tooltip: tooltip } );
14885
14886                 events = {
14887                         keyup: function( event ) {
14888                                 if ( event.keyCode === $.ui.keyCode.ESCAPE ) {
14889                                         var fakeEvent = $.Event(event);
14890                                         fakeEvent.currentTarget = target[0];
14891                                         this.close( fakeEvent, true );
14892                                 }
14893                         },
14894                         remove: function() {
14895                                 this._removeTooltip( tooltip );
14896                         }
14897                 };
14898                 if ( !event || event.type === "mouseover" ) {
14899                         events.mouseleave = "close";
14900                 }
14901                 if ( !event || event.type === "focusin" ) {
14902                         events.focusout = "close";
14903                 }
14904                 this._on( true, target, events );
14905         },
14906
14907         close: function( event ) {
14908                 var that = this,
14909                         target = $( event ? event.currentTarget : this.element ),
14910                         tooltip = this._find( target );
14911
14912                 // disabling closes the tooltip, so we need to track when we're closing
14913                 // to avoid an infinite loop in case the tooltip becomes disabled on close
14914                 if ( this.closing ) {
14915                         return;
14916                 }
14917
14918                 // Clear the interval for delayed tracking tooltips
14919                 clearInterval( this.delayedShow );
14920
14921                 // only set title if we had one before (see comment in _open())
14922                 if ( target.data( "ui-tooltip-title" ) ) {
14923                         target.attr( "title", target.data( "ui-tooltip-title" ) );
14924                 }
14925
14926                 removeDescribedBy( target );
14927
14928                 tooltip.stop( true );
14929                 this._hide( tooltip, this.options.hide, function() {
14930                         that._removeTooltip( $( this ) );
14931                 });
14932
14933                 target.removeData( "ui-tooltip-open" );
14934                 this._off( target, "mouseleave focusout keyup" );
14935                 // Remove 'remove' binding only on delegated targets
14936                 if ( target[0] !== this.element[0] ) {
14937                         this._off( target, "remove" );
14938                 }
14939                 this._off( this.document, "mousemove" );
14940
14941                 if ( event && event.type === "mouseleave" ) {
14942                         $.each( this.parents, function( id, parent ) {
14943                                 $( parent.element ).attr( "title", parent.title );
14944                                 delete that.parents[ id ];
14945                         });
14946                 }
14947
14948                 this.closing = true;
14949                 this._trigger( "close", event, { tooltip: tooltip } );
14950                 this.closing = false;
14951         },
14952
14953         _tooltip: function( element ) {
14954                 var id = "ui-tooltip-" + increments++,
14955                         tooltip = $( "<div>" )
14956                                 .attr({
14957                                         id: id,
14958                                         role: "tooltip"
14959                                 })
14960                                 .addClass( "ui-tooltip ui-widget ui-corner-all ui-widget-content " +
14961                                         ( this.options.tooltipClass || "" ) );
14962                 $( "<div>" )
14963                         .addClass( "ui-tooltip-content" )
14964                         .appendTo( tooltip );
14965                 tooltip.appendTo( this.document[0].body );
14966                 this.tooltips[ id ] = element;
14967                 return tooltip;
14968         },
14969
14970         _find: function( target ) {
14971                 var id = target.data( "ui-tooltip-id" );
14972                 return id ? $( "#" + id ) : $();
14973         },
14974
14975         _removeTooltip: function( tooltip ) {
14976                 tooltip.remove();
14977                 delete this.tooltips[ tooltip.attr( "id" ) ];
14978         },
14979
14980         _destroy: function() {
14981                 var that = this;
14982
14983                 // close open tooltips
14984                 $.each( this.tooltips, function( id, element ) {
14985                         // Delegate to close method to handle common cleanup
14986                         var event = $.Event( "blur" );
14987                         event.target = event.currentTarget = element[0];
14988                         that.close( event, true );
14989
14990                         // Remove immediately; destroying an open tooltip doesn't use the
14991                         // hide animation
14992                         $( "#" + id ).remove();
14993
14994                         // Restore the title
14995                         if ( element.data( "ui-tooltip-title" ) ) {
14996                                 element.attr( "title", element.data( "ui-tooltip-title" ) );
14997                                 element.removeData( "ui-tooltip-title" );
14998                         }
14999                 });
15000         }
15001 });
15002
15003 }( jQuery ) );