testing/ver0.01/jquery-ui-1.10.3.custom/development-bundle/ui/jquery-ui.custom.js

   1 /*! jQuery UI - v1.10.3 - 2013-08-18
   2 * http://jqueryui.com
   3 * Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.position.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.sortable.js, jquery.ui.accordion.js, jquery.ui.autocomplete.js, jquery.ui.button.js, jquery.ui.datepicker.js, jquery.ui.dialog.js, jquery.ui.menu.js, jquery.ui.progressbar.js, jquery.ui.slider.js, jquery.ui.spinner.js, jquery.ui.tabs.js, jquery.ui.tooltip.js, jquery.ui.effect.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
   4 * Copyright 2013 jQuery Foundation and other contributors Licensed MIT */
   5
   6 (function( $, undefined ) {
   7
   8 var uuid = 0,
   9         runiqueId = /^ui-id-\d+$/;
  10
  11 // $.ui might exist from components with no dependencies, e.g., $.ui.position
  12 $.ui = $.ui || {};
  13
  14 $.extend( $.ui, {
  15         version: "1.10.3",
  16
  17         keyCode: {
  18                 BACKSPACE: 8,
  19                 COMMA: 188,
  20                 DELETE: 46,
  21                 DOWN: 40,
  22                 END: 35,
  23                 ENTER: 13,
  24                 ESCAPE: 27,
  25                 HOME: 36,
  26                 LEFT: 37,
  27                 NUMPAD_ADD: 107,
  28                 NUMPAD_DECIMAL: 110,
  29                 NUMPAD_DIVIDE: 111,
  30                 NUMPAD_ENTER: 108,
  31                 NUMPAD_MULTIPLY: 106,
  32                 NUMPAD_SUBTRACT: 109,
  33                 PAGE_DOWN: 34,
  34                 PAGE_UP: 33,
  35                 PERIOD: 190,
  36                 RIGHT: 39,
  37                 SPACE: 32,
  38                 TAB: 9,
  39                 UP: 38
  40         }
  41 });
  42
  43 // plugins
  44 $.fn.extend({
  45         focus: (function( orig ) {
  46                 return function( delay, fn ) {
  47                         return typeof delay === "number" ?
  48                                 this.each(function() {
  49                                         var elem = this;
  50                                         setTimeout(function() {
  51                                                 $( elem ).focus();
  52                                                 if ( fn ) {
  53                                                         fn.call( elem );
  54                                                 }
  55                                         }, delay );
  56                                 }) :
  57                                 orig.apply( this, arguments );
  58                 };
  59         })( $.fn.focus ),
  60
  61         scrollParent: function() {
  62                 var scrollParent;
  63                 if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
  64                         scrollParent = this.parents().filter(function() {
  65                                 return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
  66                         }).eq(0);
  67                 } else {
  68                         scrollParent = this.parents().filter(function() {
  69                                 return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
  70                         }).eq(0);
  71                 }
  72
  73                 return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
  74         },
  75
  76         zIndex: function( zIndex ) {
  77                 if ( zIndex !== undefined ) {
  78                         return this.css( "zIndex", zIndex );
  79                 }
  80
  81                 if ( this.length ) {
  82                         var elem = $( this[ 0 ] ), position, value;
  83                         while ( elem.length && elem[ 0 ] !== document ) {
  84                                 // Ignore z-index if position is set to a value where z-index is ignored by the browser
  85                                 // This makes behavior of this function consistent across browsers
  86                                 // WebKit always returns auto if the element is positioned
  87                                 position = elem.css( "position" );
  88                                 if ( position === "absolute" || position === "relative" || position === "fixed" ) {
  89                                         // IE returns 0 when zIndex is not specified
  90                                         // other browsers return a string
  91                                         // we ignore the case of nested elements with an explicit value of 0
  92                                         // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
  93                                         value = parseInt( elem.css( "zIndex" ), 10 );
  94                                         if ( !isNaN( value ) && value !== 0 ) {
  95                                                 return value;
  96                                         }
  97                                 }
  98                                 elem = elem.parent();
  99                         }
 100                 }
 101
 102                 return 0;
 103         },
 104
 105         uniqueId: function() {
 106                 return this.each(function() {
 107                         if ( !this.id ) {
 108                                 this.id = "ui-id-" + (++uuid);
 109                         }
 110                 });
 111         },
 112
 113         removeUniqueId: function() {
 114                 return this.each(function() {
 115                         if ( runiqueId.test( this.id ) ) {
 116                                 $( this ).removeAttr( "id" );
 117                         }
 118                 });
 119         }
 120 });
 121
 122 // selectors
 123 function focusable( element, isTabIndexNotNaN ) {
 124         var map, mapName, img,
 125                 nodeName = element.nodeName.toLowerCase();
 126         if ( "area" === nodeName ) {
 127                 map = element.parentNode;
 128                 mapName = map.name;
 129                 if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
 130                         return false;
 131                 }
 132                 img = $( "img[usemap=#" + mapName + "]" )[0];
 133                 return !!img && visible( img );
 134         }
 135         return ( /input|select|textarea|button|object/.test( nodeName ) ?
 136                 !element.disabled :
 137                 "a" === nodeName ?
 138                         element.href || isTabIndexNotNaN :
 139                         isTabIndexNotNaN) &&
 140                 // the element and all of its ancestors must be visible
 141                 visible( element );
 142 }
 143
 144 function visible( element ) {
 145         return $.expr.filters.visible( element ) &&
 146                 !$( element ).parents().addBack().filter(function() {
 147                         return $.css( this, "visibility" ) === "hidden";
 148                 }).length;
 149 }
 150
 151 $.extend( $.expr[ ":" ], {
 152         data: $.expr.createPseudo ?
 153                 $.expr.createPseudo(function( dataName ) {
 154                         return function( elem ) {
 155                                 return !!$.data( elem, dataName );
 156                         };
 157                 }) :
 158                 // support: jQuery <1.8
 159                 function( elem, i, match ) {
 160                         return !!$.data( elem, match[ 3 ] );
 161                 },
 162
 163         focusable: function( element ) {
 164                 return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
 165         },
 166
 167         tabbable: function( element ) {
 168                 var tabIndex = $.attr( element, "tabindex" ),
 169                         isTabIndexNaN = isNaN( tabIndex );
 170                 return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
 171         }
 172 });
 173
 174 // support: jQuery <1.8
 175 if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
 176         $.each( [ "Width", "Height" ], function( i, name ) {
 177                 var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
 178                         type = name.toLowerCase(),
 179                         orig = {
 180                                 innerWidth: $.fn.innerWidth,
 181                                 innerHeight: $.fn.innerHeight,
 182                                 outerWidth: $.fn.outerWidth,
 183                                 outerHeight: $.fn.outerHeight
 184                         };
 185
 186                 function reduce( elem, size, border, margin ) {
 187                         $.each( side, function() {
 188                                 size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
 189                                 if ( border ) {
 190                                         size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
 191                                 }
 192                                 if ( margin ) {
 193                                         size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
 194                                 }
 195                         });
 196                         return size;
 197                 }
 198
 199                 $.fn[ "inner" + name ] = function( size ) {
 200                         if ( size === undefined ) {
 201                                 return orig[ "inner" + name ].call( this );
 202                         }
 203
 204                         return this.each(function() {
 205                                 $( this ).css( type, reduce( this, size ) + "px" );
 206                         });
 207                 };
 208
 209                 $.fn[ "outer" + name] = function( size, margin ) {
 210                         if ( typeof size !== "number" ) {
 211                                 return orig[ "outer" + name ].call( this, size );
 212                         }
 213
 214                         return this.each(function() {
 215                                 $( this).css( type, reduce( this, size, true, margin ) + "px" );
 216                         });
 217                 };
 218         });
 219 }
 220
 221 // support: jQuery <1.8
 222 if ( !$.fn.addBack ) {
 223         $.fn.addBack = function( selector ) {
 224                 return this.add( selector == null ?
 225                         this.prevObject : this.prevObject.filter( selector )
 226                 );
 227         };
 228 }
 229
 230 // support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
 231 if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
 232         $.fn.removeData = (function( removeData ) {
 233                 return function( key ) {
 234                         if ( arguments.length ) {
 235                                 return removeData.call( this, $.camelCase( key ) );
 236                         } else {
 237                                 return removeData.call( this );
 238                         }
 239                 };
 240         })( $.fn.removeData );
 241 }
 242
 243
 244
 245
 246
 247 // deprecated
 248 $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
 249
 250 $.support.selectstart = "onselectstart" in document.createElement( "div" );
 251 $.fn.extend({
 252         disableSelection: function() {
 253                 return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
 254                         ".ui-disableSelection", function( event ) {
 255                                 event.preventDefault();
 256                         });
 257         },
 258
 259         enableSelection: function() {
 260                 return this.unbind( ".ui-disableSelection" );
 261         }
 262 });
 263
 264 $.extend( $.ui, {
 265         // $.ui.plugin is deprecated. Use $.widget() extensions instead.
 266         plugin: {
 267                 add: function( module, option, set ) {
 268                         var i,
 269                                 proto = $.ui[ module ].prototype;
 270                         for ( i in set ) {
 271                                 proto.plugins[ i ] = proto.plugins[ i ] || [];
 272                                 proto.plugins[ i ].push( [ option, set[ i ] ] );
 273                         }
 274                 },
 275                 call: function( instance, name, args ) {
 276                         var i,
 277                                 set = instance.plugins[ name ];
 278                         if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
 279                                 return;
 280                         }
 281
 282                         for ( i = 0; i < set.length; i++ ) {
 283                                 if ( instance.options[ set[ i ][ 0 ] ] ) {
 284                                         set[ i ][ 1 ].apply( instance.element, args );
 285                                 }
 286                         }
 287                 }
 288         },
 289
 290         // only used by resizable
 291         hasScroll: function( el, a ) {
 292
 293                 //If overflow is hidden, the element might have extra content, but the user wants to hide it
 294                 if ( $( el ).css( "overflow" ) === "hidden") {
 295                         return false;
 296                 }
 297
 298                 var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
 299                         has = false;
 300
 301                 if ( el[ scroll ] > 0 ) {
 302                         return true;
 303                 }
 304
 305                 // TODO: determine which cases actually cause this to happen
 306                 // if the element doesn't have the scroll set, see if it's possible to
 307                 // set the scroll
 308                 el[ scroll ] = 1;
 309                 has = ( el[ scroll ] > 0 );
 310                 el[ scroll ] = 0;
 311                 return has;
 312         }
 313 });
 314
 315 })( jQuery );
 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 (function( $, undefined ) {
 828
 829 var mouseHandled = false;
 830 $( document ).mouseup( function() {
 831         mouseHandled = false;
 832 });
 833
 834 $.widget("ui.mouse", {
 835         version: "1.10.3",
 836         options: {
 837                 cancel: "input,textarea,button,select,option",
 838                 distance: 1,
 839                 delay: 0
 840         },
 841         _mouseInit: function() {
 842                 var that = this;
 843
 844                 this.element
 845                         .bind("mousedown."+this.widgetName, function(event) {
 846                                 return that._mouseDown(event);
 847                         })
 848                         .bind("click."+this.widgetName, function(event) {
 849                                 if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
 850                                         $.removeData(event.target, that.widgetName + ".preventClickEvent");
 851                                         event.stopImmediatePropagation();
 852                                         return false;
 853                                 }
 854                         });
 855
 856                 this.started = false;
 857         },
 858
 859         // TODO: make sure destroying one instance of mouse doesn't mess with
 860         // other instances of mouse
 861         _mouseDestroy: function() {
 862                 this.element.unbind("."+this.widgetName);
 863                 if ( this._mouseMoveDelegate ) {
 864                         $(document)
 865                                 .unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
 866                                 .unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
 867                 }
 868         },
 869
 870         _mouseDown: function(event) {
 871                 // don't let more than one widget handle mouseStart
 872                 if( mouseHandled ) { return; }
 873
 874                 // we may have missed mouseup (out of window)
 875                 (this._mouseStarted && this._mouseUp(event));
 876
 877                 this._mouseDownEvent = event;
 878
 879                 var that = this,
 880                         btnIsLeft = (event.which === 1),
 881                         // event.target.nodeName works around a bug in IE 8 with
 882                         // disabled inputs (#7620)
 883                         elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
 884                 if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
 885                         return true;
 886                 }
 887
 888                 this.mouseDelayMet = !this.options.delay;
 889                 if (!this.mouseDelayMet) {
 890                         this._mouseDelayTimer = setTimeout(function() {
 891                                 that.mouseDelayMet = true;
 892                         }, this.options.delay);
 893                 }
 894
 895                 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
 896                         this._mouseStarted = (this._mouseStart(event) !== false);
 897                         if (!this._mouseStarted) {
 898                                 event.preventDefault();
 899                                 return true;
 900                         }
 901                 }
 902
 903                 // Click event may never have fired (Gecko & Opera)
 904                 if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
 905                         $.removeData(event.target, this.widgetName + ".preventClickEvent");
 906                 }
 907
 908                 // these delegates are required to keep context
 909                 this._mouseMoveDelegate = function(event) {
 910                         return that._mouseMove(event);
 911                 };
 912                 this._mouseUpDelegate = function(event) {
 913                         return that._mouseUp(event);
 914                 };
 915                 $(document)
 916                         .bind("mousemove."+this.widgetName, this._mouseMoveDelegate)
 917                         .bind("mouseup."+this.widgetName, this._mouseUpDelegate);
 918
 919                 event.preventDefault();
 920
 921                 mouseHandled = true;
 922                 return true;
 923         },
 924
 925         _mouseMove: function(event) {
 926                 // IE mouseup check - mouseup happened when mouse was out of window
 927                 if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
 928                         return this._mouseUp(event);
 929                 }
 930
 931                 if (this._mouseStarted) {
 932                         this._mouseDrag(event);
 933                         return event.preventDefault();
 934                 }
 935
 936                 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
 937                         this._mouseStarted =
 938                                 (this._mouseStart(this._mouseDownEvent, event) !== false);
 939                         (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
 940                 }
 941
 942                 return !this._mouseStarted;
 943         },
 944
 945         _mouseUp: function(event) {
 946                 $(document)
 947                         .unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
 948                         .unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
 949
 950                 if (this._mouseStarted) {
 951                         this._mouseStarted = false;
 952
 953                         if (event.target === this._mouseDownEvent.target) {
 954                                 $.data(event.target, this.widgetName + ".preventClickEvent", true);
 955                         }
 956
 957                         this._mouseStop(event);
 958                 }
 959
 960                 return false;
 961         },
 962
 963         _mouseDistanceMet: function(event) {
 964                 return (Math.max(
 965                                 Math.abs(this._mouseDownEvent.pageX - event.pageX),
 966                                 Math.abs(this._mouseDownEvent.pageY - event.pageY)
 967                         ) >= this.options.distance
 968                 );
 969         },
 970
 971         _mouseDelayMet: function(/* event */) {
 972                 return this.mouseDelayMet;
 973         },
 974
 975         // These are placeholder methods, to be overriden by extending plugin
 976         _mouseStart: function(/* event */) {},
 977         _mouseDrag: function(/* event */) {},
 978         _mouseStop: function(/* event */) {},
 979         _mouseCapture: function(/* event */) { return true; }
 980 });
 981
 982 })(jQuery);
 983 (function( $, undefined ) {
 984
 985 $.ui = $.ui || {};
 986
 987 var cachedScrollbarWidth,
 988         max = Math.max,
 989         abs = Math.abs,
 990         round = Math.round,
 991         rhorizontal = /left|center|right/,
 992         rvertical = /top|center|bottom/,
 993         roffset = /[\+\-]\d+(\.[\d]+)?%?/,
 994         rposition = /^\w+/,
 995         rpercent = /%$/,
 996         _position = $.fn.position;
 997
 998 function getOffsets( offsets, width, height ) {
 999         return [
1000                 parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
1001                 parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
1002         ];
1003 }
1004
1005 function parseCss( element, property ) {
1006         return parseInt( $.css( element, property ), 10 ) || 0;
1007 }
1008
1009 function getDimensions( elem ) {
1010         var raw = elem[0];
1011         if ( raw.nodeType === 9 ) {
1012                 return {
1013                         width: elem.width(),
1014                         height: elem.height(),
1015                         offset: { top: 0, left: 0 }
1016                 };
1017         }
1018         if ( $.isWindow( raw ) ) {
1019                 return {
1020                         width: elem.width(),
1021                         height: elem.height(),
1022                         offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
1023                 };
1024         }
1025         if ( raw.preventDefault ) {
1026                 return {
1027                         width: 0,
1028                         height: 0,
1029                         offset: { top: raw.pageY, left: raw.pageX }
1030                 };
1031         }
1032         return {
1033                 width: elem.outerWidth(),
1034                 height: elem.outerHeight(),
1035                 offset: elem.offset()
1036         };
1037 }
1038
1039 $.position = {
1040         scrollbarWidth: function() {
1041                 if ( cachedScrollbarWidth !== undefined ) {
1042                         return cachedScrollbarWidth;
1043                 }
1044                 var w1, w2,
1045                         div = $( "<div style='display:block;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
1046                         innerDiv = div.children()[0];
1047
1048                 $( "body" ).append( div );
1049                 w1 = innerDiv.offsetWidth;
1050                 div.css( "overflow", "scroll" );
1051
1052                 w2 = innerDiv.offsetWidth;
1053
1054                 if ( w1 === w2 ) {
1055                         w2 = div[0].clientWidth;
1056                 }
1057
1058                 div.remove();
1059
1060                 return (cachedScrollbarWidth = w1 - w2);
1061         },
1062         getScrollInfo: function( within ) {
1063                 var overflowX = within.isWindow ? "" : within.element.css( "overflow-x" ),
1064                         overflowY = within.isWindow ? "" : within.element.css( "overflow-y" ),
1065                         hasOverflowX = overflowX === "scroll" ||
1066                                 ( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
1067                         hasOverflowY = overflowY === "scroll" ||
1068                                 ( overflowY === "auto" && within.height < within.element[0].scrollHeight );
1069                 return {
1070                         width: hasOverflowY ? $.position.scrollbarWidth() : 0,
1071                         height: hasOverflowX ? $.position.scrollbarWidth() : 0
1072                 };
1073         },
1074         getWithinInfo: function( element ) {
1075                 var withinElement = $( element || window ),
1076                         isWindow = $.isWindow( withinElement[0] );
1077                 return {
1078                         element: withinElement,
1079                         isWindow: isWindow,
1080                         offset: withinElement.offset() || { left: 0, top: 0 },
1081                         scrollLeft: withinElement.scrollLeft(),
1082                         scrollTop: withinElement.scrollTop(),
1083                         width: isWindow ? withinElement.width() : withinElement.outerWidth(),
1084                         height: isWindow ? withinElement.height() : withinElement.outerHeight()
1085                 };
1086         }
1087 };
1088
1089 $.fn.position = function( options ) {
1090         if ( !options || !options.of ) {
1091                 return _position.apply( this, arguments );
1092         }
1093
1094         // make a copy, we don't want to modify arguments
1095         options = $.extend( {}, options );
1096
1097         var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
1098                 target = $( options.of ),
1099                 within = $.position.getWithinInfo( options.within ),
1100                 scrollInfo = $.position.getScrollInfo( within ),
1101                 collision = ( options.collision || "flip" ).split( " " ),
1102                 offsets = {};
1103
1104         dimensions = getDimensions( target );
1105         if ( target[0].preventDefault ) {
1106                 // force left top to allow flipping
1107                 options.at = "left top";
1108         }
1109         targetWidth = dimensions.width;
1110         targetHeight = dimensions.height;
1111         targetOffset = dimensions.offset;
1112         // clone to reuse original targetOffset later
1113         basePosition = $.extend( {}, targetOffset );
1114
1115         // force my and at to have valid horizontal and vertical positions
1116         // if a value is missing or invalid, it will be converted to center
1117         $.each( [ "my", "at" ], function() {
1118                 var pos = ( options[ this ] || "" ).split( " " ),
1119                         horizontalOffset,
1120                         verticalOffset;
1121
1122                 if ( pos.length === 1) {
1123                         pos = rhorizontal.test( pos[ 0 ] ) ?
1124                                 pos.concat( [ "center" ] ) :
1125                                 rvertical.test( pos[ 0 ] ) ?
1126                                         [ "center" ].concat( pos ) :
1127                                         [ "center", "center" ];
1128                 }
1129                 pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
1130                 pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
1131
1132                 // calculate offsets
1133                 horizontalOffset = roffset.exec( pos[ 0 ] );
1134                 verticalOffset = roffset.exec( pos[ 1 ] );
1135                 offsets[ this ] = [
1136                         horizontalOffset ? horizontalOffset[ 0 ] : 0,
1137                         verticalOffset ? verticalOffset[ 0 ] : 0
1138                 ];
1139
1140                 // reduce to just the positions without the offsets
1141                 options[ this ] = [
1142                         rposition.exec( pos[ 0 ] )[ 0 ],
1143                         rposition.exec( pos[ 1 ] )[ 0 ]
1144                 ];
1145         });
1146
1147         // normalize collision option
1148         if ( collision.length === 1 ) {
1149                 collision[ 1 ] = collision[ 0 ];
1150         }
1151
1152         if ( options.at[ 0 ] === "right" ) {
1153                 basePosition.left += targetWidth;
1154         } else if ( options.at[ 0 ] === "center" ) {
1155                 basePosition.left += targetWidth / 2;
1156         }
1157
1158         if ( options.at[ 1 ] === "bottom" ) {
1159                 basePosition.top += targetHeight;
1160         } else if ( options.at[ 1 ] === "center" ) {
1161                 basePosition.top += targetHeight / 2;
1162         }
1163
1164         atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
1165         basePosition.left += atOffset[ 0 ];
1166         basePosition.top += atOffset[ 1 ];
1167
1168         return this.each(function() {
1169                 var collisionPosition, using,
1170                         elem = $( this ),
1171                         elemWidth = elem.outerWidth(),
1172                         elemHeight = elem.outerHeight(),
1173                         marginLeft = parseCss( this, "marginLeft" ),
1174                         marginTop = parseCss( this, "marginTop" ),
1175                         collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
1176                         collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
1177                         position = $.extend( {}, basePosition ),
1178                         myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
1179
1180                 if ( options.my[ 0 ] === "right" ) {
1181                         position.left -= elemWidth;
1182                 } else if ( options.my[ 0 ] === "center" ) {
1183                         position.left -= elemWidth / 2;
1184                 }
1185
1186                 if ( options.my[ 1 ] === "bottom" ) {
1187                         position.top -= elemHeight;
1188                 } else if ( options.my[ 1 ] === "center" ) {
1189                         position.top -= elemHeight / 2;
1190                 }
1191
1192                 position.left += myOffset[ 0 ];
1193                 position.top += myOffset[ 1 ];
1194
1195                 // if the browser doesn't support fractions, then round for consistent results
1196                 if ( !$.support.offsetFractions ) {
1197                         position.left = round( position.left );
1198                         position.top = round( position.top );
1199                 }
1200
1201                 collisionPosition = {
1202                         marginLeft: marginLeft,
1203                         marginTop: marginTop
1204                 };
1205
1206                 $.each( [ "left", "top" ], function( i, dir ) {
1207                         if ( $.ui.position[ collision[ i ] ] ) {
1208                                 $.ui.position[ collision[ i ] ][ dir ]( position, {
1209                                         targetWidth: targetWidth,
1210                                         targetHeight: targetHeight,
1211                                         elemWidth: elemWidth,
1212                                         elemHeight: elemHeight,
1213                                         collisionPosition: collisionPosition,
1214                                         collisionWidth: collisionWidth,
1215                                         collisionHeight: collisionHeight,
1216                                         offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1217                                         my: options.my,
1218                                         at: options.at,
1219                                         within: within,
1220                                         elem : elem
1221                                 });
1222                         }
1223                 });
1224
1225                 if ( options.using ) {
1226                         // adds feedback as second argument to using callback, if present
1227                         using = function( props ) {
1228                                 var left = targetOffset.left - position.left,
1229                                         right = left + targetWidth - elemWidth,
1230                                         top = targetOffset.top - position.top,
1231                                         bottom = top + targetHeight - elemHeight,
1232                                         feedback = {
1233                                                 target: {
1234                                                         element: target,
1235                                                         left: targetOffset.left,
1236                                                         top: targetOffset.top,
1237                                                         width: targetWidth,
1238                                                         height: targetHeight
1239                                                 },
1240                                                 element: {
1241                                                         element: elem,
1242                                                         left: position.left,
1243                                                         top: position.top,
1244                                                         width: elemWidth,
1245                                                         height: elemHeight
1246                                                 },
1247                                                 horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1248                                                 vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1249                                         };
1250                                 if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1251                                         feedback.horizontal = "center";
1252                                 }
1253                                 if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1254                                         feedback.vertical = "middle";
1255                                 }
1256                                 if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1257                                         feedback.important = "horizontal";
1258                                 } else {
1259                                         feedback.important = "vertical";
1260                                 }
1261                                 options.using.call( this, props, feedback );
1262                         };
1263                 }
1264
1265                 elem.offset( $.extend( position, { using: using } ) );
1266         });
1267 };
1268
1269 $.ui.position = {
1270         fit: {
1271                 left: function( position, data ) {
1272                         var within = data.within,
1273                                 withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1274                                 outerWidth = within.width,
1275                                 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1276                                 overLeft = withinOffset - collisionPosLeft,
1277                                 overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1278                                 newOverRight;
1279
1280                         // element is wider than within
1281                         if ( data.collisionWidth > outerWidth ) {
1282                                 // element is initially over the left side of within
1283                                 if ( overLeft > 0 && overRight <= 0 ) {
1284                                         newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
1285                                         position.left += overLeft - newOverRight;
1286                                 // element is initially over right side of within
1287                                 } else if ( overRight > 0 && overLeft <= 0 ) {
1288                                         position.left = withinOffset;
1289                                 // element is initially over both left and right sides of within
1290                                 } else {
1291                                         if ( overLeft > overRight ) {
1292                                                 position.left = withinOffset + outerWidth - data.collisionWidth;
1293                                         } else {
1294                                                 position.left = withinOffset;
1295                                         }
1296                                 }
1297                         // too far left -> align with left edge
1298                         } else if ( overLeft > 0 ) {
1299                                 position.left += overLeft;
1300                         // too far right -> align with right edge
1301                         } else if ( overRight > 0 ) {
1302                                 position.left -= overRight;
1303                         // adjust based on position and margin
1304                         } else {
1305                                 position.left = max( position.left - collisionPosLeft, position.left );
1306                         }
1307                 },
1308                 top: function( position, data ) {
1309                         var within = data.within,
1310                                 withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1311                                 outerHeight = data.within.height,
1312                                 collisionPosTop = position.top - data.collisionPosition.marginTop,
1313                                 overTop = withinOffset - collisionPosTop,
1314                                 overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1315                                 newOverBottom;
1316
1317                         // element is taller than within
1318                         if ( data.collisionHeight > outerHeight ) {
1319                                 // element is initially over the top of within
1320                                 if ( overTop > 0 && overBottom <= 0 ) {
1321                                         newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
1322                                         position.top += overTop - newOverBottom;
1323                                 // element is initially over bottom of within
1324                                 } else if ( overBottom > 0 && overTop <= 0 ) {
1325                                         position.top = withinOffset;
1326                                 // element is initially over both top and bottom of within
1327                                 } else {
1328                                         if ( overTop > overBottom ) {
1329                                                 position.top = withinOffset + outerHeight - data.collisionHeight;
1330                                         } else {
1331                                                 position.top = withinOffset;
1332                                         }
1333                                 }
1334                         // too far up -> align with top
1335                         } else if ( overTop > 0 ) {
1336                                 position.top += overTop;
1337                         // too far down -> align with bottom edge
1338                         } else if ( overBottom > 0 ) {
1339                                 position.top -= overBottom;
1340                         // adjust based on position and margin
1341                         } else {
1342                                 position.top = max( position.top - collisionPosTop, position.top );
1343                         }
1344                 }
1345         },
1346         flip: {
1347                 left: function( position, data ) {
1348                         var within = data.within,
1349                                 withinOffset = within.offset.left + within.scrollLeft,
1350                                 outerWidth = within.width,
1351                                 offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1352                                 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1353                                 overLeft = collisionPosLeft - offsetLeft,
1354                                 overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1355                                 myOffset = data.my[ 0 ] === "left" ?
1356                                         -data.elemWidth :
1357                                         data.my[ 0 ] === "right" ?
1358                                                 data.elemWidth :
1359                                                 0,
1360                                 atOffset = data.at[ 0 ] === "left" ?
1361                                         data.targetWidth :
1362                                         data.at[ 0 ] === "right" ?
1363                                                 -data.targetWidth :
1364                                                 0,
1365                                 offset = -2 * data.offset[ 0 ],
1366                                 newOverRight,
1367                                 newOverLeft;
1368
1369                         if ( overLeft < 0 ) {
1370                                 newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
1371                                 if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1372                                         position.left += myOffset + atOffset + offset;
1373                                 }
1374                         }
1375                         else if ( overRight > 0 ) {
1376                                 newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
1377                                 if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1378                                         position.left += myOffset + atOffset + offset;
1379                                 }
1380                         }
1381                 },
1382                 top: function( position, data ) {
1383                         var within = data.within,
1384                                 withinOffset = within.offset.top + within.scrollTop,
1385                                 outerHeight = within.height,
1386                                 offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1387                                 collisionPosTop = position.top - data.collisionPosition.marginTop,
1388                                 overTop = collisionPosTop - offsetTop,
1389                                 overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1390                                 top = data.my[ 1 ] === "top",
1391                                 myOffset = top ?
1392                                         -data.elemHeight :
1393                                         data.my[ 1 ] === "bottom" ?
1394                                                 data.elemHeight :
1395                                                 0,
1396                                 atOffset = data.at[ 1 ] === "top" ?
1397                                         data.targetHeight :
1398                                         data.at[ 1 ] === "bottom" ?
1399                                                 -data.targetHeight :
1400                                                 0,
1401                                 offset = -2 * data.offset[ 1 ],
1402                                 newOverTop,
1403                                 newOverBottom;
1404                         if ( overTop < 0 ) {
1405                                 newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
1406                                 if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
1407                                         position.top += myOffset + atOffset + offset;
1408                                 }
1409                         }
1410                         else if ( overBottom > 0 ) {
1411                                 newOverTop = position.top -  data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
1412                                 if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
1413                                         position.top += myOffset + atOffset + offset;
1414                                 }
1415                         }
1416                 }
1417         },
1418         flipfit: {
1419                 left: function() {
1420                         $.ui.position.flip.left.apply( this, arguments );
1421                         $.ui.position.fit.left.apply( this, arguments );
1422                 },
1423                 top: function() {
1424                         $.ui.position.flip.top.apply( this, arguments );
1425                         $.ui.position.fit.top.apply( this, arguments );
1426                 }
1427         }
1428 };
1429
1430 // fraction support test
1431 (function () {
1432         var testElement, testElementParent, testElementStyle, offsetLeft, i,
1433                 body = document.getElementsByTagName( "body" )[ 0 ],
1434                 div = document.createElement( "div" );
1435
1436         //Create a "fake body" for testing based on method used in jQuery.support
1437         testElement = document.createElement( body ? "div" : "body" );
1438         testElementStyle = {
1439                 visibility: "hidden",
1440                 width: 0,
1441                 height: 0,
1442                 border: 0,
1443                 margin: 0,
1444                 background: "none"
1445         };
1446         if ( body ) {
1447                 $.extend( testElementStyle, {
1448                         position: "absolute",
1449                         left: "-1000px",
1450                         top: "-1000px"
1451                 });
1452         }
1453         for ( i in testElementStyle ) {
1454                 testElement.style[ i ] = testElementStyle[ i ];
1455         }
1456         testElement.appendChild( div );
1457         testElementParent = body || document.documentElement;
1458         testElementParent.insertBefore( testElement, testElementParent.firstChild );
1459
1460         div.style.cssText = "position: absolute; left: 10.7432222px;";
1461
1462         offsetLeft = $( div ).offset().left;
1463         $.support.offsetFractions = offsetLeft > 10 && offsetLeft < 11;
1464
1465         testElement.innerHTML = "";
1466         testElementParent.removeChild( testElement );
1467 })();
1468
1469 }( jQuery ) );
1470 (function( $, undefined ) {
1471
1472 $.widget("ui.draggable", $.ui.mouse, {
1473         version: "1.10.3",
1474         widgetEventPrefix: "drag",
1475         options: {
1476                 addClasses: true,
1477                 appendTo: "parent",
1478                 axis: false,
1479                 connectToSortable: false,
1480                 containment: false,
1481                 cursor: "auto",
1482                 cursorAt: false,
1483                 grid: false,
1484                 handle: false,
1485                 helper: "original",
1486                 iframeFix: false,
1487                 opacity: false,
1488                 refreshPositions: false,
1489                 revert: false,
1490                 revertDuration: 500,
1491                 scope: "default",
1492                 scroll: true,
1493                 scrollSensitivity: 20,
1494                 scrollSpeed: 20,
1495                 snap: false,
1496                 snapMode: "both",
1497                 snapTolerance: 20,
1498                 stack: false,
1499                 zIndex: false,
1500
1501                 // callbacks
1502                 drag: null,
1503                 start: null,
1504                 stop: null
1505         },
1506         _create: function() {
1507
1508                 if (this.options.helper === "original" && !(/^(?:r|a|f)/).test(this.element.css("position"))) {
1509                         this.element[0].style.position = "relative";
1510                 }
1511                 if (this.options.addClasses){
1512                         this.element.addClass("ui-draggable");
1513                 }
1514                 if (this.options.disabled){
1515                         this.element.addClass("ui-draggable-disabled");
1516                 }
1517
1518                 this._mouseInit();
1519
1520         },
1521
1522         _destroy: function() {
1523                 this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
1524                 this._mouseDestroy();
1525         },
1526
1527         _mouseCapture: function(event) {
1528
1529                 var o = this.options;
1530
1531                 // among others, prevent a drag on a resizable-handle
1532                 if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
1533                         return false;
1534                 }
1535
1536                 //Quit if we're not on a valid handle
1537                 this.handle = this._getHandle(event);
1538                 if (!this.handle) {
1539                         return false;
1540                 }
1541
1542                 $(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {
1543                         $("<div class='ui-draggable-iframeFix' style='background: #fff;'></div>")
1544                         .css({
1545                                 width: this.offsetWidth+"px", height: this.offsetHeight+"px",
1546                                 position: "absolute", opacity: "0.001", zIndex: 1000
1547                         })
1548                         .css($(this).offset())
1549                         .appendTo("body");
1550                 });
1551
1552                 return true;
1553
1554         },
1555
1556         _mouseStart: function(event) {
1557
1558                 var o = this.options;
1559
1560                 //Create and append the visible helper
1561                 this.helper = this._createHelper(event);
1562
1563                 this.helper.addClass("ui-draggable-dragging");
1564
1565                 //Cache the helper size
1566                 this._cacheHelperProportions();
1567
1568                 //If ddmanager is used for droppables, set the global draggable
1569                 if($.ui.ddmanager) {
1570                         $.ui.ddmanager.current = this;
1571                 }
1572
1573                 /*
1574                  * - Position generation -
1575                  * This block generates everything position related - it's the core of draggables.
1576                  */
1577
1578                 //Cache the margins of the original element
1579                 this._cacheMargins();
1580
1581                 //Store the helper's css position
1582                 this.cssPosition = this.helper.css( "position" );
1583                 this.scrollParent = this.helper.scrollParent();
1584                 this.offsetParent = this.helper.offsetParent();
1585                 this.offsetParentCssPosition = this.offsetParent.css( "position" );
1586
1587                 //The element's absolute position on the page minus margins
1588                 this.offset = this.positionAbs = this.element.offset();
1589                 this.offset = {
1590                         top: this.offset.top - this.margins.top,
1591                         left: this.offset.left - this.margins.left
1592                 };
1593
1594                 //Reset scroll cache
1595                 this.offset.scroll = false;
1596
1597                 $.extend(this.offset, {
1598                         click: { //Where the click happened, relative to the element
1599                                 left: event.pageX - this.offset.left,
1600                                 top: event.pageY - this.offset.top
1601                         },
1602                         parent: this._getParentOffset(),
1603                         relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
1604                 });
1605
1606                 //Generate the original position
1607                 this.originalPosition = this.position = this._generatePosition(event);
1608                 this.originalPageX = event.pageX;
1609                 this.originalPageY = event.pageY;
1610
1611                 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
1612                 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
1613
1614                 //Set a containment if given in the options
1615                 this._setContainment();
1616
1617                 //Trigger event + callbacks
1618                 if(this._trigger("start", event) === false) {
1619                         this._clear();
1620                         return false;
1621                 }
1622
1623                 //Recache the helper size
1624                 this._cacheHelperProportions();
1625
1626                 //Prepare the droppable offsets
1627                 if ($.ui.ddmanager && !o.dropBehaviour) {
1628                         $.ui.ddmanager.prepareOffsets(this, event);
1629                 }
1630
1631
1632                 this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
1633
1634                 //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
1635                 if ( $.ui.ddmanager ) {
1636                         $.ui.ddmanager.dragStart(this, event);
1637                 }
1638
1639                 return true;
1640         },
1641
1642         _mouseDrag: function(event, noPropagation) {
1643                 // reset any necessary cached properties (see #5009)
1644                 if ( this.offsetParentCssPosition === "fixed" ) {
1645                         this.offset.parent = this._getParentOffset();
1646                 }
1647
1648                 //Compute the helpers position
1649                 this.position = this._generatePosition(event);
1650                 this.positionAbs = this._convertPositionTo("absolute");
1651
1652                 //Call plugins and callbacks and use the resulting position if something is returned
1653                 if (!noPropagation) {
1654                         var ui = this._uiHash();
1655                         if(this._trigger("drag", event, ui) === false) {
1656                                 this._mouseUp({});
1657                                 return false;
1658                         }
1659                         this.position = ui.position;
1660                 }
1661
1662                 if(!this.options.axis || this.options.axis !== "y") {
1663                         this.helper[0].style.left = this.position.left+"px";
1664                 }
1665                 if(!this.options.axis || this.options.axis !== "x") {
1666                         this.helper[0].style.top = this.position.top+"px";
1667                 }
1668                 if($.ui.ddmanager) {
1669                         $.ui.ddmanager.drag(this, event);
1670                 }
1671
1672                 return false;
1673         },
1674
1675         _mouseStop: function(event) {
1676
1677                 //If we are using droppables, inform the manager about the drop
1678                 var that = this,
1679                         dropped = false;
1680                 if ($.ui.ddmanager && !this.options.dropBehaviour) {
1681                         dropped = $.ui.ddmanager.drop(this, event);
1682                 }
1683
1684                 //if a drop comes from outside (a sortable)
1685                 if(this.dropped) {
1686                         dropped = this.dropped;
1687                         this.dropped = false;
1688                 }
1689
1690                 //if the original element is no longer in the DOM don't bother to continue (see #8269)
1691                 if ( this.options.helper === "original" && !$.contains( this.element[ 0 ].ownerDocument, this.element[ 0 ] ) ) {
1692                         return false;
1693                 }
1694
1695                 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))) {
1696                         $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
1697                                 if(that._trigger("stop", event) !== false) {
1698                                         that._clear();
1699                                 }
1700                         });
1701                 } else {
1702                         if(this._trigger("stop", event) !== false) {
1703                                 this._clear();
1704                         }
1705                 }
1706
1707                 return false;
1708         },
1709
1710         _mouseUp: function(event) {
1711                 //Remove frame helpers
1712                 $("div.ui-draggable-iframeFix").each(function() {
1713                         this.parentNode.removeChild(this);
1714                 });
1715
1716                 //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
1717                 if( $.ui.ddmanager ) {
1718                         $.ui.ddmanager.dragStop(this, event);
1719                 }
1720
1721                 return $.ui.mouse.prototype._mouseUp.call(this, event);
1722         },
1723
1724         cancel: function() {
1725
1726                 if(this.helper.is(".ui-draggable-dragging")) {
1727                         this._mouseUp({});
1728                 } else {
1729                         this._clear();
1730                 }
1731
1732                 return this;
1733
1734         },
1735
1736         _getHandle: function(event) {
1737                 return this.options.handle ?
1738                         !!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
1739                         true;
1740         },
1741
1742         _createHelper: function(event) {
1743
1744                 var o = this.options,
1745                         helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper === "clone" ? this.element.clone().removeAttr("id") : this.element);
1746
1747                 if(!helper.parents("body").length) {
1748                         helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
1749                 }
1750
1751                 if(helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
1752                         helper.css("position", "absolute");
1753                 }
1754
1755                 return helper;
1756
1757         },
1758
1759         _adjustOffsetFromHelper: function(obj) {
1760                 if (typeof obj === "string") {
1761                         obj = obj.split(" ");
1762                 }
1763                 if ($.isArray(obj)) {
1764                         obj = {left: +obj[0], top: +obj[1] || 0};
1765                 }
1766                 if ("left" in obj) {
1767                         this.offset.click.left = obj.left + this.margins.left;
1768                 }
1769                 if ("right" in obj) {
1770                         this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
1771                 }
1772                 if ("top" in obj) {
1773                         this.offset.click.top = obj.top + this.margins.top;
1774                 }
1775                 if ("bottom" in obj) {
1776                         this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
1777                 }
1778         },
1779
1780         _getParentOffset: function() {
1781
1782                 //Get the offsetParent and cache its position
1783                 var po = this.offsetParent.offset();
1784
1785                 // This is a special case where we need to modify a offset calculated on start, since the following happened:
1786                 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
1787                 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
1788                 //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
1789                 if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
1790                         po.left += this.scrollParent.scrollLeft();
1791                         po.top += this.scrollParent.scrollTop();
1792                 }
1793
1794                 //This needs to be actually done for all browsers, since pageX/pageY includes this information
1795                 //Ugly IE fix
1796                 if((this.offsetParent[0] === document.body) ||
1797                         (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
1798                         po = { top: 0, left: 0 };
1799                 }
1800
1801                 return {
1802                         top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
1803                         left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
1804                 };
1805
1806         },
1807
1808         _getRelativeOffset: function() {
1809
1810                 if(this.cssPosition === "relative") {
1811                         var p = this.element.position();
1812                         return {
1813                                 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
1814                                 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
1815                         };
1816                 } else {
1817                         return { top: 0, left: 0 };
1818                 }
1819
1820         },
1821
1822         _cacheMargins: function() {
1823                 this.margins = {
1824                         left: (parseInt(this.element.css("marginLeft"),10) || 0),
1825                         top: (parseInt(this.element.css("marginTop"),10) || 0),
1826                         right: (parseInt(this.element.css("marginRight"),10) || 0),
1827                         bottom: (parseInt(this.element.css("marginBottom"),10) || 0)
1828                 };
1829         },
1830
1831         _cacheHelperProportions: function() {
1832                 this.helperProportions = {
1833                         width: this.helper.outerWidth(),
1834                         height: this.helper.outerHeight()
1835                 };
1836         },
1837
1838         _setContainment: function() {
1839
1840                 var over, c, ce,
1841                         o = this.options;
1842
1843                 if ( !o.containment ) {
1844                         this.containment = null;
1845                         return;
1846                 }
1847
1848                 if ( o.containment === "window" ) {
1849                         this.containment = [
1850                                 $( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
1851                                 $( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
1852                                 $( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
1853                                 $( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
1854                         ];
1855                         return;
1856                 }
1857
1858                 if ( o.containment === "document") {
1859                         this.containment = [
1860                                 0,
1861                                 0,
1862                                 $( document ).width() - this.helperProportions.width - this.margins.left,
1863                                 ( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
1864                         ];
1865                         return;
1866                 }
1867
1868                 if ( o.containment.constructor === Array ) {
1869                         this.containment = o.containment;
1870                         return;
1871                 }
1872
1873                 if ( o.containment === "parent" ) {
1874                         o.containment = this.helper[ 0 ].parentNode;
1875                 }
1876
1877                 c = $( o.containment );
1878                 ce = c[ 0 ];
1879
1880                 if( !ce ) {
1881                         return;
1882                 }
1883
1884                 over = c.css( "overflow" ) !== "hidden";
1885
1886                 this.containment = [
1887                         ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
1888                         ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ) ,
1889                         ( 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,
1890                         ( 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
1891                 ];
1892                 this.relative_container = c;
1893         },
1894
1895         _convertPositionTo: function(d, pos) {
1896
1897                 if(!pos) {
1898                         pos = this.position;
1899                 }
1900
1901                 var mod = d === "absolute" ? 1 : -1,
1902                         scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent;
1903
1904                 //Cache the scroll
1905                 if (!this.offset.scroll) {
1906                         this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
1907                 }
1908
1909                 return {
1910                         top: (
1911                                 pos.top +                                                                                                                               // The absolute mouse position
1912                                 this.offset.relative.top * mod +                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
1913                                 this.offset.parent.top * mod -                                                                          // The offsetParent's offset without borders (offset + border)
1914                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top ) * mod )
1915                         ),
1916                         left: (
1917                                 pos.left +                                                                                                                              // The absolute mouse position
1918                                 this.offset.relative.left * mod +                                                                               // Only for relative positioned nodes: Relative offset from element to offset parent
1919                                 this.offset.parent.left * mod   -                                                                               // The offsetParent's offset without borders (offset + border)
1920                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left ) * mod )
1921                         )
1922                 };
1923
1924         },
1925
1926         _generatePosition: function(event) {
1927
1928                 var containment, co, top, left,
1929                         o = this.options,
1930                         scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent,
1931                         pageX = event.pageX,
1932                         pageY = event.pageY;
1933
1934                 //Cache the scroll
1935                 if (!this.offset.scroll) {
1936                         this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
1937                 }
1938
1939                 /*
1940                  * - Position constraining -
1941                  * Constrain the position to a mix of grid, containment.
1942                  */
1943
1944                 // If we are not dragging yet, we won't check for options
1945                 if ( this.originalPosition ) {
1946                         if ( this.containment ) {
1947                                 if ( this.relative_container ){
1948                                         co = this.relative_container.offset();
1949                                         containment = [
1950                                                 this.containment[ 0 ] + co.left,
1951                                                 this.containment[ 1 ] + co.top,
1952                                                 this.containment[ 2 ] + co.left,
1953                                                 this.containment[ 3 ] + co.top
1954                                         ];
1955                                 }
1956                                 else {
1957                                         containment = this.containment;
1958                                 }
1959
1960                                 if(event.pageX - this.offset.click.left < containment[0]) {
1961                                         pageX = containment[0] + this.offset.click.left;
1962                                 }
1963                                 if(event.pageY - this.offset.click.top < containment[1]) {
1964                                         pageY = containment[1] + this.offset.click.top;
1965                                 }
1966                                 if(event.pageX - this.offset.click.left > containment[2]) {
1967                                         pageX = containment[2] + this.offset.click.left;
1968                                 }
1969                                 if(event.pageY - this.offset.click.top > containment[3]) {
1970                                         pageY = containment[3] + this.offset.click.top;
1971                                 }
1972                         }
1973
1974                         if(o.grid) {
1975                                 //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
1976                                 top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
1977                                 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;
1978
1979                                 left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
1980                                 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;
1981                         }
1982
1983                 }
1984
1985                 return {
1986                         top: (
1987                                 pageY -                                                                                                                                 // The absolute mouse position
1988                                 this.offset.click.top   -                                                                                               // Click offset (relative to the element)
1989                                 this.offset.relative.top -                                                                                              // Only for relative positioned nodes: Relative offset from element to offset parent
1990                                 this.offset.parent.top +                                                                                                // The offsetParent's offset without borders (offset + border)
1991                                 ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top )
1992                         ),
1993                         left: (
1994                                 pageX -                                                                                                                                 // The absolute mouse position
1995                                 this.offset.click.left -                                                                                                // Click offset (relative to the element)
1996                                 this.offset.relative.left -                                                                                             // Only for relative positioned nodes: Relative offset from element to offset parent
1997                                 this.offset.parent.left +                                                                                               // The offsetParent's offset without borders (offset + border)
1998                                 ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left )
1999                         )
2000                 };
2001
2002         },
2003
2004         _clear: function() {
2005                 this.helper.removeClass("ui-draggable-dragging");
2006                 if(this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
2007                         this.helper.remove();
2008                 }
2009                 this.helper = null;
2010                 this.cancelHelperRemoval = false;
2011         },
2012
2013         // From now on bulk stuff - mainly helpers
2014
2015         _trigger: function(type, event, ui) {
2016                 ui = ui || this._uiHash();
2017                 $.ui.plugin.call(this, type, [event, ui]);
2018                 //The absolute position has to be recalculated after plugins
2019                 if(type === "drag") {
2020                         this.positionAbs = this._convertPositionTo("absolute");
2021                 }
2022                 return $.Widget.prototype._trigger.call(this, type, event, ui);
2023         },
2024
2025         plugins: {},
2026
2027         _uiHash: function() {
2028                 return {
2029                         helper: this.helper,
2030                         position: this.position,
2031                         originalPosition: this.originalPosition,
2032                         offset: this.positionAbs
2033                 };
2034         }
2035
2036 });
2037
2038 $.ui.plugin.add("draggable", "connectToSortable", {
2039         start: function(event, ui) {
2040
2041                 var inst = $(this).data("ui-draggable"), o = inst.options,
2042                         uiSortable = $.extend({}, ui, { item: inst.element });
2043                 inst.sortables = [];
2044                 $(o.connectToSortable).each(function() {
2045                         var sortable = $.data(this, "ui-sortable");
2046                         if (sortable && !sortable.options.disabled) {
2047                                 inst.sortables.push({
2048                                         instance: sortable,
2049                                         shouldRevert: sortable.options.revert
2050                                 });
2051                                 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).
2052                                 sortable._trigger("activate", event, uiSortable);
2053                         }
2054                 });
2055
2056         },
2057         stop: function(event, ui) {
2058
2059                 //If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
2060                 var inst = $(this).data("ui-draggable"),
2061                         uiSortable = $.extend({}, ui, { item: inst.element });
2062
2063                 $.each(inst.sortables, function() {
2064                         if(this.instance.isOver) {
2065
2066                                 this.instance.isOver = 0;
2067
2068                                 inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
2069                                 this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
2070
2071                                 //The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: "valid/invalid"
2072                                 if(this.shouldRevert) {
2073                                         this.instance.options.revert = this.shouldRevert;
2074                                 }
2075
2076                                 //Trigger the stop of the sortable
2077                                 this.instance._mouseStop(event);
2078
2079                                 this.instance.options.helper = this.instance.options._helper;
2080
2081                                 //If the helper has been the original item, restore properties in the sortable
2082                                 if(inst.options.helper === "original") {
2083                                         this.instance.currentItem.css({ top: "auto", left: "auto" });
2084                                 }
2085
2086                         } else {
2087                                 this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
2088                                 this.instance._trigger("deactivate", event, uiSortable);
2089                         }
2090
2091                 });
2092
2093         },
2094         drag: function(event, ui) {
2095
2096                 var inst = $(this).data("ui-draggable"), that = this;
2097
2098                 $.each(inst.sortables, function() {
2099
2100                         var innermostIntersecting = false,
2101                                 thisSortable = this;
2102
2103                         //Copy over some variables to allow calling the sortable's native _intersectsWith
2104                         this.instance.positionAbs = inst.positionAbs;
2105                         this.instance.helperProportions = inst.helperProportions;
2106                         this.instance.offset.click = inst.offset.click;
2107
2108                         if(this.instance._intersectsWith(this.instance.containerCache)) {
2109                                 innermostIntersecting = true;
2110                                 $.each(inst.sortables, function () {
2111                                         this.instance.positionAbs = inst.positionAbs;
2112                                         this.instance.helperProportions = inst.helperProportions;
2113                                         this.instance.offset.click = inst.offset.click;
2114                                         if (this !== thisSortable &&
2115                                                 this.instance._intersectsWith(this.instance.containerCache) &&
2116                                                 $.contains(thisSortable.instance.element[0], this.instance.element[0])
2117                                         ) {
2118                                                 innermostIntersecting = false;
2119                                         }
2120                                         return innermostIntersecting;
2121                                 });
2122                         }
2123
2124
2125                         if(innermostIntersecting) {
2126                                 //If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
2127                                 if(!this.instance.isOver) {
2128
2129                                         this.instance.isOver = 1;
2130                                         //Now we fake the start of dragging for the sortable instance,
2131                                         //by cloning the list group item, appending it to the sortable and using it as inst.currentItem
2132                                         //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)
2133                                         this.instance.currentItem = $(that).clone().removeAttr("id").appendTo(this.instance.element).data("ui-sortable-item", true);
2134                                         this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
2135                                         this.instance.options.helper = function() { return ui.helper[0]; };
2136
2137                                         event.target = this.instance.currentItem[0];
2138                                         this.instance._mouseCapture(event, true);
2139                                         this.instance._mouseStart(event, true, true);
2140
2141                                         //Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
2142                                         this.instance.offset.click.top = inst.offset.click.top;
2143                                         this.instance.offset.click.left = inst.offset.click.left;
2144                                         this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
2145                                         this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
2146
2147                                         inst._trigger("toSortable", event);
2148                                         inst.dropped = this.instance.element; //draggable revert needs that
2149                                         //hack so receive/update callbacks work (mostly)
2150                                         inst.currentItem = inst.element;
2151                                         this.instance.fromOutside = inst;
2152
2153                                 }
2154
2155                                 //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
2156                                 if(this.instance.currentItem) {
2157                                         this.instance._mouseDrag(event);
2158                                 }
2159
2160                         } else {
2161
2162                                 //If it doesn't intersect with the sortable, and it intersected before,
2163                                 //we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
2164                                 if(this.instance.isOver) {
2165
2166                                         this.instance.isOver = 0;
2167                                         this.instance.cancelHelperRemoval = true;
2168
2169                                         //Prevent reverting on this forced stop
2170                                         this.instance.options.revert = false;
2171
2172                                         // The out event needs to be triggered independently
2173                                         this.instance._trigger("out", event, this.instance._uiHash(this.instance));
2174
2175                                         this.instance._mouseStop(event, true);
2176                                         this.instance.options.helper = this.instance.options._helper;
2177
2178                                         //Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
2179                                         this.instance.currentItem.remove();
2180                                         if(this.instance.placeholder) {
2181                                                 this.instance.placeholder.remove();
2182                                         }
2183
2184                                         inst._trigger("fromSortable", event);
2185                                         inst.dropped = false; //draggable revert needs that
2186                                 }
2187
2188                         }
2189
2190                 });
2191
2192         }
2193 });
2194
2195 $.ui.plugin.add("draggable", "cursor", {
2196         start: function() {
2197                 var t = $("body"), o = $(this).data("ui-draggable").options;
2198                 if (t.css("cursor")) {
2199                         o._cursor = t.css("cursor");
2200                 }
2201                 t.css("cursor", o.cursor);
2202         },
2203         stop: function() {
2204                 var o = $(this).data("ui-draggable").options;
2205                 if (o._cursor) {
2206                         $("body").css("cursor", o._cursor);
2207                 }
2208         }
2209 });
2210
2211 $.ui.plugin.add("draggable", "opacity", {
2212         start: function(event, ui) {
2213                 var t = $(ui.helper), o = $(this).data("ui-draggable").options;
2214                 if(t.css("opacity")) {
2215                         o._opacity = t.css("opacity");
2216                 }
2217                 t.css("opacity", o.opacity);
2218         },
2219         stop: function(event, ui) {
2220                 var o = $(this).data("ui-draggable").options;
2221                 if(o._opacity) {
2222                         $(ui.helper).css("opacity", o._opacity);
2223                 }
2224         }
2225 });
2226
2227 $.ui.plugin.add("draggable", "scroll", {
2228         start: function() {
2229                 var i = $(this).data("ui-draggable");
2230                 if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
2231                         i.overflowOffset = i.scrollParent.offset();
2232                 }
2233         },
2234         drag: function( event ) {
2235
2236                 var i = $(this).data("ui-draggable"), o = i.options, scrolled = false;
2237
2238                 if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
2239
2240                         if(!o.axis || o.axis !== "x") {
2241                                 if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
2242                                         i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
2243                                 } else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity) {
2244                                         i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
2245                                 }
2246                         }
2247
2248                         if(!o.axis || o.axis !== "y") {
2249                                 if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
2250                                         i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
2251                                 } else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity) {
2252                                         i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
2253                                 }
2254                         }
2255
2256                 } else {
2257
2258                         if(!o.axis || o.axis !== "x") {
2259                                 if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
2260                                         scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
2261                                 } else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
2262                                         scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
2263                                 }
2264                         }
2265
2266                         if(!o.axis || o.axis !== "y") {
2267                                 if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
2268                                         scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
2269                                 } else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
2270                                         scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
2271                                 }
2272                         }
2273
2274                 }
2275
2276                 if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
2277                         $.ui.ddmanager.prepareOffsets(i, event);
2278                 }
2279
2280         }
2281 });
2282
2283 $.ui.plugin.add("draggable", "snap", {
2284         start: function() {
2285
2286                 var i = $(this).data("ui-draggable"),
2287                         o = i.options;
2288
2289                 i.snapElements = [];
2290
2291                 $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
2292                         var $t = $(this),
2293                                 $o = $t.offset();
2294                         if(this !== i.element[0]) {
2295                                 i.snapElements.push({
2296                                         item: this,
2297                                         width: $t.outerWidth(), height: $t.outerHeight(),
2298                                         top: $o.top, left: $o.left
2299                                 });
2300                         }
2301                 });
2302
2303         },
2304         drag: function(event, ui) {
2305
2306                 var ts, bs, ls, rs, l, r, t, b, i, first,
2307                         inst = $(this).data("ui-draggable"),
2308                         o = inst.options,
2309                         d = o.snapTolerance,
2310                         x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
2311                         y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
2312
2313                 for (i = inst.snapElements.length - 1; i >= 0; i--){
2314
2315                         l = inst.snapElements[i].left;
2316                         r = l + inst.snapElements[i].width;
2317                         t = inst.snapElements[i].top;
2318                         b = t + inst.snapElements[i].height;
2319
2320                         if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
2321                                 if(inst.snapElements[i].snapping) {
2322                                         (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
2323                                 }
2324                                 inst.snapElements[i].snapping = false;
2325                                 continue;
2326                         }
2327
2328                         if(o.snapMode !== "inner") {
2329                                 ts = Math.abs(t - y2) <= d;
2330                                 bs = Math.abs(b - y1) <= d;
2331                                 ls = Math.abs(l - x2) <= d;
2332                                 rs = Math.abs(r - x1) <= d;
2333                                 if(ts) {
2334                                         ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
2335                                 }
2336                                 if(bs) {
2337                                         ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
2338                                 }
2339                                 if(ls) {
2340                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
2341                                 }
2342                                 if(rs) {
2343                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
2344                                 }
2345                         }
2346
2347                         first = (ts || bs || ls || rs);
2348
2349                         if(o.snapMode !== "outer") {
2350                                 ts = Math.abs(t - y1) <= d;
2351                                 bs = Math.abs(b - y2) <= d;
2352                                 ls = Math.abs(l - x1) <= d;
2353                                 rs = Math.abs(r - x2) <= d;
2354                                 if(ts) {
2355                                         ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
2356                                 }
2357                                 if(bs) {
2358                                         ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
2359                                 }
2360                                 if(ls) {
2361                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
2362                                 }
2363                                 if(rs) {
2364                                         ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
2365                                 }
2366                         }
2367
2368                         if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
2369                                 (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
2370                         }
2371                         inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
2372
2373                 }
2374
2375         }
2376 });
2377
2378 $.ui.plugin.add("draggable", "stack", {
2379         start: function() {
2380                 var min,
2381                         o = this.data("ui-draggable").options,
2382                         group = $.makeArray($(o.stack)).sort(function(a,b) {
2383                                 return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
2384                         });
2385
2386                 if (!group.length) { return; }
2387
2388                 min = parseInt($(group[0]).css("zIndex"), 10) || 0;
2389                 $(group).each(function(i) {
2390                         $(this).css("zIndex", min + i);
2391                 });
2392                 this.css("zIndex", (min + group.length));
2393         }
2394 });
2395
2396 $.ui.plugin.add("draggable", "zIndex", {
2397         start: function(event, ui) {
2398                 var t = $(ui.helper), o = $(this).data("ui-draggable").options;
2399                 if(t.css("zIndex")) {
2400                         o._zIndex = t.css("zIndex");
2401                 }
2402                 t.css("zIndex", o.zIndex);
2403         },
2404         stop: function(event, ui) {
2405                 var o = $(this).data("ui-draggable").options;
2406                 if(o._zIndex) {
2407                         $(ui.helper).css("zIndex", o._zIndex);
2408                 }
2409         }
2410 });
2411
2412 })(jQuery);
2413 (function( $, undefined ) {
2414
2415 function isOverAxis( x, reference, size ) {
2416         return ( x > reference ) && ( x < ( reference + size ) );
2417 }
2418
2419 $.widget("ui.droppable", {
2420         version: "1.10.3",
2421         widgetEventPrefix: "drop",
2422         options: {
2423                 accept: "*",
2424                 activeClass: false,
2425                 addClasses: true,
2426                 greedy: false,
2427                 hoverClass: false,
2428                 scope: "default",
2429                 tolerance: "intersect",
2430
2431                 // callbacks
2432                 activate: null,
2433                 deactivate: null,
2434                 drop: null,
2435                 out: null,
2436                 over: null
2437         },
2438         _create: function() {
2439
2440                 var o = this.options,
2441                         accept = o.accept;
2442
2443                 this.isover = false;
2444                 this.isout = true;
2445
2446                 this.accept = $.isFunction(accept) ? accept : function(d) {
2447                         return d.is(accept);
2448                 };
2449
2450                 //Store the droppable's proportions
2451                 this.proportions = { width: this.element[0].offsetWidth, height: this.element[0].offsetHeight };
2452
2453                 // Add the reference and positions to the manager
2454                 $.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
2455                 $.ui.ddmanager.droppables[o.scope].push(this);
2456
2457                 (o.addClasses && this.element.addClass("ui-droppable"));
2458
2459         },
2460
2461         _destroy: function() {
2462                 var i = 0,
2463                         drop = $.ui.ddmanager.droppables[this.options.scope];
2464
2465                 for ( ; i < drop.length; i++ ) {
2466                         if ( drop[i] === this ) {
2467                                 drop.splice(i, 1);
2468                         }
2469                 }
2470
2471                 this.element.removeClass("ui-droppable ui-droppable-disabled");
2472         },
2473
2474         _setOption: function(key, value) {
2475
2476                 if(key === "accept") {
2477                         this.accept = $.isFunction(value) ? value : function(d) {
2478                                 return d.is(value);
2479                         };
2480                 }
2481                 $.Widget.prototype._setOption.apply(this, arguments);
2482         },
2483
2484         _activate: function(event) {
2485                 var draggable = $.ui.ddmanager.current;
2486                 if(this.options.activeClass) {
2487                         this.element.addClass(this.options.activeClass);
2488                 }
2489                 if(draggable){
2490                         this._trigger("activate", event, this.ui(draggable));
2491                 }
2492         },
2493
2494         _deactivate: function(event) {
2495                 var draggable = $.ui.ddmanager.current;
2496                 if(this.options.activeClass) {
2497                         this.element.removeClass(this.options.activeClass);
2498                 }
2499                 if(draggable){
2500                         this._trigger("deactivate", event, this.ui(draggable));
2501                 }
2502         },
2503
2504         _over: function(event) {
2505
2506                 var draggable = $.ui.ddmanager.current;
2507
2508                 // Bail if draggable and droppable are same element
2509                 if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2510                         return;
2511                 }
2512
2513                 if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2514                         if(this.options.hoverClass) {
2515                                 this.element.addClass(this.options.hoverClass);
2516                         }
2517                         this._trigger("over", event, this.ui(draggable));
2518                 }
2519
2520         },
2521
2522         _out: function(event) {
2523
2524                 var draggable = $.ui.ddmanager.current;
2525
2526                 // Bail if draggable and droppable are same element
2527                 if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2528                         return;
2529                 }
2530
2531                 if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2532                         if(this.options.hoverClass) {
2533                                 this.element.removeClass(this.options.hoverClass);
2534                         }
2535                         this._trigger("out", event, this.ui(draggable));
2536                 }
2537
2538         },
2539
2540         _drop: function(event,custom) {
2541
2542                 var draggable = custom || $.ui.ddmanager.current,
2543                         childrenIntersection = false;
2544
2545                 // Bail if draggable and droppable are same element
2546                 if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2547                         return false;
2548                 }
2549
2550                 this.element.find(":data(ui-droppable)").not(".ui-draggable-dragging").each(function() {
2551                         var inst = $.data(this, "ui-droppable");
2552                         if(
2553                                 inst.options.greedy &&
2554                                 !inst.options.disabled &&
2555                                 inst.options.scope === draggable.options.scope &&
2556                                 inst.accept.call(inst.element[0], (draggable.currentItem || draggable.element)) &&
2557                                 $.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
2558                         ) { childrenIntersection = true; return false; }
2559                 });
2560                 if(childrenIntersection) {
2561                         return false;
2562                 }
2563
2564                 if(this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2565                         if(this.options.activeClass) {
2566                                 this.element.removeClass(this.options.activeClass);
2567                         }
2568                         if(this.options.hoverClass) {
2569                                 this.element.removeClass(this.options.hoverClass);
2570                         }
2571                         this._trigger("drop", event, this.ui(draggable));
2572                         return this.element;
2573                 }
2574
2575                 return false;
2576
2577         },
2578
2579         ui: function(c) {
2580                 return {
2581                         draggable: (c.currentItem || c.element),
2582                         helper: c.helper,
2583                         position: c.position,
2584                         offset: c.positionAbs
2585                 };
2586         }
2587
2588 });
2589
2590 $.ui.intersect = function(draggable, droppable, toleranceMode) {
2591
2592         if (!droppable.offset) {
2593                 return false;
2594         }
2595
2596         var draggableLeft, draggableTop,
2597                 x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
2598                 y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height,
2599                 l = droppable.offset.left, r = l + droppable.proportions.width,
2600                 t = droppable.offset.top, b = t + droppable.proportions.height;
2601
2602         switch (toleranceMode) {
2603                 case "fit":
2604                         return (l <= x1 && x2 <= r && t <= y1 && y2 <= b);
2605                 case "intersect":
2606                         return (l < x1 + (draggable.helperProportions.width / 2) && // Right Half
2607                                 x2 - (draggable.helperProportions.width / 2) < r && // Left Half
2608                                 t < y1 + (draggable.helperProportions.height / 2) && // Bottom Half
2609                                 y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
2610                 case "pointer":
2611                         draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left);
2612                         draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top);
2613                         return isOverAxis( draggableTop, t, droppable.proportions.height ) && isOverAxis( draggableLeft, l, droppable.proportions.width );
2614                 case "touch":
2615                         return (
2616                                 (y1 >= t && y1 <= b) || // Top edge touching
2617                                 (y2 >= t && y2 <= b) || // Bottom edge touching
2618                                 (y1 < t && y2 > b)              // Surrounded vertically
2619                         ) && (
2620                                 (x1 >= l && x1 <= r) || // Left edge touching
2621                                 (x2 >= l && x2 <= r) || // Right edge touching
2622                                 (x1 < l && x2 > r)              // Surrounded horizontally
2623                         );
2624                 default:
2625                         return false;
2626                 }
2627
2628 };
2629
2630 /*
2631         This manager tracks offsets of draggables and droppables
2632 */
2633 $.ui.ddmanager = {
2634         current: null,
2635         droppables: { "default": [] },
2636         prepareOffsets: function(t, event) {
2637
2638                 var i, j,
2639                         m = $.ui.ddmanager.droppables[t.options.scope] || [],
2640                         type = event ? event.type : null, // workaround for #2317
2641                         list = (t.currentItem || t.element).find(":data(ui-droppable)").addBack();
2642
2643                 droppablesLoop: for (i = 0; i < m.length; i++) {
2644
2645                         //No disabled and non-accepted
2646                         if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) {
2647                                 continue;
2648                         }
2649
2650                         // Filter out elements in the current dragged item
2651                         for (j=0; j < list.length; j++) {
2652                                 if(list[j] === m[i].element[0]) {
2653                                         m[i].proportions.height = 0;
2654                                         continue droppablesLoop;
2655                                 }
2656                         }
2657
2658                         m[i].visible = m[i].element.css("display") !== "none";
2659                         if(!m[i].visible) {
2660                                 continue;
2661                         }
2662
2663                         //Activate the droppable if used directly from draggables
2664                         if(type === "mousedown") {
2665                                 m[i]._activate.call(m[i], event);
2666                         }
2667
2668                         m[i].offset = m[i].element.offset();
2669                         m[i].proportions = { width: m[i].element[0].offsetWidth, height: m[i].element[0].offsetHeight };
2670
2671                 }
2672
2673         },
2674         drop: function(draggable, event) {
2675
2676                 var dropped = false;
2677                 // Create a copy of the droppables in case the list changes during the drop (#9116)
2678                 $.each(($.ui.ddmanager.droppables[draggable.options.scope] || []).slice(), function() {
2679
2680                         if(!this.options) {
2681                                 return;
2682                         }
2683                         if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance)) {
2684                                 dropped = this._drop.call(this, event) || dropped;
2685                         }
2686
2687                         if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2688                                 this.isout = true;
2689                                 this.isover = false;
2690                                 this._deactivate.call(this, event);
2691                         }
2692
2693                 });
2694                 return dropped;
2695
2696         },
2697         dragStart: function( draggable, event ) {
2698                 //Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
2699                 draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
2700                         if( !draggable.options.refreshPositions ) {
2701                                 $.ui.ddmanager.prepareOffsets( draggable, event );
2702                         }
2703                 });
2704         },
2705         drag: function(draggable, event) {
2706
2707                 //If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
2708                 if(draggable.options.refreshPositions) {
2709                         $.ui.ddmanager.prepareOffsets(draggable, event);
2710                 }
2711
2712                 //Run through all droppables and check their positions based on specific tolerance options
2713                 $.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
2714
2715                         if(this.options.disabled || this.greedyChild || !this.visible) {
2716                                 return;
2717                         }
2718
2719                         var parentInstance, scope, parent,
2720                                 intersects = $.ui.intersect(draggable, this, this.options.tolerance),
2721                                 c = !intersects && this.isover ? "isout" : (intersects && !this.isover ? "isover" : null);
2722                         if(!c) {
2723                                 return;
2724                         }
2725
2726                         if (this.options.greedy) {
2727                                 // find droppable parents with same scope
2728                                 scope = this.options.scope;
2729                                 parent = this.element.parents(":data(ui-droppable)").filter(function () {
2730                                         return $.data(this, "ui-droppable").options.scope === scope;
2731                                 });
2732
2733                                 if (parent.length) {
2734                                         parentInstance = $.data(parent[0], "ui-droppable");
2735                                         parentInstance.greedyChild = (c === "isover");
2736                                 }
2737                         }
2738
2739                         // we just moved into a greedy child
2740                         if (parentInstance && c === "isover") {
2741                                 parentInstance.isover = false;
2742                                 parentInstance.isout = true;
2743                                 parentInstance._out.call(parentInstance, event);
2744                         }
2745
2746                         this[c] = true;
2747                         this[c === "isout" ? "isover" : "isout"] = false;
2748                         this[c === "isover" ? "_over" : "_out"].call(this, event);
2749
2750                         // we just moved out of a greedy child
2751                         if (parentInstance && c === "isout") {
2752                                 parentInstance.isout = false;
2753                                 parentInstance.isover = true;
2754                                 parentInstance._over.call(parentInstance, event);
2755                         }
2756                 });
2757
2758         },
2759         dragStop: function( draggable, event ) {
2760                 draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
2761                 //Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
2762                 if( !draggable.options.refreshPositions ) {
2763                         $.ui.ddmanager.prepareOffsets( draggable, event );
2764                 }
2765         }
2766 };
2767
2768 })(jQuery);
2769 (function( $, undefined ) {
2770
2771 function num(v) {
2772         return parseInt(v, 10) || 0;
2773 }
2774
2775 function isNumber(value) {
2776         return !isNaN(parseInt(value, 10));
2777 }
2778
2779 $.widget("ui.resizable", $.ui.mouse, {
2780         version: "1.10.3",
2781         widgetEventPrefix: "resize",
2782         options: {
2783                 alsoResize: false,
2784                 animate: false,
2785                 animateDuration: "slow",
2786                 animateEasing: "swing",
2787                 aspectRatio: false,
2788                 autoHide: false,
2789                 containment: false,
2790                 ghost: false,
2791                 grid: false,
2792                 handles: "e,s,se",
2793                 helper: false,
2794                 maxHeight: null,
2795                 maxWidth: null,
2796                 minHeight: 10,
2797                 minWidth: 10,
2798                 // See #7960
2799                 zIndex: 90,
2800
2801                 // callbacks
2802                 resize: null,
2803                 start: null,
2804                 stop: null
2805         },
2806         _create: function() {
2807
2808                 var n, i, handle, axis, hname,
2809                         that = this,
2810                         o = this.options;
2811                 this.element.addClass("ui-resizable");
2812
2813                 $.extend(this, {
2814                         _aspectRatio: !!(o.aspectRatio),
2815                         aspectRatio: o.aspectRatio,
2816                         originalElement: this.element,
2817                         _proportionallyResizeElements: [],
2818                         _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
2819                 });
2820
2821                 //Wrap the element if it cannot hold child nodes
2822                 if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {
2823
2824                         //Create a wrapper element and set the wrapper to the new current internal element
2825                         this.element.wrap(
2826                                 $("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
2827                                         position: this.element.css("position"),
2828                                         width: this.element.outerWidth(),
2829                                         height: this.element.outerHeight(),
2830                                         top: this.element.css("top"),
2831                                         left: this.element.css("left")
2832                                 })
2833                         );
2834
2835                         //Overwrite the original this.element
2836                         this.element = this.element.parent().data(
2837                                 "ui-resizable", this.element.data("ui-resizable")
2838                         );
2839
2840                         this.elementIsWrapper = true;
2841
2842                         //Move margins to the wrapper
2843                         this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
2844                         this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
2845
2846                         //Prevent Safari textarea resize
2847                         this.originalResizeStyle = this.originalElement.css("resize");
2848                         this.originalElement.css("resize", "none");
2849
2850                         //Push the actual element to our proportionallyResize internal array
2851                         this._proportionallyResizeElements.push(this.originalElement.css({ position: "static", zoom: 1, display: "block" }));
2852
2853                         // avoid IE jump (hard set the margin)
2854                         this.originalElement.css({ margin: this.originalElement.css("margin") });
2855
2856                         // fix handlers offset
2857                         this._proportionallyResize();
2858
2859                 }
2860
2861                 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" });
2862                 if(this.handles.constructor === String) {
2863
2864                         if ( this.handles === "all") {
2865                                 this.handles = "n,e,s,w,se,sw,ne,nw";
2866                         }
2867
2868                         n = this.handles.split(",");
2869                         this.handles = {};
2870
2871                         for(i = 0; i < n.length; i++) {
2872
2873                                 handle = $.trim(n[i]);
2874                                 hname = "ui-resizable-"+handle;
2875                                 axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
2876
2877                                 // Apply zIndex to all handles - see #7960
2878                                 axis.css({ zIndex: o.zIndex });
2879
2880                                 //TODO : What's going on here?
2881                                 if ("se" === handle) {
2882                                         axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
2883                                 }
2884
2885                                 //Insert into internal handles object and append to element
2886                                 this.handles[handle] = ".ui-resizable-"+handle;
2887                                 this.element.append(axis);
2888                         }
2889
2890                 }
2891
2892                 this._renderAxis = function(target) {
2893
2894                         var i, axis, padPos, padWrapper;
2895
2896                         target = target || this.element;
2897
2898                         for(i in this.handles) {
2899
2900                                 if(this.handles[i].constructor === String) {
2901                                         this.handles[i] = $(this.handles[i], this.element).show();
2902                                 }
2903
2904                                 //Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
2905                                 if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {
2906
2907                                         axis = $(this.handles[i], this.element);
2908
2909                                         //Checking the correct pad and border
2910                                         padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
2911
2912                                         //The padding type i have to apply...
2913                                         padPos = [ "padding",
2914                                                 /ne|nw|n/.test(i) ? "Top" :
2915                                                 /se|sw|s/.test(i) ? "Bottom" :
2916                                                 /^e$/.test(i) ? "Right" : "Left" ].join("");
2917
2918                                         target.css(padPos, padWrapper);
2919
2920                                         this._proportionallyResize();
2921
2922                                 }
2923
2924                                 //TODO: What's that good for? There's not anything to be executed left
2925                                 if(!$(this.handles[i]).length) {
2926                                         continue;
2927                                 }
2928                         }
2929                 };
2930
2931                 //TODO: make renderAxis a prototype function
2932                 this._renderAxis(this.element);
2933
2934                 this._handles = $(".ui-resizable-handle", this.element)
2935                         .disableSelection();
2936
2937                 //Matching axis name
2938                 this._handles.mouseover(function() {
2939                         if (!that.resizing) {
2940                                 if (this.className) {
2941                                         axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
2942                                 }
2943                                 //Axis, default = se
2944                                 that.axis = axis && axis[1] ? axis[1] : "se";
2945                         }
2946                 });
2947
2948                 //If we want to auto hide the elements
2949                 if (o.autoHide) {
2950                         this._handles.hide();
2951                         $(this.element)
2952                                 .addClass("ui-resizable-autohide")
2953                                 .mouseenter(function() {
2954                                         if (o.disabled) {
2955                                                 return;
2956                                         }
2957                                         $(this).removeClass("ui-resizable-autohide");
2958                                         that._handles.show();
2959                                 })
2960                                 .mouseleave(function(){
2961                                         if (o.disabled) {
2962                                                 return;
2963                                         }
2964                                         if (!that.resizing) {
2965                                                 $(this).addClass("ui-resizable-autohide");
2966                                                 that._handles.hide();
2967                                         }
2968                                 });
2969                 }
2970
2971                 //Initialize the mouse interaction
2972                 this._mouseInit();
2973
2974         },
2975
2976         _destroy: function() {
2977
2978                 this._mouseDestroy();
2979
2980                 var wrapper,
2981                         _destroy = function(exp) {
2982                                 $(exp).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
2983                                         .removeData("resizable").removeData("ui-resizable").unbind(".resizable").find(".ui-resizable-handle").remove();
2984                         };
2985
2986                 //TODO: Unwrap at same DOM position
2987                 if (this.elementIsWrapper) {
2988                         _destroy(this.element);
2989                         wrapper = this.element;
2990                         this.originalElement.css({
2991                                 position: wrapper.css("position"),
2992                                 width: wrapper.outerWidth(),
2993                                 height: wrapper.outerHeight(),
2994                                 top: wrapper.css("top"),
2995                                 left: wrapper.css("left")
2996                         }).insertAfter( wrapper );
2997                         wrapper.remove();
2998                 }
2999
3000                 this.originalElement.css("resize", this.originalResizeStyle);
3001                 _destroy(this.originalElement);
3002
3003                 return this;
3004         },
3005
3006         _mouseCapture: function(event) {
3007                 var i, handle,
3008                         capture = false;
3009
3010                 for (i in this.handles) {
3011                         handle = $(this.handles[i])[0];
3012                         if (handle === event.target || $.contains(handle, event.target)) {
3013                                 capture = true;
3014                         }
3015                 }
3016
3017                 return !this.options.disabled && capture;
3018         },
3019
3020         _mouseStart: function(event) {
3021
3022                 var curleft, curtop, cursor,
3023                         o = this.options,
3024                         iniPos = this.element.position(),
3025                         el = this.element;
3026
3027                 this.resizing = true;
3028
3029                 // bugfix for http://dev.jquery.com/ticket/1749
3030                 if ( (/absolute/).test( el.css("position") ) ) {
3031                         el.css({ position: "absolute", top: el.css("top"), left: el.css("left") });
3032                 } else if (el.is(".ui-draggable")) {
3033                         el.css({ position: "absolute", top: iniPos.top, left: iniPos.left });
3034                 }
3035
3036                 this._renderProxy();
3037
3038                 curleft = num(this.helper.css("left"));
3039                 curtop = num(this.helper.css("top"));
3040
3041                 if (o.containment) {
3042                         curleft += $(o.containment).scrollLeft() || 0;
3043                         curtop += $(o.containment).scrollTop() || 0;
3044                 }
3045
3046                 //Store needed variables
3047                 this.offset = this.helper.offset();
3048                 this.position = { left: curleft, top: curtop };
3049                 this.size = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
3050                 this.originalSize = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
3051                 this.originalPosition = { left: curleft, top: curtop };
3052                 this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
3053                 this.originalMousePosition = { left: event.pageX, top: event.pageY };
3054
3055                 //Aspect Ratio
3056                 this.aspectRatio = (typeof o.aspectRatio === "number") ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);
3057
3058                 cursor = $(".ui-resizable-" + this.axis).css("cursor");
3059                 $("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
3060
3061                 el.addClass("ui-resizable-resizing");
3062                 this._propagate("start", event);
3063                 return true;
3064         },
3065
3066         _mouseDrag: function(event) {
3067
3068                 //Increase performance, avoid regex
3069                 var data,
3070                         el = this.helper, props = {},
3071                         smp = this.originalMousePosition,
3072                         a = this.axis,
3073                         prevTop = this.position.top,
3074                         prevLeft = this.position.left,
3075                         prevWidth = this.size.width,
3076                         prevHeight = this.size.height,
3077                         dx = (event.pageX-smp.left)||0,
3078                         dy = (event.pageY-smp.top)||0,
3079                         trigger = this._change[a];
3080
3081                 if (!trigger) {
3082                         return false;
3083                 }
3084
3085                 // Calculate the attrs that will be change
3086                 data = trigger.apply(this, [event, dx, dy]);
3087
3088                 // Put this in the mouseDrag handler since the user can start pressing shift while resizing
3089                 this._updateVirtualBoundaries(event.shiftKey);
3090                 if (this._aspectRatio || event.shiftKey) {
3091                         data = this._updateRatio(data, event);
3092                 }
3093
3094                 data = this._respectSize(data, event);
3095
3096                 this._updateCache(data);
3097
3098                 // plugins callbacks need to be called first
3099                 this._propagate("resize", event);
3100
3101                 if (this.position.top !== prevTop) {
3102                         props.top = this.position.top + "px";
3103                 }
3104                 if (this.position.left !== prevLeft) {
3105                         props.left = this.position.left + "px";
3106                 }
3107                 if (this.size.width !== prevWidth) {
3108                         props.width = this.size.width + "px";
3109                 }
3110                 if (this.size.height !== prevHeight) {
3111                         props.height = this.size.height + "px";
3112                 }
3113                 el.css(props);
3114
3115                 if (!this._helper && this._proportionallyResizeElements.length) {
3116                         this._proportionallyResize();
3117                 }
3118
3119                 // Call the user callback if the element was resized
3120                 if ( ! $.isEmptyObject(props) ) {
3121                         this._trigger("resize", event, this.ui());
3122                 }
3123
3124                 return false;
3125         },
3126
3127         _mouseStop: function(event) {
3128
3129                 this.resizing = false;
3130                 var pr, ista, soffseth, soffsetw, s, left, top,
3131                         o = this.options, that = this;
3132
3133                 if(this._helper) {
3134
3135                         pr = this._proportionallyResizeElements;
3136                         ista = pr.length && (/textarea/i).test(pr[0].nodeName);
3137                         soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height;
3138                         soffsetw = ista ? 0 : that.sizeDiff.width;
3139
3140                         s = { width: (that.helper.width()  - soffsetw), height: (that.helper.height() - soffseth) };
3141                         left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null;
3142                         top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
3143
3144                         if (!o.animate) {
3145                                 this.element.css($.extend(s, { top: top, left: left }));
3146                         }
3147
3148                         that.helper.height(that.size.height);
3149                         that.helper.width(that.size.width);
3150
3151                         if (this._helper && !o.animate) {
3152                                 this._proportionallyResize();
3153                         }
3154                 }
3155
3156                 $("body").css("cursor", "auto");
3157
3158                 this.element.removeClass("ui-resizable-resizing");
3159
3160                 this._propagate("stop", event);
3161
3162                 if (this._helper) {
3163                         this.helper.remove();
3164                 }
3165
3166                 return false;
3167
3168         },
3169
3170         _updateVirtualBoundaries: function(forceAspectRatio) {
3171                 var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
3172                         o = this.options;
3173
3174                 b = {
3175                         minWidth: isNumber(o.minWidth) ? o.minWidth : 0,
3176                         maxWidth: isNumber(o.maxWidth) ? o.maxWidth : Infinity,
3177                         minHeight: isNumber(o.minHeight) ? o.minHeight : 0,
3178                         maxHeight: isNumber(o.maxHeight) ? o.maxHeight : Infinity
3179                 };
3180
3181                 if(this._aspectRatio || forceAspectRatio) {
3182                         // We want to create an enclosing box whose aspect ration is the requested one
3183                         // First, compute the "projected" size for each dimension based on the aspect ratio and other dimension
3184                         pMinWidth = b.minHeight * this.aspectRatio;
3185                         pMinHeight = b.minWidth / this.aspectRatio;
3186                         pMaxWidth = b.maxHeight * this.aspectRatio;
3187                         pMaxHeight = b.maxWidth / this.aspectRatio;
3188
3189                         if(pMinWidth > b.minWidth) {
3190                                 b.minWidth = pMinWidth;
3191                         }
3192                         if(pMinHeight > b.minHeight) {
3193                                 b.minHeight = pMinHeight;
3194                         }
3195                         if(pMaxWidth < b.maxWidth) {
3196                                 b.maxWidth = pMaxWidth;
3197                         }
3198                         if(pMaxHeight < b.maxHeight) {
3199                                 b.maxHeight = pMaxHeight;
3200                         }
3201                 }
3202                 this._vBoundaries = b;
3203         },
3204
3205         _updateCache: function(data) {
3206                 this.offset = this.helper.offset();
3207                 if (isNumber(data.left)) {
3208                         this.position.left = data.left;
3209                 }
3210                 if (isNumber(data.top)) {
3211                         this.position.top = data.top;
3212                 }
3213                 if (isNumber(data.height)) {
3214                         this.size.height = data.height;
3215                 }
3216                 if (isNumber(data.width)) {
3217                         this.size.width = data.width;
3218                 }
3219         },
3220
3221         _updateRatio: function( data ) {
3222
3223                 var cpos = this.position,
3224                         csize = this.size,
3225                         a = this.axis;
3226
3227                 if (isNumber(data.height)) {
3228                         data.width = (data.height * this.aspectRatio);
3229                 } else if (isNumber(data.width)) {
3230                         data.height = (data.width / this.aspectRatio);
3231                 }
3232
3233                 if (a === "sw") {
3234                         data.left = cpos.left + (csize.width - data.width);
3235                         data.top = null;
3236                 }
3237                 if (a === "nw") {
3238                         data.top = cpos.top + (csize.height - data.height);
3239                         data.left = cpos.left + (csize.width - data.width);
3240                 }
3241
3242                 return data;
3243         },
3244
3245         _respectSize: function( data ) {
3246
3247                 var o = this._vBoundaries,
3248                         a = this.axis,
3249                         ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
3250                         isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
3251                         dw = this.originalPosition.left + this.originalSize.width,
3252                         dh = this.position.top + this.size.height,
3253                         cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
3254                 if (isminw) {
3255                         data.width = o.minWidth;
3256                 }
3257                 if (isminh) {
3258                         data.height = o.minHeight;
3259                 }
3260                 if (ismaxw) {
3261                         data.width = o.maxWidth;
3262                 }
3263                 if (ismaxh) {
3264                         data.height = o.maxHeight;
3265                 }
3266
3267                 if (isminw && cw) {
3268                         data.left = dw - o.minWidth;
3269                 }
3270                 if (ismaxw && cw) {
3271                         data.left = dw - o.maxWidth;
3272                 }
3273                 if (isminh && ch) {
3274                         data.top = dh - o.minHeight;
3275                 }
3276                 if (ismaxh && ch) {
3277                         data.top = dh - o.maxHeight;
3278                 }
3279
3280                 // fixing jump error on top/left - bug #2330
3281                 if (!data.width && !data.height && !data.left && data.top) {
3282                         data.top = null;
3283                 } else if (!data.width && !data.height && !data.top && data.left) {
3284                         data.left = null;
3285                 }
3286
3287                 return data;
3288         },
3289
3290         _proportionallyResize: function() {
3291
3292                 if (!this._proportionallyResizeElements.length) {
3293                         return;
3294                 }
3295
3296                 var i, j, borders, paddings, prel,
3297                         element = this.helper || this.element;
3298
3299                 for ( i=0; i < this._proportionallyResizeElements.length; i++) {
3300
3301                         prel = this._proportionallyResizeElements[i];
3302
3303                         if (!this.borderDif) {
3304                                 this.borderDif = [];
3305                                 borders = [prel.css("borderTopWidth"), prel.css("borderRightWidth"), prel.css("borderBottomWidth"), prel.css("borderLeftWidth")];
3306                                 paddings = [prel.css("paddingTop"), prel.css("paddingRight"), prel.css("paddingBottom"), prel.css("paddingLeft")];
3307
3308                                 for ( j = 0; j < borders.length; j++ ) {
3309                                         this.borderDif[ j ] = ( parseInt( borders[ j ], 10 ) || 0 ) + ( parseInt( paddings[ j ], 10 ) || 0 );
3310                                 }
3311                         }
3312
3313                         prel.css({
3314                                 height: (element.height() - this.borderDif[0] - this.borderDif[2]) || 0,
3315                                 width: (element.width() - this.borderDif[1] - this.borderDif[3]) || 0
3316                         });
3317
3318                 }
3319
3320         },
3321
3322         _renderProxy: function() {
3323
3324                 var el = this.element, o = this.options;
3325                 this.elementOffset = el.offset();
3326
3327                 if(this._helper) {
3328
3329                         this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
3330
3331                         this.helper.addClass(this._helper).css({
3332                                 width: this.element.outerWidth() - 1,
3333                                 height: this.element.outerHeight() - 1,
3334                                 position: "absolute",
3335                                 left: this.elementOffset.left +"px",
3336                                 top: this.elementOffset.top +"px",
3337                                 zIndex: ++o.zIndex //TODO: Don't modify option
3338                         });
3339
3340                         this.helper
3341                                 .appendTo("body")
3342                                 .disableSelection();
3343
3344                 } else {
3345                         this.helper = this.element;
3346                 }
3347
3348         },
3349
3350         _change: {
3351                 e: function(event, dx) {
3352                         return { width: this.originalSize.width + dx };
3353                 },
3354                 w: function(event, dx) {
3355                         var cs = this.originalSize, sp = this.originalPosition;
3356                         return { left: sp.left + dx, width: cs.width - dx };
3357                 },
3358                 n: function(event, dx, dy) {
3359                         var cs = this.originalSize, sp = this.originalPosition;
3360                         return { top: sp.top + dy, height: cs.height - dy };
3361                 },
3362                 s: function(event, dx, dy) {
3363                         return { height: this.originalSize.height + dy };
3364                 },
3365                 se: function(event, dx, dy) {
3366                         return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
3367                 },
3368                 sw: function(event, dx, dy) {
3369                         return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
3370                 },
3371                 ne: function(event, dx, dy) {
3372                         return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
3373                 },
3374                 nw: function(event, dx, dy) {
3375                         return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
3376                 }
3377         },
3378
3379         _propagate: function(n, event) {
3380                 $.ui.plugin.call(this, n, [event, this.ui()]);
3381                 (n !== "resize" && this._trigger(n, event, this.ui()));
3382         },
3383
3384         plugins: {},
3385
3386         ui: function() {
3387                 return {
3388                         originalElement: this.originalElement,
3389                         element: this.element,
3390                         helper: this.helper,
3391                         position: this.position,
3392                         size: this.size,
3393                         originalSize: this.originalSize,
3394                         originalPosition: this.originalPosition
3395                 };
3396         }
3397
3398 });
3399
3400 /*
3401  * Resizable Extensions
3402  */
3403
3404 $.ui.plugin.add("resizable", "animate", {
3405
3406         stop: function( event ) {
3407                 var that = $(this).data("ui-resizable"),
3408                         o = that.options,
3409                         pr = that._proportionallyResizeElements,
3410                         ista = pr.length && (/textarea/i).test(pr[0].nodeName),
3411                         soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height,
3412                         soffsetw = ista ? 0 : that.sizeDiff.width,
3413                         style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
3414                         left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null,
3415                         top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
3416
3417                 that.element.animate(
3418                         $.extend(style, top && left ? { top: top, left: left } : {}), {
3419                                 duration: o.animateDuration,
3420                                 easing: o.animateEasing,
3421                                 step: function() {
3422
3423                                         var data = {
3424                                                 width: parseInt(that.element.css("width"), 10),
3425                                                 height: parseInt(that.element.css("height"), 10),
3426                                                 top: parseInt(that.element.css("top"), 10),
3427                                                 left: parseInt(that.element.css("left"), 10)
3428                                         };
3429
3430                                         if (pr && pr.length) {
3431                                                 $(pr[0]).css({ width: data.width, height: data.height });
3432                                         }
3433
3434                                         // propagating resize, and updating values for each animation step
3435                                         that._updateCache(data);
3436                                         that._propagate("resize", event);
3437
3438                                 }
3439                         }
3440                 );
3441         }
3442
3443 });
3444
3445 $.ui.plugin.add("resizable", "containment", {
3446
3447         start: function() {
3448                 var element, p, co, ch, cw, width, height,
3449                         that = $(this).data("ui-resizable"),
3450                         o = that.options,
3451                         el = that.element,
3452                         oc = o.containment,
3453                         ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
3454
3455                 if (!ce) {
3456                         return;
3457                 }
3458
3459                 that.containerElement = $(ce);
3460
3461                 if (/document/.test(oc) || oc === document) {
3462                         that.containerOffset = { left: 0, top: 0 };
3463                         that.containerPosition = { left: 0, top: 0 };
3464
3465                         that.parentData = {
3466                                 element: $(document), left: 0, top: 0,
3467                                 width: $(document).width(), height: $(document).height() || document.body.parentNode.scrollHeight
3468                         };
3469                 }
3470
3471                 // i'm a node, so compute top, left, right, bottom
3472                 else {
3473                         element = $(ce);
3474                         p = [];
3475                         $([ "Top", "Right", "Left", "Bottom" ]).each(function(i, name) { p[i] = num(element.css("padding" + name)); });
3476
3477                         that.containerOffset = element.offset();
3478                         that.containerPosition = element.position();
3479                         that.containerSize = { height: (element.innerHeight() - p[3]), width: (element.innerWidth() - p[1]) };
3480
3481                         co = that.containerOffset;
3482                         ch = that.containerSize.height;
3483                         cw = that.containerSize.width;
3484                         width = ($.ui.hasScroll(ce, "left") ? ce.scrollWidth : cw );
3485                         height = ($.ui.hasScroll(ce) ? ce.scrollHeight : ch);
3486
3487                         that.parentData = {
3488                                 element: ce, left: co.left, top: co.top, width: width, height: height
3489                         };
3490                 }
3491         },
3492
3493         resize: function( event ) {
3494                 var woset, hoset, isParent, isOffsetRelative,
3495                         that = $(this).data("ui-resizable"),
3496                         o = that.options,
3497                         co = that.containerOffset, cp = that.position,
3498                         pRatio = that._aspectRatio || event.shiftKey,
3499                         cop = { top:0, left:0 }, ce = that.containerElement;
3500
3501                 if (ce[0] !== document && (/static/).test(ce.css("position"))) {
3502                         cop = co;
3503                 }
3504
3505                 if (cp.left < (that._helper ? co.left : 0)) {
3506                         that.size.width = that.size.width + (that._helper ? (that.position.left - co.left) : (that.position.left - cop.left));
3507                         if (pRatio) {
3508                                 that.size.height = that.size.width / that.aspectRatio;
3509                         }
3510                         that.position.left = o.helper ? co.left : 0;
3511                 }
3512
3513                 if (cp.top < (that._helper ? co.top : 0)) {
3514                         that.size.height = that.size.height + (that._helper ? (that.position.top - co.top) : that.position.top);
3515                         if (pRatio) {
3516                                 that.size.width = that.size.height * that.aspectRatio;
3517                         }
3518                         that.position.top = that._helper ? co.top : 0;
3519                 }
3520
3521                 that.offset.left = that.parentData.left+that.position.left;
3522                 that.offset.top = that.parentData.top+that.position.top;
3523
3524                 woset = Math.abs( (that._helper ? that.offset.left - cop.left : (that.offset.left - cop.left)) + that.sizeDiff.width );
3525                 hoset = Math.abs( (that._helper ? that.offset.top - cop.top : (that.offset.top - co.top)) + that.sizeDiff.height );
3526
3527                 isParent = that.containerElement.get(0) === that.element.parent().get(0);
3528                 isOffsetRelative = /relative|absolute/.test(that.containerElement.css("position"));
3529
3530                 if(isParent && isOffsetRelative) {
3531                         woset -= that.parentData.left;
3532                 }
3533
3534                 if (woset + that.size.width >= that.parentData.width) {
3535                         that.size.width = that.parentData.width - woset;
3536                         if (pRatio) {
3537                                 that.size.height = that.size.width / that.aspectRatio;
3538                         }
3539                 }
3540
3541                 if (hoset + that.size.height >= that.parentData.height) {
3542                         that.size.height = that.parentData.height - hoset;
3543                         if (pRatio) {
3544                                 that.size.width = that.size.height * that.aspectRatio;
3545                         }
3546                 }
3547         },
3548
3549         stop: function(){
3550                 var that = $(this).data("ui-resizable"),
3551                         o = that.options,
3552                         co = that.containerOffset,
3553                         cop = that.containerPosition,
3554                         ce = that.containerElement,
3555                         helper = $(that.helper),
3556                         ho = helper.offset(),
3557                         w = helper.outerWidth() - that.sizeDiff.width,
3558                         h = helper.outerHeight() - that.sizeDiff.height;
3559
3560                 if (that._helper && !o.animate && (/relative/).test(ce.css("position"))) {
3561                         $(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
3562                 }
3563
3564                 if (that._helper && !o.animate && (/static/).test(ce.css("position"))) {
3565                         $(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
3566                 }
3567
3568         }
3569 });
3570
3571 $.ui.plugin.add("resizable", "alsoResize", {
3572
3573         start: function () {
3574                 var that = $(this).data("ui-resizable"),
3575                         o = that.options,
3576                         _store = function (exp) {
3577                                 $(exp).each(function() {
3578                                         var el = $(this);
3579                                         el.data("ui-resizable-alsoresize", {
3580                                                 width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
3581                                                 left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10)
3582                                         });
3583                                 });
3584                         };
3585
3586                 if (typeof(o.alsoResize) === "object" && !o.alsoResize.parentNode) {
3587                         if (o.alsoResize.length) { o.alsoResize = o.alsoResize[0]; _store(o.alsoResize); }
3588                         else { $.each(o.alsoResize, function (exp) { _store(exp); }); }
3589                 }else{
3590                         _store(o.alsoResize);
3591                 }
3592         },
3593
3594         resize: function (event, ui) {
3595                 var that = $(this).data("ui-resizable"),
3596                         o = that.options,
3597                         os = that.originalSize,
3598                         op = that.originalPosition,
3599                         delta = {
3600                                 height: (that.size.height - os.height) || 0, width: (that.size.width - os.width) || 0,
3601                                 top: (that.position.top - op.top) || 0, left: (that.position.left - op.left) || 0
3602                         },
3603
3604                         _alsoResize = function (exp, c) {
3605                                 $(exp).each(function() {
3606                                         var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
3607                                                 css = c && c.length ? c : el.parents(ui.originalElement[0]).length ? ["width", "height"] : ["width", "height", "top", "left"];
3608
3609                                         $.each(css, function (i, prop) {
3610                                                 var sum = (start[prop]||0) + (delta[prop]||0);
3611                                                 if (sum && sum >= 0) {
3612                                                         style[prop] = sum || null;
3613                                                 }
3614                                         });
3615
3616                                         el.css(style);
3617                                 });
3618                         };
3619
3620                 if (typeof(o.alsoResize) === "object" && !o.alsoResize.nodeType) {
3621                         $.each(o.alsoResize, function (exp, c) { _alsoResize(exp, c); });
3622                 }else{
3623                         _alsoResize(o.alsoResize);
3624                 }
3625         },
3626
3627         stop: function () {
3628                 $(this).removeData("resizable-alsoresize");
3629         }
3630 });
3631
3632 $.ui.plugin.add("resizable", "ghost", {
3633
3634         start: function() {
3635
3636                 var that = $(this).data("ui-resizable"), o = that.options, cs = that.size;
3637
3638                 that.ghost = that.originalElement.clone();
3639                 that.ghost
3640                         .css({ opacity: 0.25, display: "block", position: "relative", height: cs.height, width: cs.width, margin: 0, left: 0, top: 0 })
3641                         .addClass("ui-resizable-ghost")
3642                         .addClass(typeof o.ghost === "string" ? o.ghost : "");
3643
3644                 that.ghost.appendTo(that.helper);
3645
3646         },
3647
3648         resize: function(){
3649                 var that = $(this).data("ui-resizable");
3650                 if (that.ghost) {
3651                         that.ghost.css({ position: "relative", height: that.size.height, width: that.size.width });
3652                 }
3653         },
3654
3655         stop: function() {
3656                 var that = $(this).data("ui-resizable");
3657                 if (that.ghost && that.helper) {
3658                         that.helper.get(0).removeChild(that.ghost.get(0));
3659                 }
3660         }
3661
3662 });
3663
3664 $.ui.plugin.add("resizable", "grid", {
3665
3666         resize: function() {
3667                 var that = $(this).data("ui-resizable"),
3668                         o = that.options,
3669                         cs = that.size,
3670                         os = that.originalSize,
3671                         op = that.originalPosition,
3672                         a = that.axis,
3673                         grid = typeof o.grid === "number" ? [o.grid, o.grid] : o.grid,
3674                         gridX = (grid[0]||1),
3675                         gridY = (grid[1]||1),
3676                         ox = Math.round((cs.width - os.width) / gridX) * gridX,
3677                         oy = Math.round((cs.height - os.height) / gridY) * gridY,
3678                         newWidth = os.width + ox,
3679                         newHeight = os.height + oy,
3680                         isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
3681                         isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
3682                         isMinWidth = o.minWidth && (o.minWidth > newWidth),
3683                         isMinHeight = o.minHeight && (o.minHeight > newHeight);
3684
3685                 o.grid = grid;
3686
3687                 if (isMinWidth) {
3688                         newWidth = newWidth + gridX;
3689                 }
3690                 if (isMinHeight) {
3691                         newHeight = newHeight + gridY;
3692                 }
3693                 if (isMaxWidth) {
3694                         newWidth = newWidth - gridX;
3695                 }
3696                 if (isMaxHeight) {
3697                         newHeight = newHeight - gridY;
3698                 }
3699
3700                 if (/^(se|s|e)$/.test(a)) {
3701                         that.size.width = newWidth;
3702                         that.size.height = newHeight;
3703                 } else if (/^(ne)$/.test(a)) {
3704                         that.size.width = newWidth;
3705                         that.size.height = newHeight;
3706                         that.position.top = op.top - oy;
3707                 } else if (/^(sw)$/.test(a)) {
3708                         that.size.width = newWidth;
3709                         that.size.height = newHeight;
3710                         that.position.left = op.left - ox;
3711                 } else {
3712                         that.size.width = newWidth;
3713                         that.size.height = newHeight;
3714                         that.position.top = op.top - oy;
3715                         that.position.left = op.left - ox;
3716                 }
3717         }
3718
3719 });
3720
3721 })(jQuery);
3722 (function( $, undefined ) {
3723
3724 $.widget("ui.selectable", $.ui.mouse, {
3725         version: "1.10.3",
3726         options: {
3727                 appendTo: "body",
3728                 autoRefresh: true,
3729                 distance: 0,
3730                 filter: "*",
3731                 tolerance: "touch",
3732
3733                 // callbacks
3734                 selected: null,
3735                 selecting: null,
3736                 start: null,
3737                 stop: null,
3738                 unselected: null,
3739                 unselecting: null
3740         },
3741         _create: function() {
3742                 var selectees,
3743                         that = this;
3744
3745                 this.element.addClass("ui-selectable");
3746
3747                 this.dragged = false;
3748
3749                 // cache selectee children based on filter
3750                 this.refresh = function() {
3751                         selectees = $(that.options.filter, that.element[0]);
3752                         selectees.addClass("ui-selectee");
3753                         selectees.each(function() {
3754                                 var $this = $(this),
3755                                         pos = $this.offset();
3756                                 $.data(this, "selectable-item", {
3757                                         element: this,
3758                                         $element: $this,
3759                                         left: pos.left,
3760                                         top: pos.top,
3761                                         right: pos.left + $this.outerWidth(),
3762                                         bottom: pos.top + $this.outerHeight(),
3763                                         startselected: false,
3764                                         selected: $this.hasClass("ui-selected"),
3765                                         selecting: $this.hasClass("ui-selecting"),
3766                                         unselecting: $this.hasClass("ui-unselecting")
3767                                 });
3768                         });
3769                 };
3770                 this.refresh();
3771
3772                 this.selectees = selectees.addClass("ui-selectee");
3773
3774                 this._mouseInit();
3775
3776                 this.helper = $("<div class='ui-selectable-helper'></div>");
3777         },
3778
3779         _destroy: function() {
3780                 this.selectees
3781                         .removeClass("ui-selectee")
3782                         .removeData("selectable-item");
3783                 this.element
3784                         .removeClass("ui-selectable ui-selectable-disabled");
3785                 this._mouseDestroy();
3786         },
3787
3788         _mouseStart: function(event) {
3789                 var that = this,
3790                         options = this.options;
3791
3792                 this.opos = [event.pageX, event.pageY];
3793
3794                 if (this.options.disabled) {
3795                         return;
3796                 }
3797
3798                 this.selectees = $(options.filter, this.element[0]);
3799
3800                 this._trigger("start", event);
3801
3802                 $(options.appendTo).append(this.helper);
3803                 // position helper (lasso)
3804                 this.helper.css({
3805                         "left": event.pageX,
3806                         "top": event.pageY,
3807                         "width": 0,
3808                         "height": 0
3809                 });
3810
3811                 if (options.autoRefresh) {
3812                         this.refresh();
3813                 }
3814
3815                 this.selectees.filter(".ui-selected").each(function() {
3816                         var selectee = $.data(this, "selectable-item");
3817                         selectee.startselected = true;
3818                         if (!event.metaKey && !event.ctrlKey) {
3819                                 selectee.$element.removeClass("ui-selected");
3820                                 selectee.selected = false;
3821                                 selectee.$element.addClass("ui-unselecting");
3822                                 selectee.unselecting = true;
3823                                 // selectable UNSELECTING callback
3824                                 that._trigger("unselecting", event, {
3825                                         unselecting: selectee.element
3826                                 });
3827                         }
3828                 });
3829
3830                 $(event.target).parents().addBack().each(function() {
3831                         var doSelect,
3832                                 selectee = $.data(this, "selectable-item");
3833                         if (selectee) {
3834                                 doSelect = (!event.metaKey && !event.ctrlKey) || !selectee.$element.hasClass("ui-selected");
3835                                 selectee.$element
3836                                         .removeClass(doSelect ? "ui-unselecting" : "ui-selected")
3837                                         .addClass(doSelect ? "ui-selecting" : "ui-unselecting");
3838                                 selectee.unselecting = !doSelect;
3839                                 selectee.selecting = doSelect;
3840                                 selectee.selected = doSelect;
3841                                 // selectable (UN)SELECTING callback
3842                                 if (doSelect) {
3843                                         that._trigger("selecting", event, {
3844                                                 selecting: selectee.element
3845                                         });
3846                                 } else {
3847                                         that._trigger("unselecting", event, {
3848                                                 unselecting: selectee.element
3849                                         });
3850                                 }
3851                                 return false;
3852                         }
3853                 });
3854
3855         },
3856
3857         _mouseDrag: function(event) {
3858
3859                 this.dragged = true;
3860
3861                 if (this.options.disabled) {
3862                         return;
3863                 }
3864
3865                 var tmp,
3866                         that = this,
3867                         options = this.options,
3868                         x1 = this.opos[0],
3869                         y1 = this.opos[1],
3870                         x2 = event.pageX,
3871                         y2 = event.pageY;
3872
3873                 if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
3874                 if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
3875                 this.helper.css({left: x1, top: y1, width: x2-x1, height: y2-y1});
3876
3877                 this.selectees.each(function() {
3878                         var selectee = $.data(this, "selectable-item"),
3879                                 hit = false;
3880
3881                         //prevent helper from being selected if appendTo: selectable
3882                         if (!selectee || selectee.element === that.element[0]) {
3883                                 return;
3884                         }
3885
3886                         if (options.tolerance === "touch") {
3887                                 hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
3888                         } else if (options.tolerance === "fit") {
3889                                 hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
3890                         }
3891
3892                         if (hit) {
3893                                 // SELECT
3894                                 if (selectee.selected) {
3895                                         selectee.$element.removeClass("ui-selected");
3896                                         selectee.selected = false;
3897                                 }
3898                                 if (selectee.unselecting) {
3899                                         selectee.$element.removeClass("ui-unselecting");
3900                                         selectee.unselecting = false;
3901                                 }
3902                                 if (!selectee.selecting) {
3903                                         selectee.$element.addClass("ui-selecting");
3904                                         selectee.selecting = true;
3905                                         // selectable SELECTING callback
3906                                         that._trigger("selecting", event, {
3907                                                 selecting: selectee.element
3908                                         });
3909                                 }
3910                         } else {
3911                                 // UNSELECT
3912                                 if (selectee.selecting) {
3913                                         if ((event.metaKey || event.ctrlKey) && selectee.startselected) {
3914                                                 selectee.$element.removeClass("ui-selecting");
3915                                                 selectee.selecting = false;
3916                                                 selectee.$element.addClass("ui-selected");
3917                                                 selectee.selected = true;
3918                                         } else {
3919                                                 selectee.$element.removeClass("ui-selecting");
3920                                                 selectee.selecting = false;
3921                                                 if (selectee.startselected) {
3922                                                         selectee.$element.addClass("ui-unselecting");
3923                                                         selectee.unselecting = true;
3924                                                 }
3925                                                 // selectable UNSELECTING callback
3926                                                 that._trigger("unselecting", event, {
3927                                                         unselecting: selectee.element
3928                                                 });
3929                                         }
3930                                 }
3931                                 if (selectee.selected) {
3932                                         if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
3933                                                 selectee.$element.removeClass("ui-selected");
3934                                                 selectee.selected = false;
3935
3936                                                 selectee.$element.addClass("ui-unselecting");
3937                                                 selectee.unselecting = true;
3938                                                 // selectable UNSELECTING callback
3939                                                 that._trigger("unselecting", event, {
3940                                                         unselecting: selectee.element
3941                                                 });
3942                                         }
3943                                 }
3944                         }
3945                 });
3946
3947                 return false;
3948         },
3949
3950         _mouseStop: function(event) {
3951                 var that = this;
3952
3953                 this.dragged = false;
3954
3955                 $(".ui-unselecting", this.element[0]).each(function() {
3956                         var selectee = $.data(this, "selectable-item");
3957                         selectee.$element.removeClass("ui-unselecting");
3958                         selectee.unselecting = false;
3959                         selectee.startselected = false;
3960                         that._trigger("unselected", event, {
3961                                 unselected: selectee.element
3962                         });
3963                 });
3964                 $(".ui-selecting", this.element[0]).each(function() {
3965                         var selectee = $.data(this, "selectable-item");
3966                         selectee.$element.removeClass("ui-selecting").addClass("ui-selected");
3967                         selectee.selecting = false;
3968                         selectee.selected = true;
3969                         selectee.startselected = true;
3970                         that._trigger("selected", event, {
3971                                 selected: selectee.element
3972                         });
3973                 });
3974                 this._trigger("stop", event);
3975
3976                 this.helper.remove();
3977
3978                 return false;
3979         }
3980
3981 });
3982
3983 })(jQuery);
3984 (function( $, undefined ) {
3985
3986 /*jshint loopfunc: true */
3987
3988 function isOverAxis( x, reference, size ) {
3989         return ( x > reference ) && ( x < ( reference + size ) );
3990 }
3991
3992 function isFloating(item) {
3993         return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
3994 }
3995
3996 $.widget("ui.sortable", $.ui.mouse, {
3997         version: "1.10.3",
3998         widgetEventPrefix: "sort",
3999         ready: false,
4000         options: {
4001                 appendTo: "parent",
4002                 axis: false,
4003                 connectWith: false,
4004                 containment: false,
4005                 cursor: "auto",
4006                 cursorAt: false,
4007                 dropOnEmpty: true,
4008                 forcePlaceholderSize: false,
4009                 forceHelperSize: false,
4010                 grid: false,
4011                 handle: false,
4012                 helper: "original",
4013                 items: "> *",
4014                 opacity: false,
4015                 placeholder: false,
4016                 revert: false,
4017                 scroll: true,
4018                 scrollSensitivity: 20,
4019                 scrollSpeed: 20,
4020                 scope: "default",
4021                 tolerance: "intersect",
4022                 zIndex: 1000,
4023
4024                 // callbacks
4025                 activate: null,
4026                 beforeStop: null,
4027                 change: null,
4028                 deactivate: null,
4029                 out: null,
4030                 over: null,
4031                 receive: null,
4032                 remove: null,
4033                 sort: null,
4034                 start: null,
4035                 stop: null,
4036                 update: null
4037         },
4038         _create: function() {
4039
4040                 var o = this.options;
4041                 this.containerCache = {};
4042                 this.element.addClass("ui-sortable");
4043
4044                 //Get the items
4045                 this.refresh();
4046
4047                 //Let's determine if the items are being displayed horizontally
4048                 this.floating = this.items.length ? o.axis === "x" || isFloating(this.items[0].item) : false;
4049
4050                 //Let's determine the parent's offset
4051                 this.offset = this.element.offset();
4052
4053                 //Initialize mouse events for interaction
4054                 this._mouseInit();
4055
4056                 //We're ready to go
4057                 this.ready = true;
4058
4059         },
4060
4061         _destroy: function() {
4062                 this.element
4063                         .removeClass("ui-sortable ui-sortable-disabled");
4064                 this._mouseDestroy();
4065
4066                 for ( var i = this.items.length - 1; i >= 0; i-- ) {
4067                         this.items[i].item.removeData(this.widgetName + "-item");
4068                 }
4069
4070                 return this;
4071         },
4072
4073         _setOption: function(key, value){
4074                 if ( key === "disabled" ) {
4075                         this.options[ key ] = value;
4076
4077                         this.widget().toggleClass( "ui-sortable-disabled", !!value );
4078                 } else {
4079                         // Don't call widget base _setOption for disable as it adds ui-state-disabled class
4080                         $.Widget.prototype._setOption.apply(this, arguments);
4081                 }
4082         },
4083
4084         _mouseCapture: function(event, overrideHandle) {
4085                 var currentItem = null,
4086                         validHandle = false,
4087                         that = this;
4088
4089                 if (this.reverting) {
4090                         return false;
4091                 }
4092
4093                 if(this.options.disabled || this.options.type === "static") {
4094                         return false;
4095                 }
4096
4097                 //We have to refresh the items data once first
4098                 this._refreshItems(event);
4099
4100                 //Find out if the clicked node (or one of its parents) is a actual item in this.items
4101                 $(event.target).parents().each(function() {
4102                         if($.data(this, that.widgetName + "-item") === that) {
4103                                 currentItem = $(this);
4104                                 return false;
4105                         }
4106                 });
4107                 if($.data(event.target, that.widgetName + "-item") === that) {
4108                         currentItem = $(event.target);
4109                 }
4110
4111                 if(!currentItem) {
4112                         return false;
4113                 }
4114                 if(this.options.handle && !overrideHandle) {
4115                         $(this.options.handle, currentItem).find("*").addBack().each(function() {
4116                                 if(this === event.target) {
4117                                         validHandle = true;
4118                                 }
4119                         });
4120                         if(!validHandle) {
4121                                 return false;
4122                         }
4123                 }
4124
4125                 this.currentItem = currentItem;
4126                 this._removeCurrentsFromItems();
4127                 return true;
4128
4129         },
4130
4131         _mouseStart: function(event, overrideHandle, noActivation) {
4132
4133                 var i, body,
4134                         o = this.options;
4135
4136                 this.currentContainer = this;
4137
4138                 //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
4139                 this.refreshPositions();
4140
4141                 //Create and append the visible helper
4142                 this.helper = this._createHelper(event);
4143
4144                 //Cache the helper size
4145                 this._cacheHelperProportions();
4146
4147                 /*
4148                  * - Position generation -
4149                  * This block generates everything position related - it's the core of draggables.
4150                  */
4151
4152                 //Cache the margins of the original element
4153                 this._cacheMargins();
4154
4155                 //Get the next scrolling parent
4156                 this.scrollParent = this.helper.scrollParent();
4157
4158                 //The element's absolute position on the page minus margins
4159                 this.offset = this.currentItem.offset();
4160                 this.offset = {
4161                         top: this.offset.top - this.margins.top,
4162                         left: this.offset.left - this.margins.left
4163                 };
4164
4165                 $.extend(this.offset, {
4166                         click: { //Where the click happened, relative to the element
4167                                 left: event.pageX - this.offset.left,
4168                                 top: event.pageY - this.offset.top
4169                         },
4170                         parent: this._getParentOffset(),
4171                         relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
4172                 });
4173
4174                 // Only after we got the offset, we can change the helper's position to absolute
4175                 // TODO: Still need to figure out a way to make relative sorting possible
4176                 this.helper.css("position", "absolute");
4177                 this.cssPosition = this.helper.css("position");
4178
4179                 //Generate the original position
4180                 this.originalPosition = this._generatePosition(event);
4181                 this.originalPageX = event.pageX;
4182                 this.originalPageY = event.pageY;
4183
4184                 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
4185                 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
4186
4187                 //Cache the former DOM position
4188                 this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
4189
4190                 //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
4191                 if(this.helper[0] !== this.currentItem[0]) {
4192                         this.currentItem.hide();
4193                 }
4194
4195                 //Create the placeholder
4196                 this._createPlaceholder();
4197
4198                 //Set a containment if given in the options
4199                 if(o.containment) {
4200                         this._setContainment();
4201                 }
4202
4203                 if( o.cursor && o.cursor !== "auto" ) { // cursor option
4204                         body = this.document.find( "body" );
4205
4206                         // support: IE
4207                         this.storedCursor = body.css( "cursor" );
4208                         body.css( "cursor", o.cursor );
4209
4210                         this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
4211                 }
4212
4213                 if(o.opacity) { // opacity option
4214                         if (this.helper.css("opacity")) {
4215                                 this._storedOpacity = this.helper.css("opacity");
4216                         }
4217                         this.helper.css("opacity", o.opacity);
4218                 }
4219
4220                 if(o.zIndex) { // zIndex option
4221                         if (this.helper.css("zIndex")) {
4222                                 this._storedZIndex = this.helper.css("zIndex");
4223                         }
4224                         this.helper.css("zIndex", o.zIndex);
4225                 }
4226
4227                 //Prepare scrolling
4228                 if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
4229                         this.overflowOffset = this.scrollParent.offset();
4230                 }
4231
4232                 //Call callbacks
4233                 this._trigger("start", event, this._uiHash());
4234
4235                 //Recache the helper size
4236                 if(!this._preserveHelperProportions) {
4237                         this._cacheHelperProportions();
4238                 }
4239
4240
4241                 //Post "activate" events to possible containers
4242                 if( !noActivation ) {
4243                         for ( i = this.containers.length - 1; i >= 0; i-- ) {
4244                                 this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
4245                         }
4246                 }
4247
4248                 //Prepare possible droppables
4249                 if($.ui.ddmanager) {
4250                         $.ui.ddmanager.current = this;
4251                 }
4252
4253                 if ($.ui.ddmanager && !o.dropBehaviour) {
4254                         $.ui.ddmanager.prepareOffsets(this, event);
4255                 }
4256
4257                 this.dragging = true;
4258
4259                 this.helper.addClass("ui-sortable-helper");
4260                 this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
4261                 return true;
4262
4263         },
4264
4265         _mouseDrag: function(event) {
4266                 var i, item, itemElement, intersection,
4267                         o = this.options,
4268                         scrolled = false;
4269
4270                 //Compute the helpers position
4271                 this.position = this._generatePosition(event);
4272                 this.positionAbs = this._convertPositionTo("absolute");
4273
4274                 if (!this.lastPositionAbs) {
4275                         this.lastPositionAbs = this.positionAbs;
4276                 }
4277
4278                 //Do scrolling
4279                 if(this.options.scroll) {
4280                         if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
4281
4282                                 if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
4283                                         this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
4284                                 } else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
4285                                         this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
4286                                 }
4287
4288                                 if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
4289                                         this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
4290                                 } else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
4291                                         this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
4292                                 }
4293
4294                         } else {
4295
4296                                 if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
4297                                         scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
4298                                 } else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
4299                                         scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
4300                                 }
4301
4302                                 if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
4303                                         scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
4304                                 } else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
4305                                         scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
4306                                 }
4307
4308                         }
4309
4310                         if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
4311                                 $.ui.ddmanager.prepareOffsets(this, event);
4312                         }
4313                 }
4314
4315                 //Regenerate the absolute position used for position checks
4316                 this.positionAbs = this._convertPositionTo("absolute");
4317
4318                 //Set the helper position
4319                 if(!this.options.axis || this.options.axis !== "y") {
4320                         this.helper[0].style.left = this.position.left+"px";
4321                 }
4322                 if(!this.options.axis || this.options.axis !== "x") {
4323                         this.helper[0].style.top = this.position.top+"px";
4324                 }
4325
4326                 //Rearrange
4327                 for (i = this.items.length - 1; i >= 0; i--) {
4328
4329                         //Cache variables and intersection, continue if no intersection
4330                         item = this.items[i];
4331                         itemElement = item.item[0];
4332                         intersection = this._intersectsWithPointer(item);
4333                         if (!intersection) {
4334                                 continue;
4335                         }
4336
4337                         // Only put the placeholder inside the current Container, skip all
4338                         // items form other containers. This works because when moving
4339                         // an item from one container to another the
4340                         // currentContainer is switched before the placeholder is moved.
4341                         //
4342                         // Without this moving items in "sub-sortables" can cause the placeholder to jitter
4343                         // beetween the outer and inner container.
4344                         if (item.instance !== this.currentContainer) {
4345                                 continue;
4346                         }
4347
4348                         // cannot intersect with itself
4349                         // no useless actions that have been done before
4350                         // no action if the item moved is the parent of the item checked
4351                         if (itemElement !== this.currentItem[0] &&
4352                                 this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
4353                                 !$.contains(this.placeholder[0], itemElement) &&
4354                                 (this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
4355                         ) {
4356
4357                                 this.direction = intersection === 1 ? "down" : "up";
4358
4359                                 if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
4360                                         this._rearrange(event, item);
4361                                 } else {
4362                                         break;
4363                                 }
4364
4365                                 this._trigger("change", event, this._uiHash());
4366                                 break;
4367                         }
4368                 }
4369
4370                 //Post events to containers
4371                 this._contactContainers(event);
4372
4373                 //Interconnect with droppables
4374                 if($.ui.ddmanager) {
4375                         $.ui.ddmanager.drag(this, event);
4376                 }
4377
4378                 //Call callbacks
4379                 this._trigger("sort", event, this._uiHash());
4380
4381                 this.lastPositionAbs = this.positionAbs;
4382                 return false;
4383
4384         },
4385
4386         _mouseStop: function(event, noPropagation) {
4387
4388                 if(!event) {
4389                         return;
4390                 }
4391
4392                 //If we are using droppables, inform the manager about the drop
4393                 if ($.ui.ddmanager && !this.options.dropBehaviour) {
4394                         $.ui.ddmanager.drop(this, event);
4395                 }
4396
4397                 if(this.options.revert) {
4398                         var that = this,
4399                                 cur = this.placeholder.offset(),
4400                                 axis = this.options.axis,
4401                                 animation = {};
4402
4403                         if ( !axis || axis === "x" ) {
4404                                 animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollLeft);
4405                         }
4406                         if ( !axis || axis === "y" ) {
4407                                 animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollTop);
4408                         }
4409                         this.reverting = true;
4410                         $(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
4411                                 that._clear(event);
4412                         });
4413                 } else {
4414                         this._clear(event, noPropagation);
4415                 }
4416
4417                 return false;
4418
4419         },
4420
4421         cancel: function() {
4422
4423                 if(this.dragging) {
4424
4425                         this._mouseUp({ target: null });
4426
4427                         if(this.options.helper === "original") {
4428                                 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
4429                         } else {
4430                                 this.currentItem.show();
4431                         }
4432
4433                         //Post deactivating events to containers
4434                         for (var i = this.containers.length - 1; i >= 0; i--){
4435                                 this.containers[i]._trigger("deactivate", null, this._uiHash(this));
4436                                 if(this.containers[i].containerCache.over) {
4437                                         this.containers[i]._trigger("out", null, this._uiHash(this));
4438                                         this.containers[i].containerCache.over = 0;
4439                                 }
4440                         }
4441
4442                 }
4443
4444                 if (this.placeholder) {
4445                         //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
4446                         if(this.placeholder[0].parentNode) {
4447                                 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
4448                         }
4449                         if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
4450                                 this.helper.remove();
4451                         }
4452
4453                         $.extend(this, {
4454                                 helper: null,
4455                                 dragging: false,
4456                                 reverting: false,
4457                                 _noFinalSort: null
4458                         });
4459
4460                         if(this.domPosition.prev) {
4461                                 $(this.domPosition.prev).after(this.currentItem);
4462                         } else {
4463                                 $(this.domPosition.parent).prepend(this.currentItem);
4464                         }
4465                 }
4466
4467                 return this;
4468
4469         },
4470
4471         serialize: function(o) {
4472
4473                 var items = this._getItemsAsjQuery(o && o.connected),
4474                         str = [];
4475                 o = o || {};
4476
4477                 $(items).each(function() {
4478                         var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
4479                         if (res) {
4480                                 str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
4481                         }
4482                 });
4483
4484                 if(!str.length && o.key) {
4485                         str.push(o.key + "=");
4486                 }
4487
4488                 return str.join("&");
4489
4490         },
4491
4492         toArray: function(o) {
4493
4494                 var items = this._getItemsAsjQuery(o && o.connected),
4495                         ret = [];
4496
4497                 o = o || {};
4498
4499                 items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
4500                 return ret;
4501
4502         },
4503
4504         /* Be careful with the following core functions */
4505         _intersectsWith: function(item) {
4506
4507                 var x1 = this.positionAbs.left,
4508                         x2 = x1 + this.helperProportions.width,
4509                         y1 = this.positionAbs.top,
4510                         y2 = y1 + this.helperProportions.height,
4511                         l = item.left,
4512                         r = l + item.width,
4513                         t = item.top,
4514                         b = t + item.height,
4515                         dyClick = this.offset.click.top,
4516                         dxClick = this.offset.click.left,
4517                         isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
4518                         isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
4519                         isOverElement = isOverElementHeight && isOverElementWidth;
4520
4521                 if ( this.options.tolerance === "pointer" ||
4522                         this.options.forcePointerForContainers ||
4523                         (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
4524                 ) {
4525                         return isOverElement;
4526                 } else {
4527
4528                         return (l < x1 + (this.helperProportions.width / 2) && // Right Half
4529                                 x2 - (this.helperProportions.width / 2) < r && // Left Half
4530                                 t < y1 + (this.helperProportions.height / 2) && // Bottom Half
4531                                 y2 - (this.helperProportions.height / 2) < b ); // Top Half
4532
4533                 }
4534         },
4535
4536         _intersectsWithPointer: function(item) {
4537
4538                 var isOverElementHeight = (this.options.axis === "x") || isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
4539                         isOverElementWidth = (this.options.axis === "y") || isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
4540                         isOverElement = isOverElementHeight && isOverElementWidth,
4541                         verticalDirection = this._getDragVerticalDirection(),
4542                         horizontalDirection = this._getDragHorizontalDirection();
4543
4544                 if (!isOverElement) {
4545                         return false;
4546                 }
4547
4548                 return this.floating ?
4549                         ( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
4550                         : ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
4551
4552         },
4553
4554         _intersectsWithSides: function(item) {
4555
4556                 var isOverBottomHalf = isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
4557                         isOverRightHalf = isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
4558                         verticalDirection = this._getDragVerticalDirection(),
4559                         horizontalDirection = this._getDragHorizontalDirection();
4560
4561                 if (this.floating && horizontalDirection) {
4562                         return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
4563                 } else {
4564                         return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
4565                 }
4566
4567         },
4568
4569         _getDragVerticalDirection: function() {
4570                 var delta = this.positionAbs.top - this.lastPositionAbs.top;
4571                 return delta !== 0 && (delta > 0 ? "down" : "up");
4572         },
4573
4574         _getDragHorizontalDirection: function() {
4575                 var delta = this.positionAbs.left - this.lastPositionAbs.left;
4576                 return delta !== 0 && (delta > 0 ? "right" : "left");
4577         },
4578
4579         refresh: function(event) {
4580                 this._refreshItems(event);
4581                 this.refreshPositions();
4582                 return this;
4583         },
4584
4585         _connectWith: function() {
4586                 var options = this.options;
4587                 return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
4588         },
4589
4590         _getItemsAsjQuery: function(connected) {
4591
4592                 var i, j, cur, inst,
4593                         items = [],
4594                         queries = [],
4595                         connectWith = this._connectWith();
4596
4597                 if(connectWith && connected) {
4598                         for (i = connectWith.length - 1; i >= 0; i--){
4599                                 cur = $(connectWith[i]);
4600                                 for ( j = cur.length - 1; j >= 0; j--){
4601                                         inst = $.data(cur[j], this.widgetFullName);
4602                                         if(inst && inst !== this && !inst.options.disabled) {
4603                                                 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]);
4604                                         }
4605                                 }
4606                         }
4607                 }
4608
4609                 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]);
4610
4611                 for (i = queries.length - 1; i >= 0; i--){
4612                         queries[i][0].each(function() {
4613                                 items.push(this);
4614                         });
4615                 }
4616
4617                 return $(items);
4618
4619         },
4620
4621         _removeCurrentsFromItems: function() {
4622
4623                 var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
4624
4625                 this.items = $.grep(this.items, function (item) {
4626                         for (var j=0; j < list.length; j++) {
4627                                 if(list[j] === item.item[0]) {
4628                                         return false;
4629                                 }
4630                         }
4631                         return true;
4632                 });
4633
4634         },
4635
4636         _refreshItems: function(event) {
4637
4638                 this.items = [];
4639                 this.containers = [this];
4640
4641                 var i, j, cur, inst, targetData, _queries, item, queriesLength,
4642                         items = this.items,
4643                         queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
4644                         connectWith = this._connectWith();
4645
4646                 if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
4647                         for (i = connectWith.length - 1; i >= 0; i--){
4648                                 cur = $(connectWith[i]);
4649                                 for (j = cur.length - 1; j >= 0; j--){
4650                                         inst = $.data(cur[j], this.widgetFullName);
4651                                         if(inst && inst !== this && !inst.options.disabled) {
4652                                                 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
4653                                                 this.containers.push(inst);
4654                                         }
4655                                 }
4656                         }
4657                 }
4658
4659                 for (i = queries.length - 1; i >= 0; i--) {
4660                         targetData = queries[i][1];
4661                         _queries = queries[i][0];
4662
4663                         for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
4664                                 item = $(_queries[j]);
4665
4666                                 item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
4667
4668                                 items.push({
4669                                         item: item,
4670                                         instance: targetData,
4671                                         width: 0, height: 0,
4672                                         left: 0, top: 0
4673                                 });
4674                         }
4675                 }
4676
4677         },
4678
4679         refreshPositions: function(fast) {
4680
4681                 //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
4682                 if(this.offsetParent && this.helper) {
4683                         this.offset.parent = this._getParentOffset();
4684                 }
4685
4686                 var i, item, t, p;
4687
4688                 for (i = this.items.length - 1; i >= 0; i--){
4689                         item = this.items[i];
4690
4691                         //We ignore calculating positions of all connected containers when we're not over them
4692                         if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
4693                                 continue;
4694                         }
4695
4696                         t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
4697
4698                         if (!fast) {
4699                                 item.width = t.outerWidth();
4700                                 item.height = t.outerHeight();
4701                         }
4702
4703                         p = t.offset();
4704                         item.left = p.left;
4705                         item.top = p.top;
4706                 }
4707
4708                 if(this.options.custom && this.options.custom.refreshContainers) {
4709                         this.options.custom.refreshContainers.call(this);
4710                 } else {
4711                         for (i = this.containers.length - 1; i >= 0; i--){
4712                                 p = this.containers[i].element.offset();
4713                                 this.containers[i].containerCache.left = p.left;
4714                                 this.containers[i].containerCache.top = p.top;
4715                                 this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
4716                                 this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
4717                         }
4718                 }
4719
4720                 return this;
4721         },
4722
4723         _createPlaceholder: function(that) {
4724                 that = that || this;
4725                 var className,
4726                         o = that.options;
4727
4728                 if(!o.placeholder || o.placeholder.constructor === String) {
4729                         className = o.placeholder;
4730                         o.placeholder = {
4731                                 element: function() {
4732
4733                                         var nodeName = that.currentItem[0].nodeName.toLowerCase(),
4734                                                 element = $( "<" + nodeName + ">", that.document[0] )
4735                                                         .addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
4736                                                         .removeClass("ui-sortable-helper");
4737
4738                                         if ( nodeName === "tr" ) {
4739                                                 that.currentItem.children().each(function() {
4740                                                         $( "<td>&#160;</td>", that.document[0] )
4741                                                                 .attr( "colspan", $( this ).attr( "colspan" ) || 1 )
4742                                                                 .appendTo( element );
4743                                                 });
4744                                         } else if ( nodeName === "img" ) {
4745                                                 element.attr( "src", that.currentItem.attr( "src" ) );
4746                                         }
4747
4748                                         if ( !className ) {
4749                                                 element.css( "visibility", "hidden" );
4750                                         }
4751
4752                                         return element;
4753                                 },
4754                                 update: function(container, p) {
4755
4756                                         // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
4757                                         // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
4758                                         if(className && !o.forcePlaceholderSize) {
4759                                                 return;
4760                                         }
4761
4762                                         //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
4763                                         if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
4764                                         if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
4765                                 }
4766                         };
4767                 }
4768
4769                 //Create the placeholder
4770                 that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
4771
4772                 //Append it after the actual current item
4773                 that.currentItem.after(that.placeholder);
4774
4775                 //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
4776                 o.placeholder.update(that, that.placeholder);
4777
4778         },
4779
4780         _contactContainers: function(event) {
4781                 var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, base, cur, nearBottom, floating,
4782                         innermostContainer = null,
4783                         innermostIndex = null;
4784
4785                 // get innermost container that intersects with item
4786                 for (i = this.containers.length - 1; i >= 0; i--) {
4787
4788                         // never consider a container that's located within the item itself
4789                         if($.contains(this.currentItem[0], this.containers[i].element[0])) {
4790                                 continue;
4791                         }
4792
4793                         if(this._intersectsWith(this.containers[i].containerCache)) {
4794
4795                                 // if we've already found a container and it's more "inner" than this, then continue
4796                                 if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
4797                                         continue;
4798                                 }
4799
4800                                 innermostContainer = this.containers[i];
4801                                 innermostIndex = i;
4802
4803                         } else {
4804                                 // container doesn't intersect. trigger "out" event if necessary
4805                                 if(this.containers[i].containerCache.over) {
4806                                         this.containers[i]._trigger("out", event, this._uiHash(this));
4807                                         this.containers[i].containerCache.over = 0;
4808                                 }
4809                         }
4810
4811                 }
4812
4813                 // if no intersecting containers found, return
4814                 if(!innermostContainer) {
4815                         return;
4816                 }
4817
4818                 // move the item into the container if it's not there already
4819                 if(this.containers.length === 1) {
4820                         if (!this.containers[innermostIndex].containerCache.over) {
4821                                 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
4822                                 this.containers[innermostIndex].containerCache.over = 1;
4823                         }
4824                 } else {
4825
4826                         //When entering a new container, we will find the item with the least distance and append our item near it
4827                         dist = 10000;
4828                         itemWithLeastDistance = null;
4829                         floating = innermostContainer.floating || isFloating(this.currentItem);
4830                         posProperty = floating ? "left" : "top";
4831                         sizeProperty = floating ? "width" : "height";
4832                         base = this.positionAbs[posProperty] + this.offset.click[posProperty];
4833                         for (j = this.items.length - 1; j >= 0; j--) {
4834                                 if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
4835                                         continue;
4836                                 }
4837                                 if(this.items[j].item[0] === this.currentItem[0]) {
4838                                         continue;
4839                                 }
4840                                 if (floating && !isOverAxis(this.positionAbs.top + this.offset.click.top, this.items[j].top, this.items[j].height)) {
4841                                         continue;
4842                                 }
4843                                 cur = this.items[j].item.offset()[posProperty];
4844                                 nearBottom = false;
4845                                 if(Math.abs(cur - base) > Math.abs(cur + this.items[j][sizeProperty] - base)){
4846                                         nearBottom = true;
4847                                         cur += this.items[j][sizeProperty];
4848                                 }
4849
4850                                 if(Math.abs(cur - base) < dist) {
4851                                         dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
4852                                         this.direction = nearBottom ? "up": "down";
4853                                 }
4854                         }
4855
4856                         //Check if dropOnEmpty is enabled
4857                         if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
4858                                 return;
4859                         }
4860
4861                         if(this.currentContainer === this.containers[innermostIndex]) {
4862                                 return;
4863                         }
4864
4865                         itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
4866                         this._trigger("change", event, this._uiHash());
4867                         this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
4868                         this.currentContainer = this.containers[innermostIndex];
4869
4870                         //Update the placeholder
4871                         this.options.placeholder.update(this.currentContainer, this.placeholder);
4872
4873                         this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
4874                         this.containers[innermostIndex].containerCache.over = 1;
4875                 }
4876
4877
4878         },
4879
4880         _createHelper: function(event) {
4881
4882                 var o = this.options,
4883                         helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
4884
4885                 //Add the helper to the DOM if that didn't happen already
4886                 if(!helper.parents("body").length) {
4887                         $(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
4888                 }
4889
4890                 if(helper[0] === this.currentItem[0]) {
4891                         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") };
4892                 }
4893
4894                 if(!helper[0].style.width || o.forceHelperSize) {
4895                         helper.width(this.currentItem.width());
4896                 }
4897                 if(!helper[0].style.height || o.forceHelperSize) {
4898                         helper.height(this.currentItem.height());
4899                 }
4900
4901                 return helper;
4902
4903         },
4904
4905         _adjustOffsetFromHelper: function(obj) {
4906                 if (typeof obj === "string") {
4907                         obj = obj.split(" ");
4908                 }
4909                 if ($.isArray(obj)) {
4910                         obj = {left: +obj[0], top: +obj[1] || 0};
4911                 }
4912                 if ("left" in obj) {
4913                         this.offset.click.left = obj.left + this.margins.left;
4914                 }
4915                 if ("right" in obj) {
4916                         this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
4917                 }
4918                 if ("top" in obj) {
4919                         this.offset.click.top = obj.top + this.margins.top;
4920                 }
4921                 if ("bottom" in obj) {
4922                         this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
4923                 }
4924         },
4925
4926         _getParentOffset: function() {
4927
4928
4929                 //Get the offsetParent and cache its position
4930                 this.offsetParent = this.helper.offsetParent();
4931                 var po = this.offsetParent.offset();
4932
4933                 // This is a special case where we need to modify a offset calculated on start, since the following happened:
4934                 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
4935                 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
4936                 //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
4937                 if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
4938                         po.left += this.scrollParent.scrollLeft();
4939                         po.top += this.scrollParent.scrollTop();
4940                 }
4941
4942                 // This needs to be actually done for all browsers, since pageX/pageY includes this information
4943                 // with an ugly IE fix
4944                 if( this.offsetParent[0] === document.body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
4945                         po = { top: 0, left: 0 };
4946                 }
4947
4948                 return {
4949                         top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
4950                         left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
4951                 };
4952
4953         },
4954
4955         _getRelativeOffset: function() {
4956
4957                 if(this.cssPosition === "relative") {
4958                         var p = this.currentItem.position();
4959                         return {
4960                                 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
4961                                 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
4962                         };
4963                 } else {
4964                         return { top: 0, left: 0 };
4965                 }
4966
4967         },
4968
4969         _cacheMargins: function() {
4970                 this.margins = {
4971                         left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
4972                         top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
4973                 };
4974         },
4975
4976         _cacheHelperProportions: function() {
4977                 this.helperProportions = {
4978                         width: this.helper.outerWidth(),
4979                         height: this.helper.outerHeight()
4980                 };
4981         },
4982
4983         _setContainment: function() {
4984
4985                 var ce, co, over,
4986                         o = this.options;
4987                 if(o.containment === "parent") {
4988                         o.containment = this.helper[0].parentNode;
4989                 }
4990                 if(o.containment === "document" || o.containment === "window") {
4991                         this.containment = [
4992                                 0 - this.offset.relative.left - this.offset.parent.left,
4993                                 0 - this.offset.relative.top - this.offset.parent.top,
4994                                 $(o.containment === "document" ? document : window).width() - this.helperProportions.width - this.margins.left,
4995                                 ($(o.containment === "document" ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
4996                         ];
4997                 }
4998
4999                 if(!(/^(document|window|parent)$/).test(o.containment)) {
5000                         ce = $(o.containment)[0];
5001                         co = $(o.containment).offset();
5002                         over = ($(ce).css("overflow") !== "hidden");
5003
5004                         this.containment = [
5005                                 co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
5006                                 co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
5007                                 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,
5008                                 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
5009                         ];
5010                 }
5011
5012         },
5013
5014         _convertPositionTo: function(d, pos) {
5015
5016                 if(!pos) {
5017                         pos = this.position;
5018                 }
5019                 var mod = d === "absolute" ? 1 : -1,
5020                         scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
5021                         scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
5022
5023                 return {
5024                         top: (
5025                                 pos.top +                                                                                                                               // The absolute mouse position
5026                                 this.offset.relative.top * mod +                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
5027                                 this.offset.parent.top * mod -                                                                                  // The offsetParent's offset without borders (offset + border)
5028                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
5029                         ),
5030                         left: (
5031                                 pos.left +                                                                                                                              // The absolute mouse position
5032                                 this.offset.relative.left * mod +                                                                               // Only for relative positioned nodes: Relative offset from element to offset parent
5033                                 this.offset.parent.left * mod   -                                                                               // The offsetParent's offset without borders (offset + border)
5034                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
5035                         )
5036                 };
5037
5038         },
5039
5040         _generatePosition: function(event) {
5041
5042                 var top, left,
5043                         o = this.options,
5044                         pageX = event.pageX,
5045                         pageY = event.pageY,
5046                         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);
5047
5048                 // This is another very weird special case that only happens for relative elements:
5049                 // 1. If the css position is relative
5050                 // 2. and the scroll parent is the document or similar to the offset parent
5051                 // we have to refresh the relative offset during the scroll so there are no jumps
5052                 if(this.cssPosition === "relative" && !(this.scrollParent[0] !== document && this.scrollParent[0] !== this.offsetParent[0])) {
5053                         this.offset.relative = this._getRelativeOffset();
5054                 }
5055
5056                 /*
5057                  * - Position constraining -
5058                  * Constrain the position to a mix of grid, containment.
5059                  */
5060
5061                 if(this.originalPosition) { //If we are not dragging yet, we won't check for options
5062
5063                         if(this.containment) {
5064                                 if(event.pageX - this.offset.click.left < this.containment[0]) {
5065                                         pageX = this.containment[0] + this.offset.click.left;
5066                                 }
5067                                 if(event.pageY - this.offset.click.top < this.containment[1]) {
5068                                         pageY = this.containment[1] + this.offset.click.top;
5069                                 }
5070                                 if(event.pageX - this.offset.click.left > this.containment[2]) {
5071                                         pageX = this.containment[2] + this.offset.click.left;
5072                                 }
5073                                 if(event.pageY - this.offset.click.top > this.containment[3]) {
5074                                         pageY = this.containment[3] + this.offset.click.top;
5075                                 }
5076                         }
5077
5078                         if(o.grid) {
5079                                 top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
5080                                 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;
5081
5082                                 left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
5083                                 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;
5084                         }
5085
5086                 }
5087
5088                 return {
5089                         top: (
5090                                 pageY -                                                                                                                         // The absolute mouse position
5091                                 this.offset.click.top -                                                                                                 // Click offset (relative to the element)
5092                                 this.offset.relative.top        -                                                                                       // Only for relative positioned nodes: Relative offset from element to offset parent
5093                                 this.offset.parent.top +                                                                                                // The offsetParent's offset without borders (offset + border)
5094                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
5095                         ),
5096                         left: (
5097                                 pageX -                                                                                                                         // The absolute mouse position
5098                                 this.offset.click.left -                                                                                                // Click offset (relative to the element)
5099                                 this.offset.relative.left       -                                                                                       // Only for relative positioned nodes: Relative offset from element to offset parent
5100                                 this.offset.parent.left +                                                                                               // The offsetParent's offset without borders (offset + border)
5101                                 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
5102                         )
5103                 };
5104
5105         },
5106
5107         _rearrange: function(event, i, a, hardRefresh) {
5108
5109                 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));
5110
5111                 //Various things done here to improve the performance:
5112                 // 1. we create a setTimeout, that calls refreshPositions
5113                 // 2. on the instance, we have a counter variable, that get's higher after every append
5114                 // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
5115                 // 4. this lets only the last addition to the timeout stack through
5116                 this.counter = this.counter ? ++this.counter : 1;
5117                 var counter = this.counter;
5118
5119                 this._delay(function() {
5120                         if(counter === this.counter) {
5121                                 this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
5122                         }
5123                 });
5124
5125         },
5126
5127         _clear: function(event, noPropagation) {
5128
5129                 this.reverting = false;
5130                 // We delay all events that have to be triggered to after the point where the placeholder has been removed and
5131                 // everything else normalized again
5132                 var i,
5133                         delayedTriggers = [];
5134
5135                 // We first have to update the dom position of the actual currentItem
5136                 // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
5137                 if(!this._noFinalSort && this.currentItem.parent().length) {
5138                         this.placeholder.before(this.currentItem);
5139                 }
5140                 this._noFinalSort = null;
5141
5142                 if(this.helper[0] === this.currentItem[0]) {
5143                         for(i in this._storedCSS) {
5144                                 if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
5145                                         this._storedCSS[i] = "";
5146                                 }
5147                         }
5148                         this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
5149                 } else {
5150                         this.currentItem.show();
5151                 }
5152
5153                 if(this.fromOutside && !noPropagation) {
5154                         delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
5155                 }
5156                 if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
5157                         delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
5158                 }
5159
5160                 // Check if the items Container has Changed and trigger appropriate
5161                 // events.
5162                 if (this !== this.currentContainer) {
5163                         if(!noPropagation) {
5164                                 delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
5165                                 delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); };  }).call(this, this.currentContainer));
5166                                 delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this));  }; }).call(this, this.currentContainer));
5167                         }
5168                 }
5169
5170
5171                 //Post events to containers
5172                 for (i = this.containers.length - 1; i >= 0; i--){
5173                         if(!noPropagation) {
5174                                 delayedTriggers.push((function(c) { return function(event) { c._trigger("deactivate", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
5175                         }
5176                         if(this.containers[i].containerCache.over) {
5177                                 delayedTriggers.push((function(c) { return function(event) { c._trigger("out", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
5178                                 this.containers[i].containerCache.over = 0;
5179                         }
5180                 }
5181
5182                 //Do what was originally in plugins
5183                 if ( this.storedCursor ) {
5184                         this.document.find( "body" ).css( "cursor", this.storedCursor );
5185                         this.storedStylesheet.remove();
5186                 }
5187                 if(this._storedOpacity) {
5188                         this.helper.css("opacity", this._storedOpacity);
5189                 }
5190                 if(this._storedZIndex) {
5191                         this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
5192                 }
5193
5194                 this.dragging = false;
5195                 if(this.cancelHelperRemoval) {
5196                         if(!noPropagation) {
5197                                 this._trigger("beforeStop", event, this._uiHash());
5198                                 for (i=0; i < delayedTriggers.length; i++) {
5199                                         delayedTriggers[i].call(this, event);
5200                                 } //Trigger all delayed events
5201                                 this._trigger("stop", event, this._uiHash());
5202                         }
5203
5204                         this.fromOutside = false;
5205                         return false;
5206                 }
5207
5208                 if(!noPropagation) {
5209                         this._trigger("beforeStop", event, this._uiHash());
5210                 }
5211
5212                 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
5213                 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
5214
5215                 if(this.helper[0] !== this.currentItem[0]) {
5216                         this.helper.remove();
5217                 }
5218                 this.helper = null;
5219
5220                 if(!noPropagation) {
5221                         for (i=0; i < delayedTriggers.length; i++) {
5222                                 delayedTriggers[i].call(this, event);
5223                         } //Trigger all delayed events
5224                         this._trigger("stop", event, this._uiHash());
5225                 }
5226
5227                 this.fromOutside = false;
5228                 return true;
5229
5230         },
5231
5232         _trigger: function() {
5233                 if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
5234                         this.cancel();
5235                 }
5236         },
5237
5238         _uiHash: function(_inst) {
5239                 var inst = _inst || this;
5240                 return {
5241                         helper: inst.helper,
5242                         placeholder: inst.placeholder || $([]),
5243                         position: inst.position,
5244                         originalPosition: inst.originalPosition,
5245                         offset: inst.positionAbs,
5246                         item: inst.currentItem,
5247                         sender: _inst ? _inst.element : null
5248                 };
5249         }
5250
5251 });
5252
5253 })(jQuery);
5254 (function( $, undefined ) {
5255
5256 var uid = 0,
5257         hideProps = {},
5258         showProps = {};
5259
5260 hideProps.height = hideProps.paddingTop = hideProps.paddingBottom =
5261         hideProps.borderTopWidth = hideProps.borderBottomWidth = "hide";
5262 showProps.height = showProps.paddingTop = showProps.paddingBottom =
5263         showProps.borderTopWidth = showProps.borderBottomWidth = "show";
5264
5265 $.widget( "ui.accordion", {
5266         version: "1.10.3",
5267         options: {
5268                 active: 0,
5269                 animate: {},
5270                 collapsible: false,
5271                 event: "click",
5272                 header: "> li > :first-child,> :not(li):even",
5273                 heightStyle: "auto",
5274                 icons: {
5275                         activeHeader: "ui-icon-triangle-1-s",
5276                         header: "ui-icon-triangle-1-e"
5277                 },
5278
5279                 // callbacks
5280                 activate: null,
5281                 beforeActivate: null
5282         },
5283
5284         _create: function() {
5285                 var options = this.options;
5286                 this.prevShow = this.prevHide = $();
5287                 this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
5288                         // ARIA
5289                         .attr( "role", "tablist" );
5290
5291                 // don't allow collapsible: false and active: false / null
5292                 if ( !options.collapsible && (options.active === false || options.active == null) ) {
5293                         options.active = 0;
5294                 }
5295
5296                 this._processPanels();
5297                 // handle negative values
5298                 if ( options.active < 0 ) {
5299                         options.active += this.headers.length;
5300                 }
5301                 this._refresh();
5302         },
5303
5304         _getCreateEventData: function() {
5305                 return {
5306                         header: this.active,
5307                         panel: !this.active.length ? $() : this.active.next(),
5308                         content: !this.active.length ? $() : this.active.next()
5309                 };
5310         },
5311
5312         _createIcons: function() {
5313                 var icons = this.options.icons;
5314                 if ( icons ) {
5315                         $( "<span>" )
5316                                 .addClass( "ui-accordion-header-icon ui-icon " + icons.header )
5317                                 .prependTo( this.headers );
5318                         this.active.children( ".ui-accordion-header-icon" )
5319                                 .removeClass( icons.header )
5320                                 .addClass( icons.activeHeader );
5321                         this.headers.addClass( "ui-accordion-icons" );
5322                 }
5323         },
5324
5325         _destroyIcons: function() {
5326                 this.headers
5327                         .removeClass( "ui-accordion-icons" )
5328                         .children( ".ui-accordion-header-icon" )
5329                                 .remove();
5330         },
5331
5332         _destroy: function() {
5333                 var contents;
5334
5335                 // clean up main element
5336                 this.element
5337                         .removeClass( "ui-accordion ui-widget ui-helper-reset" )
5338                         .removeAttr( "role" );
5339
5340                 // clean up headers
5341                 this.headers
5342                         .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" )
5343                         .removeAttr( "role" )
5344                         .removeAttr( "aria-selected" )
5345                         .removeAttr( "aria-controls" )
5346                         .removeAttr( "tabIndex" )
5347                         .each(function() {
5348                                 if ( /^ui-accordion/.test( this.id ) ) {
5349                                         this.removeAttribute( "id" );
5350                                 }
5351                         });
5352                 this._destroyIcons();
5353
5354                 // clean up content panels
5355                 contents = this.headers.next()
5356                         .css( "display", "" )
5357                         .removeAttr( "role" )
5358                         .removeAttr( "aria-expanded" )
5359                         .removeAttr( "aria-hidden" )
5360                         .removeAttr( "aria-labelledby" )
5361                         .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active ui-state-disabled" )
5362                         .each(function() {
5363                                 if ( /^ui-accordion/.test( this.id ) ) {
5364                                         this.removeAttribute( "id" );
5365                                 }
5366                         });
5367                 if ( this.options.heightStyle !== "content" ) {
5368                         contents.css( "height", "" );
5369                 }
5370         },
5371
5372         _setOption: function( key, value ) {
5373                 if ( key === "active" ) {
5374                         // _activate() will handle invalid values and update this.options
5375                         this._activate( value );
5376                         return;
5377                 }
5378
5379                 if ( key === "event" ) {
5380                         if ( this.options.event ) {
5381                                 this._off( this.headers, this.options.event );
5382                         }
5383                         this._setupEvents( value );
5384                 }
5385
5386                 this._super( key, value );
5387
5388                 // setting collapsible: false while collapsed; open first panel
5389                 if ( key === "collapsible" && !value && this.options.active === false ) {
5390                         this._activate( 0 );
5391                 }
5392
5393                 if ( key === "icons" ) {
5394                         this._destroyIcons();
5395                         if ( value ) {
5396                                 this._createIcons();
5397                         }
5398                 }
5399
5400                 // #5332 - opacity doesn't cascade to positioned elements in IE
5401                 // so we need to add the disabled class to the headers and panels
5402                 if ( key === "disabled" ) {
5403                         this.headers.add( this.headers.next() )
5404                                 .toggleClass( "ui-state-disabled", !!value );
5405                 }
5406         },
5407
5408         _keydown: function( event ) {
5409                 /*jshint maxcomplexity:15*/
5410                 if ( event.altKey || event.ctrlKey ) {
5411                         return;
5412                 }
5413
5414                 var keyCode = $.ui.keyCode,
5415                         length = this.headers.length,
5416                         currentIndex = this.headers.index( event.target ),
5417                         toFocus = false;
5418
5419                 switch ( event.keyCode ) {
5420                         case keyCode.RIGHT:
5421                         case keyCode.DOWN:
5422                                 toFocus = this.headers[ ( currentIndex + 1 ) % length ];
5423                                 break;
5424                         case keyCode.LEFT:
5425                         case keyCode.UP:
5426                                 toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
5427                                 break;
5428                         case keyCode.SPACE:
5429                         case keyCode.ENTER:
5430                                 this._eventHandler( event );
5431                                 break;
5432                         case keyCode.HOME:
5433                                 toFocus = this.headers[ 0 ];
5434                                 break;
5435                         case keyCode.END:
5436                                 toFocus = this.headers[ length - 1 ];
5437                                 break;
5438                 }
5439
5440                 if ( toFocus ) {
5441                         $( event.target ).attr( "tabIndex", -1 );
5442                         $( toFocus ).attr( "tabIndex", 0 );
5443                         toFocus.focus();
5444                         event.preventDefault();
5445                 }
5446         },
5447
5448         _panelKeyDown : function( event ) {
5449                 if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
5450                         $( event.currentTarget ).prev().focus();
5451                 }
5452         },
5453
5454         refresh: function() {
5455                 var options = this.options;
5456                 this._processPanels();
5457
5458                 // was collapsed or no panel
5459                 if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
5460                         options.active = false;
5461                         this.active = $();
5462                 // active false only when collapsible is true
5463                 } else if ( options.active === false ) {
5464                         this._activate( 0 );
5465                 // was active, but active panel is gone
5466                 } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
5467                         // all remaining panel are disabled
5468                         if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
5469                                 options.active = false;
5470                                 this.active = $();
5471                         // activate previous panel
5472                         } else {
5473                                 this._activate( Math.max( 0, options.active - 1 ) );
5474                         }
5475                 // was active, active panel still exists
5476                 } else {
5477                         // make sure active index is correct
5478                         options.active = this.headers.index( this.active );
5479                 }
5480
5481                 this._destroyIcons();
5482
5483                 this._refresh();
5484         },
5485
5486         _processPanels: function() {
5487                 this.headers = this.element.find( this.options.header )
5488                         .addClass( "ui-accordion-header ui-helper-reset ui-state-default ui-corner-all" );
5489
5490                 this.headers.next()
5491                         .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
5492                         .filter(":not(.ui-accordion-content-active)")
5493                         .hide();
5494         },
5495
5496         _refresh: function() {
5497                 var maxHeight,
5498                         options = this.options,
5499                         heightStyle = options.heightStyle,
5500                         parent = this.element.parent(),
5501                         accordionId = this.accordionId = "ui-accordion-" +
5502                                 (this.element.attr( "id" ) || ++uid);
5503
5504                 this.active = this._findActive( options.active )
5505                         .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
5506                         .removeClass( "ui-corner-all" );
5507                 this.active.next()
5508                         .addClass( "ui-accordion-content-active" )
5509                         .show();
5510
5511                 this.headers
5512                         .attr( "role", "tab" )
5513                         .each(function( i ) {
5514                                 var header = $( this ),
5515                                         headerId = header.attr( "id" ),
5516                                         panel = header.next(),
5517                                         panelId = panel.attr( "id" );
5518                                 if ( !headerId ) {
5519                                         headerId = accordionId + "-header-" + i;
5520                                         header.attr( "id", headerId );
5521                                 }
5522                                 if ( !panelId ) {
5523                                         panelId = accordionId + "-panel-" + i;
5524                                         panel.attr( "id", panelId );
5525                                 }
5526                                 header.attr( "aria-controls", panelId );
5527                                 panel.attr( "aria-labelledby", headerId );
5528                         })
5529                         .next()
5530                                 .attr( "role", "tabpanel" );
5531
5532                 this.headers
5533                         .not( this.active )
5534                         .attr({
5535                                 "aria-selected": "false",
5536                                 tabIndex: -1
5537                         })
5538                         .next()
5539                                 .attr({
5540                                         "aria-expanded": "false",
5541                                         "aria-hidden": "true"
5542                                 })
5543                                 .hide();
5544
5545                 // make sure at least one header is in the tab order
5546                 if ( !this.active.length ) {
5547                         this.headers.eq( 0 ).attr( "tabIndex", 0 );
5548                 } else {
5549                         this.active.attr({
5550                                 "aria-selected": "true",
5551                                 tabIndex: 0
5552                         })
5553                         .next()
5554                                 .attr({
5555                                         "aria-expanded": "true",
5556                                         "aria-hidden": "false"
5557                                 });
5558                 }
5559
5560                 this._createIcons();
5561
5562                 this._setupEvents( options.event );
5563
5564                 if ( heightStyle === "fill" ) {
5565                         maxHeight = parent.height();
5566                         this.element.siblings( ":visible" ).each(function() {
5567                                 var elem = $( this ),
5568                                         position = elem.css( "position" );
5569
5570                                 if ( position === "absolute" || position === "fixed" ) {
5571                                         return;
5572                                 }
5573                                 maxHeight -= elem.outerHeight( true );
5574                         });
5575
5576                         this.headers.each(function() {
5577                                 maxHeight -= $( this ).outerHeight( true );
5578                         });
5579
5580                         this.headers.next()
5581                                 .each(function() {
5582                                         $( this ).height( Math.max( 0, maxHeight -
5583                                                 $( this ).innerHeight() + $( this ).height() ) );
5584                                 })
5585                                 .css( "overflow", "auto" );
5586                 } else if ( heightStyle === "auto" ) {
5587                         maxHeight = 0;
5588                         this.headers.next()
5589                                 .each(function() {
5590                                         maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
5591                                 })
5592                                 .height( maxHeight );
5593                 }
5594         },
5595
5596         _activate: function( index ) {
5597                 var active = this._findActive( index )[ 0 ];
5598
5599                 // trying to activate the already active panel
5600                 if ( active === this.active[ 0 ] ) {
5601                         return;
5602                 }
5603
5604                 // trying to collapse, simulate a click on the currently active header
5605                 active = active || this.active[ 0 ];
5606
5607                 this._eventHandler({
5608                         target: active,
5609                         currentTarget: active,
5610                         preventDefault: $.noop
5611                 });
5612         },
5613
5614         _findActive: function( selector ) {
5615                 return typeof selector === "number" ? this.headers.eq( selector ) : $();
5616         },
5617
5618         _setupEvents: function( event ) {
5619                 var events = {
5620                         keydown: "_keydown"
5621                 };
5622                 if ( event ) {
5623                         $.each( event.split(" "), function( index, eventName ) {
5624                                 events[ eventName ] = "_eventHandler";
5625                         });
5626                 }
5627
5628                 this._off( this.headers.add( this.headers.next() ) );
5629                 this._on( this.headers, events );
5630                 this._on( this.headers.next(), { keydown: "_panelKeyDown" });
5631                 this._hoverable( this.headers );
5632                 this._focusable( this.headers );
5633         },
5634
5635         _eventHandler: function( event ) {
5636                 var options = this.options,
5637                         active = this.active,
5638                         clicked = $( event.currentTarget ),
5639                         clickedIsActive = clicked[ 0 ] === active[ 0 ],
5640                         collapsing = clickedIsActive && options.collapsible,
5641                         toShow = collapsing ? $() : clicked.next(),
5642                         toHide = active.next(),
5643                         eventData = {
5644                                 oldHeader: active,
5645                                 oldPanel: toHide,
5646                                 newHeader: collapsing ? $() : clicked,
5647                                 newPanel: toShow
5648                         };
5649
5650                 event.preventDefault();
5651
5652                 if (
5653                                 // click on active header, but not collapsible
5654                                 ( clickedIsActive && !options.collapsible ) ||
5655                                 // allow canceling activation
5656                                 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
5657                         return;
5658                 }
5659
5660                 options.active = collapsing ? false : this.headers.index( clicked );
5661
5662                 // when the call to ._toggle() comes after the class changes
5663                 // it causes a very odd bug in IE 8 (see #6720)
5664                 this.active = clickedIsActive ? $() : clicked;
5665                 this._toggle( eventData );
5666
5667                 // switch classes
5668                 // corner classes on the previously active header stay after the animation
5669                 active.removeClass( "ui-accordion-header-active ui-state-active" );
5670                 if ( options.icons ) {
5671                         active.children( ".ui-accordion-header-icon" )
5672                                 .removeClass( options.icons.activeHeader )
5673                                 .addClass( options.icons.header );
5674                 }
5675
5676                 if ( !clickedIsActive ) {
5677                         clicked
5678                                 .removeClass( "ui-corner-all" )
5679                                 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
5680                         if ( options.icons ) {
5681                                 clicked.children( ".ui-accordion-header-icon" )
5682                                         .removeClass( options.icons.header )
5683                                         .addClass( options.icons.activeHeader );
5684                         }
5685
5686                         clicked
5687                                 .next()
5688                                 .addClass( "ui-accordion-content-active" );
5689                 }
5690         },
5691
5692         _toggle: function( data ) {
5693                 var toShow = data.newPanel,
5694                         toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
5695
5696                 // handle activating a panel during the animation for another activation
5697                 this.prevShow.add( this.prevHide ).stop( true, true );
5698                 this.prevShow = toShow;
5699                 this.prevHide = toHide;
5700
5701                 if ( this.options.animate ) {
5702                         this._animate( toShow, toHide, data );
5703                 } else {
5704                         toHide.hide();
5705                         toShow.show();
5706                         this._toggleComplete( data );
5707                 }
5708
5709                 toHide.attr({
5710                         "aria-expanded": "false",
5711                         "aria-hidden": "true"
5712                 });
5713                 toHide.prev().attr( "aria-selected", "false" );
5714                 // if we're switching panels, remove the old header from the tab order
5715                 // if we're opening from collapsed state, remove the previous header from the tab order
5716                 // if we're collapsing, then keep the collapsing header in the tab order
5717                 if ( toShow.length && toHide.length ) {
5718                         toHide.prev().attr( "tabIndex", -1 );
5719                 } else if ( toShow.length ) {
5720                         this.headers.filter(function() {
5721                                 return $( this ).attr( "tabIndex" ) === 0;
5722                         })
5723                         .attr( "tabIndex", -1 );
5724                 }
5725
5726                 toShow
5727                         .attr({
5728                                 "aria-expanded": "true",
5729                                 "aria-hidden": "false"
5730                         })
5731                         .prev()
5732                                 .attr({
5733                                         "aria-selected": "true",
5734                                         tabIndex: 0
5735                                 });
5736         },
5737
5738         _animate: function( toShow, toHide, data ) {
5739                 var total, easing, duration,
5740                         that = this,
5741                         adjust = 0,
5742                         down = toShow.length &&
5743                                 ( !toHide.length || ( toShow.index() < toHide.index() ) ),
5744                         animate = this.options.animate || {},
5745                         options = down && animate.down || animate,
5746                         complete = function() {
5747                                 that._toggleComplete( data );
5748                         };
5749
5750                 if ( typeof options === "number" ) {
5751                         duration = options;
5752                 }
5753                 if ( typeof options === "string" ) {
5754                         easing = options;
5755                 }
5756                 // fall back from options to animation in case of partial down settings
5757                 easing = easing || options.easing || animate.easing;
5758                 duration = duration || options.duration || animate.duration;
5759
5760                 if ( !toHide.length ) {
5761                         return toShow.animate( showProps, duration, easing, complete );
5762                 }
5763                 if ( !toShow.length ) {
5764                         return toHide.animate( hideProps, duration, easing, complete );
5765                 }
5766
5767                 total = toShow.show().outerHeight();
5768                 toHide.animate( hideProps, {
5769                         duration: duration,
5770                         easing: easing,
5771                         step: function( now, fx ) {
5772                                 fx.now = Math.round( now );
5773                         }
5774                 });
5775                 toShow
5776                         .hide()
5777                         .animate( showProps, {
5778                                 duration: duration,
5779                                 easing: easing,
5780                                 complete: complete,
5781                                 step: function( now, fx ) {
5782                                         fx.now = Math.round( now );
5783                                         if ( fx.prop !== "height" ) {
5784                                                 adjust += fx.now;
5785                                         } else if ( that.options.heightStyle !== "content" ) {
5786                                                 fx.now = Math.round( total - toHide.outerHeight() - adjust );
5787                                                 adjust = 0;
5788                                         }
5789                                 }
5790                         });
5791         },
5792
5793         _toggleComplete: function( data ) {
5794                 var toHide = data.oldPanel;
5795
5796                 toHide
5797                         .removeClass( "ui-accordion-content-active" )
5798                         .prev()
5799                                 .removeClass( "ui-corner-top" )
5800                                 .addClass( "ui-corner-all" );
5801
5802                 // Work around for rendering bug in IE (#5421)
5803                 if ( toHide.length ) {
5804                         toHide.parent()[0].className = toHide.parent()[0].className;
5805                 }
5806
5807                 this._trigger( "activate", null, data );
5808         }
5809 });
5810
5811 })( jQuery );
5812 (function( $, undefined ) {
5813
5814 // used to prevent race conditions with remote data sources
5815 var requestIndex = 0;
5816
5817 $.widget( "ui.autocomplete", {
5818         version: "1.10.3",
5819         defaultElement: "<input>",
5820         options: {
5821                 appendTo: null,
5822                 autoFocus: false,
5823                 delay: 300,
5824                 minLength: 1,
5825                 position: {
5826                         my: "left top",
5827                         at: "left bottom",
5828                         collision: "none"
5829                 },
5830                 source: null,
5831
5832                 // callbacks
5833                 change: null,
5834                 close: null,
5835                 focus: null,
5836                 open: null,
5837                 response: null,
5838                 search: null,
5839                 select: null
5840         },
5841
5842         pending: 0,
5843
5844         _create: function() {
5845                 // Some browsers only repeat keydown events, not keypress events,
5846                 // so we use the suppressKeyPress flag to determine if we've already
5847                 // handled the keydown event. #7269
5848                 // Unfortunately the code for & in keypress is the same as the up arrow,
5849                 // so we use the suppressKeyPressRepeat flag to avoid handling keypress
5850                 // events when we know the keydown event was used to modify the
5851                 // search term. #7799
5852                 var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
5853                         nodeName = this.element[0].nodeName.toLowerCase(),
5854                         isTextarea = nodeName === "textarea",
5855                         isInput = nodeName === "input";
5856
5857                 this.isMultiLine =
5858                         // Textareas are always multi-line
5859                         isTextarea ? true :
5860                         // Inputs are always single-line, even if inside a contentEditable element
5861                         // IE also treats inputs as contentEditable
5862                         isInput ? false :
5863                         // All other element types are determined by whether or not they're contentEditable
5864                         this.element.prop( "isContentEditable" );
5865
5866                 this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
5867                 this.isNewMenu = true;
5868
5869                 this.element
5870                         .addClass( "ui-autocomplete-input" )
5871                         .attr( "autocomplete", "off" );
5872
5873                 this._on( this.element, {
5874                         keydown: function( event ) {
5875                                 /*jshint maxcomplexity:15*/
5876                                 if ( this.element.prop( "readOnly" ) ) {
5877                                         suppressKeyPress = true;
5878                                         suppressInput = true;
5879                                         suppressKeyPressRepeat = true;
5880                                         return;
5881                                 }
5882
5883                                 suppressKeyPress = false;
5884                                 suppressInput = false;
5885                                 suppressKeyPressRepeat = false;
5886                                 var keyCode = $.ui.keyCode;
5887                                 switch( event.keyCode ) {
5888                                 case keyCode.PAGE_UP:
5889                                         suppressKeyPress = true;
5890                                         this._move( "previousPage", event );
5891                                         break;
5892                                 case keyCode.PAGE_DOWN:
5893                                         suppressKeyPress = true;
5894                                         this._move( "nextPage", event );
5895                                         break;
5896                                 case keyCode.UP:
5897                                         suppressKeyPress = true;
5898                                         this._keyEvent( "previous", event );
5899                                         break;
5900                                 case keyCode.DOWN:
5901                                         suppressKeyPress = true;
5902                                         this._keyEvent( "next", event );
5903                                         break;
5904                                 case keyCode.ENTER:
5905                                 case keyCode.NUMPAD_ENTER:
5906                                         // when menu is open and has focus
5907                                         if ( this.menu.active ) {
5908                                                 // #6055 - Opera still allows the keypress to occur
5909                                                 // which causes forms to submit
5910                                                 suppressKeyPress = true;
5911                                                 event.preventDefault();
5912                                                 this.menu.select( event );
5913                                         }
5914                                         break;
5915                                 case keyCode.TAB:
5916                                         if ( this.menu.active ) {
5917                                                 this.menu.select( event );
5918                                         }
5919                                         break;
5920                                 case keyCode.ESCAPE:
5921                                         if ( this.menu.element.is( ":visible" ) ) {
5922                                                 this._value( this.term );
5923                                                 this.close( event );
5924                                                 // Different browsers have different default behavior for escape
5925                                                 // Single press can mean undo or clear
5926                                                 // Double press in IE means clear the whole form
5927                                                 event.preventDefault();
5928                                         }
5929                                         break;
5930                                 default:
5931                                         suppressKeyPressRepeat = true;
5932                                         // search timeout should be triggered before the input value is changed
5933                                         this._searchTimeout( event );
5934                                         break;
5935                                 }
5936                         },
5937                         keypress: function( event ) {
5938                                 if ( suppressKeyPress ) {
5939                                         suppressKeyPress = false;
5940                                         if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
5941                                                 event.preventDefault();
5942                                         }
5943                                         return;
5944                                 }
5945                                 if ( suppressKeyPressRepeat ) {
5946                                         return;
5947                                 }
5948
5949                                 // replicate some key handlers to allow them to repeat in Firefox and Opera
5950                                 var keyCode = $.ui.keyCode;
5951                                 switch( event.keyCode ) {
5952                                 case keyCode.PAGE_UP:
5953                                         this._move( "previousPage", event );
5954                                         break;
5955                                 case keyCode.PAGE_DOWN:
5956                                         this._move( "nextPage", event );
5957                                         break;
5958                                 case keyCode.UP:
5959                                         this._keyEvent( "previous", event );
5960                                         break;
5961                                 case keyCode.DOWN:
5962                                         this._keyEvent( "next", event );
5963                                         break;
5964                                 }
5965                         },
5966                         input: function( event ) {
5967                                 if ( suppressInput ) {
5968                                         suppressInput = false;
5969                                         event.preventDefault();
5970                                         return;
5971                                 }
5972                                 this._searchTimeout( event );
5973                         },
5974                         focus: function() {
5975                                 this.selectedItem = null;
5976                                 this.previous = this._value();
5977                         },
5978                         blur: function( event ) {
5979                                 if ( this.cancelBlur ) {
5980                                         delete this.cancelBlur;
5981                                         return;
5982                                 }
5983
5984                                 clearTimeout( this.searching );
5985                                 this.close( event );
5986                                 this._change( event );
5987                         }
5988                 });
5989
5990                 this._initSource();
5991                 this.menu = $( "<ul>" )
5992                         .addClass( "ui-autocomplete ui-front" )
5993                         .appendTo( this._appendTo() )
5994                         .menu({
5995                                 // disable ARIA support, the live region takes care of that
5996                                 role: null
5997                         })
5998                         .hide()
5999                         .data( "ui-menu" );
6000
6001                 this._on( this.menu.element, {
6002                         mousedown: function( event ) {
6003                                 // prevent moving focus out of the text field
6004                                 event.preventDefault();
6005
6006                                 // IE doesn't prevent moving focus even with event.preventDefault()
6007                                 // so we set a flag to know when we should ignore the blur event
6008                                 this.cancelBlur = true;
6009                                 this._delay(function() {
6010                                         delete this.cancelBlur;
6011                                 });
6012
6013                                 // clicking on the scrollbar causes focus to shift to the body
6014                                 // but we can't detect a mouseup or a click immediately afterward
6015                                 // so we have to track the next mousedown and close the menu if
6016                                 // the user clicks somewhere outside of the autocomplete
6017                                 var menuElement = this.menu.element[ 0 ];
6018                                 if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
6019                                         this._delay(function() {
6020                                                 var that = this;
6021                                                 this.document.one( "mousedown", function( event ) {
6022                                                         if ( event.target !== that.element[ 0 ] &&
6023                                                                         event.target !== menuElement &&
6024                                                                         !$.contains( menuElement, event.target ) ) {
6025                                                                 that.close();
6026                                                         }
6027                                                 });
6028                                         });
6029                                 }
6030                         },
6031                         menufocus: function( event, ui ) {
6032                                 // support: Firefox
6033                                 // Prevent accidental activation of menu items in Firefox (#7024 #9118)
6034                                 if ( this.isNewMenu ) {
6035                                         this.isNewMenu = false;
6036                                         if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
6037                                                 this.menu.blur();
6038
6039                                                 this.document.one( "mousemove", function() {
6040                                                         $( event.target ).trigger( event.originalEvent );
6041                                                 });
6042
6043                                                 return;
6044                                         }
6045                                 }
6046
6047                                 var item = ui.item.data( "ui-autocomplete-item" );
6048                                 if ( false !== this._trigger( "focus", event, { item: item } ) ) {
6049                                         // use value to match what will end up in the input, if it was a key event
6050                                         if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
6051                                                 this._value( item.value );
6052                                         }
6053                                 } else {
6054                                         // Normally the input is populated with the item's value as the
6055                                         // menu is navigated, causing screen readers to notice a change and
6056                                         // announce the item. Since the focus event was canceled, this doesn't
6057                                         // happen, so we update the live region so that screen readers can
6058                                         // still notice the change and announce it.
6059                                         this.liveRegion.text( item.value );
6060                                 }
6061                         },
6062                         menuselect: function( event, ui ) {
6063                                 var item = ui.item.data( "ui-autocomplete-item" ),
6064                                         previous = this.previous;
6065
6066                                 // only trigger when focus was lost (click on menu)
6067                                 if ( this.element[0] !== this.document[0].activeElement ) {
6068                                         this.element.focus();
6069                                         this.previous = previous;
6070                                         // #6109 - IE triggers two focus events and the second
6071                                         // is asynchronous, so we need to reset the previous
6072                                         // term synchronously and asynchronously :-(
6073                                         this._delay(function() {
6074                                                 this.previous = previous;
6075                                                 this.selectedItem = item;
6076                                         });
6077                                 }
6078
6079                                 if ( false !== this._trigger( "select", event, { item: item } ) ) {
6080                                         this._value( item.value );
6081                                 }
6082                                 // reset the term after the select event
6083                                 // this allows custom select handling to work properly
6084                                 this.term = this._value();
6085
6086                                 this.close( event );
6087                                 this.selectedItem = item;
6088                         }
6089                 });
6090
6091                 this.liveRegion = $( "<span>", {
6092                                 role: "status",
6093                                 "aria-live": "polite"
6094                         })
6095                         .addClass( "ui-helper-hidden-accessible" )
6096                         .insertBefore( this.element );
6097
6098                 // turning off autocomplete prevents the browser from remembering the
6099                 // value when navigating through history, so we re-enable autocomplete
6100                 // if the page is unloaded before the widget is destroyed. #7790
6101                 this._on( this.window, {
6102                         beforeunload: function() {
6103                                 this.element.removeAttr( "autocomplete" );
6104                         }
6105                 });
6106         },
6107
6108         _destroy: function() {
6109                 clearTimeout( this.searching );
6110                 this.element
6111                         .removeClass( "ui-autocomplete-input" )
6112                         .removeAttr( "autocomplete" );
6113                 this.menu.element.remove();
6114                 this.liveRegion.remove();
6115         },
6116
6117         _setOption: function( key, value ) {
6118                 this._super( key, value );
6119                 if ( key === "source" ) {
6120                         this._initSource();
6121                 }
6122                 if ( key === "appendTo" ) {
6123                         this.menu.element.appendTo( this._appendTo() );
6124                 }
6125                 if ( key === "disabled" && value && this.xhr ) {
6126                         this.xhr.abort();
6127                 }
6128         },
6129
6130         _appendTo: function() {
6131                 var element = this.options.appendTo;
6132
6133                 if ( element ) {
6134                         element = element.jquery || element.nodeType ?
6135                                 $( element ) :
6136                                 this.document.find( element ).eq( 0 );
6137                 }
6138
6139                 if ( !element ) {
6140                         element = this.element.closest( ".ui-front" );
6141                 }
6142
6143                 if ( !element.length ) {
6144                         element = this.document[0].body;
6145                 }
6146
6147                 return element;
6148         },
6149
6150         _initSource: function() {
6151                 var array, url,
6152                         that = this;
6153                 if ( $.isArray(this.options.source) ) {
6154                         array = this.options.source;
6155                         this.source = function( request, response ) {
6156                                 response( $.ui.autocomplete.filter( array, request.term ) );
6157                         };
6158                 } else if ( typeof this.options.source === "string" ) {
6159                         url = this.options.source;
6160                         this.source = function( request, response ) {
6161                                 if ( that.xhr ) {
6162                                         that.xhr.abort();
6163                                 }
6164                                 that.xhr = $.ajax({
6165                                         url: url,
6166                                         data: request,
6167                                         dataType: "json",
6168                                         success: function( data ) {
6169                                                 response( data );
6170                                         },
6171                                         error: function() {
6172                                                 response( [] );
6173                                         }
6174                                 });
6175                         };
6176                 } else {
6177                         this.source = this.options.source;
6178                 }
6179         },
6180
6181         _searchTimeout: function( event ) {
6182                 clearTimeout( this.searching );
6183                 this.searching = this._delay(function() {
6184                         // only search if the value has changed
6185                         if ( this.term !== this._value() ) {
6186                                 this.selectedItem = null;
6187                                 this.search( null, event );
6188                         }
6189                 }, this.options.delay );
6190         },
6191
6192         search: function( value, event ) {
6193                 value = value != null ? value : this._value();
6194
6195                 // always save the actual value, not the one passed as an argument
6196                 this.term = this._value();
6197
6198                 if ( value.length < this.options.minLength ) {
6199                         return this.close( event );
6200                 }
6201
6202                 if ( this._trigger( "search", event ) === false ) {
6203                         return;
6204                 }
6205
6206                 return this._search( value );
6207         },
6208
6209         _search: function( value ) {
6210                 this.pending++;
6211                 this.element.addClass( "ui-autocomplete-loading" );
6212                 this.cancelSearch = false;
6213
6214                 this.source( { term: value }, this._response() );
6215         },
6216
6217         _response: function() {
6218                 var that = this,
6219                         index = ++requestIndex;
6220
6221                 return function( content ) {
6222                         if ( index === requestIndex ) {
6223                                 that.__response( content );
6224                         }
6225
6226                         that.pending--;
6227                         if ( !that.pending ) {
6228                                 that.element.removeClass( "ui-autocomplete-loading" );
6229                         }
6230                 };
6231         },
6232
6233         __response: function( content ) {
6234                 if ( content ) {
6235                         content = this._normalize( content );
6236                 }
6237                 this._trigger( "response", null, { content: content } );
6238                 if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
6239                         this._suggest( content );
6240                         this._trigger( "open" );
6241                 } else {
6242                         // use ._close() instead of .close() so we don't cancel future searches
6243                         this._close();
6244                 }
6245         },
6246
6247         close: function( event ) {
6248                 this.cancelSearch = true;
6249                 this._close( event );
6250         },
6251
6252         _close: function( event ) {
6253                 if ( this.menu.element.is( ":visible" ) ) {
6254                         this.menu.element.hide();
6255                         this.menu.blur();
6256                         this.isNewMenu = true;
6257                         this._trigger( "close", event );
6258                 }
6259         },
6260
6261         _change: function( event ) {
6262                 if ( this.previous !== this._value() ) {
6263                         this._trigger( "change", event, { item: this.selectedItem } );
6264                 }
6265         },
6266
6267         _normalize: function( items ) {
6268                 // assume all items have the right format when the first item is complete
6269                 if ( items.length && items[0].label && items[0].value ) {
6270                         return items;
6271                 }
6272                 return $.map( items, function( item ) {
6273                         if ( typeof item === "string" ) {
6274                                 return {
6275                                         label: item,
6276                                         value: item
6277                                 };
6278                         }
6279                         return $.extend({
6280                                 label: item.label || item.value,
6281                                 value: item.value || item.label
6282                         }, item );
6283                 });
6284         },
6285
6286         _suggest: function( items ) {
6287                 var ul = this.menu.element.empty();
6288                 this._renderMenu( ul, items );
6289                 this.isNewMenu = true;
6290                 this.menu.refresh();
6291
6292                 // size and position menu
6293                 ul.show();
6294                 this._resizeMenu();
6295                 ul.position( $.extend({
6296                         of: this.element
6297                 }, this.options.position ));
6298
6299                 if ( this.options.autoFocus ) {
6300                         this.menu.next();
6301                 }
6302         },
6303
6304         _resizeMenu: function() {
6305                 var ul = this.menu.element;
6306                 ul.outerWidth( Math.max(
6307                         // Firefox wraps long text (possibly a rounding bug)
6308                         // so we add 1px to avoid the wrapping (#7513)
6309                         ul.width( "" ).outerWidth() + 1,
6310                         this.element.outerWidth()
6311                 ) );
6312         },
6313
6314         _renderMenu: function( ul, items ) {
6315                 var that = this;
6316                 $.each( items, function( index, item ) {
6317                         that._renderItemData( ul, item );
6318                 });
6319         },
6320
6321         _renderItemData: function( ul, item ) {
6322                 return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
6323         },
6324
6325         _renderItem: function( ul, item ) {
6326                 return $( "<li>" )
6327                         .append( $( "<a>" ).text( item.label ) )
6328                         .appendTo( ul );
6329         },
6330
6331         _move: function( direction, event ) {
6332                 if ( !this.menu.element.is( ":visible" ) ) {
6333                         this.search( null, event );
6334                         return;
6335                 }
6336                 if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
6337                                 this.menu.isLastItem() && /^next/.test( direction ) ) {
6338                         this._value( this.term );
6339                         this.menu.blur();
6340                         return;
6341                 }
6342                 this.menu[ direction ]( event );
6343         },
6344
6345         widget: function() {
6346                 return this.menu.element;
6347         },
6348
6349         _value: function() {
6350                 return this.valueMethod.apply( this.element, arguments );
6351         },
6352
6353         _keyEvent: function( keyEvent, event ) {
6354                 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
6355                         this._move( keyEvent, event );
6356
6357                         // prevents moving cursor to beginning/end of the text field in some browsers
6358                         event.preventDefault();
6359                 }
6360         }
6361 });
6362
6363 $.extend( $.ui.autocomplete, {
6364         escapeRegex: function( value ) {
6365                 return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
6366         },
6367         filter: function(array, term) {
6368                 var matcher = new RegExp( $.ui.autocomplete.escapeRegex(term), "i" );
6369                 return $.grep( array, function(value) {
6370                         return matcher.test( value.label || value.value || value );
6371                 });
6372         }
6373 });
6374
6375
6376 // live region extension, adding a `messages` option
6377 // NOTE: This is an experimental API. We are still investigating
6378 // a full solution for string manipulation and internationalization.
6379 $.widget( "ui.autocomplete", $.ui.autocomplete, {
6380         options: {
6381                 messages: {
6382                         noResults: "No search results.",
6383                         results: function( amount ) {
6384                                 return amount + ( amount > 1 ? " results are" : " result is" ) +
6385                                         " available, use up and down arrow keys to navigate.";
6386                         }
6387                 }
6388         },
6389
6390         __response: function( content ) {
6391                 var message;
6392                 this._superApply( arguments );
6393                 if ( this.options.disabled || this.cancelSearch ) {
6394                         return;
6395                 }
6396                 if ( content && content.length ) {
6397                         message = this.options.messages.results( content.length );
6398                 } else {
6399                         message = this.options.messages.noResults;
6400                 }
6401                 this.liveRegion.text( message );
6402         }
6403 });
6404
6405 }( jQuery ));
6406 (function( $, undefined ) {
6407
6408 var lastActive, startXPos, startYPos, clickDragged,
6409         baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
6410         stateClasses = "ui-state-hover ui-state-active ",
6411         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",
6412         formResetHandler = function() {
6413                 var form = $( this );
6414                 setTimeout(function() {
6415                         form.find( ":ui-button" ).button( "refresh" );
6416                 }, 1 );
6417         },
6418         radioGroup = function( radio ) {
6419                 var name = radio.name,
6420                         form = radio.form,
6421                         radios = $( [] );
6422                 if ( name ) {
6423                         name = name.replace( /'/g, "\\'" );
6424                         if ( form ) {
6425                                 radios = $( form ).find( "[name='" + name + "']" );
6426                         } else {
6427                                 radios = $( "[name='" + name + "']", radio.ownerDocument )
6428                                         .filter(function() {
6429                                                 return !this.form;
6430                                         });
6431                         }
6432                 }
6433                 return radios;
6434         };
6435
6436 $.widget( "ui.button", {
6437         version: "1.10.3",
6438         defaultElement: "<button>",
6439         options: {
6440                 disabled: null,
6441                 text: true,
6442                 label: null,
6443                 icons: {
6444                         primary: null,
6445                         secondary: null
6446                 }
6447         },
6448         _create: function() {
6449                 this.element.closest( "form" )
6450                         .unbind( "reset" + this.eventNamespace )
6451                         .bind( "reset" + this.eventNamespace, formResetHandler );
6452
6453                 if ( typeof this.options.disabled !== "boolean" ) {
6454                         this.options.disabled = !!this.element.prop( "disabled" );
6455                 } else {
6456                         this.element.prop( "disabled", this.options.disabled );
6457                 }
6458
6459                 this._determineButtonType();
6460                 this.hasTitle = !!this.buttonElement.attr( "title" );
6461
6462                 var that = this,
6463                         options = this.options,
6464                         toggleButton = this.type === "checkbox" || this.type === "radio",
6465                         activeClass = !toggleButton ? "ui-state-active" : "",
6466                         focusClass = "ui-state-focus";
6467
6468                 if ( options.label === null ) {
6469                         options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
6470                 }
6471
6472                 this._hoverable( this.buttonElement );
6473
6474                 this.buttonElement
6475                         .addClass( baseClasses )
6476                         .attr( "role", "button" )
6477                         .bind( "mouseenter" + this.eventNamespace, function() {
6478                                 if ( options.disabled ) {
6479                                         return;
6480                                 }
6481                                 if ( this === lastActive ) {
6482                                         $( this ).addClass( "ui-state-active" );
6483                                 }
6484                         })
6485                         .bind( "mouseleave" + this.eventNamespace, function() {
6486                                 if ( options.disabled ) {
6487                                         return;
6488                                 }
6489                                 $( this ).removeClass( activeClass );
6490                         })
6491                         .bind( "click" + this.eventNamespace, function( event ) {
6492                                 if ( options.disabled ) {
6493                                         event.preventDefault();
6494                                         event.stopImmediatePropagation();
6495                                 }
6496                         });
6497
6498                 this.element
6499                         .bind( "focus" + this.eventNamespace, function() {
6500                                 // no need to check disabled, focus won't be triggered anyway
6501                                 that.buttonElement.addClass( focusClass );
6502                         })
6503                         .bind( "blur" + this.eventNamespace, function() {
6504                                 that.buttonElement.removeClass( focusClass );
6505                         });
6506
6507                 if ( toggleButton ) {
6508                         this.element.bind( "change" + this.eventNamespace, function() {
6509                                 if ( clickDragged ) {
6510                                         return;
6511                                 }
6512                                 that.refresh();
6513                         });
6514                         // if mouse moves between mousedown and mouseup (drag) set clickDragged flag
6515                         // prevents issue where button state changes but checkbox/radio checked state
6516                         // does not in Firefox (see ticket #6970)
6517                         this.buttonElement
6518                                 .bind( "mousedown" + this.eventNamespace, function( event ) {
6519                                         if ( options.disabled ) {
6520                                                 return;
6521                                         }
6522                                         clickDragged = false;
6523                                         startXPos = event.pageX;
6524                                         startYPos = event.pageY;
6525                                 })
6526                                 .bind( "mouseup" + this.eventNamespace, function( event ) {
6527                                         if ( options.disabled ) {
6528                                                 return;
6529                                         }
6530                                         if ( startXPos !== event.pageX || startYPos !== event.pageY ) {
6531                                                 clickDragged = true;
6532                                         }
6533                         });
6534                 }
6535
6536                 if ( this.type === "checkbox" ) {
6537                         this.buttonElement.bind( "click" + this.eventNamespace, function() {
6538                                 if ( options.disabled || clickDragged ) {
6539                                         return false;
6540                                 }
6541                         });
6542                 } else if ( this.type === "radio" ) {
6543                         this.buttonElement.bind( "click" + this.eventNamespace, function() {
6544                                 if ( options.disabled || clickDragged ) {
6545                                         return false;
6546                                 }
6547                                 $( this ).addClass( "ui-state-active" );
6548                                 that.buttonElement.attr( "aria-pressed", "true" );
6549
6550                                 var radio = that.element[ 0 ];
6551                                 radioGroup( radio )
6552                                         .not( radio )
6553                                         .map(function() {
6554                                                 return $( this ).button( "widget" )[ 0 ];
6555                                         })
6556                                         .removeClass( "ui-state-active" )
6557                                         .attr( "aria-pressed", "false" );
6558                         });
6559                 } else {
6560                         this.buttonElement
6561                                 .bind( "mousedown" + this.eventNamespace, function() {
6562                                         if ( options.disabled ) {
6563                                                 return false;
6564                                         }
6565                                         $( this ).addClass( "ui-state-active" );
6566                                         lastActive = this;
6567                                         that.document.one( "mouseup", function() {
6568                                                 lastActive = null;
6569                                         });
6570                                 })
6571                                 .bind( "mouseup" + this.eventNamespace, function() {
6572                                         if ( options.disabled ) {
6573                                                 return false;
6574                                         }
6575                                         $( this ).removeClass( "ui-state-active" );
6576                                 })
6577                                 .bind( "keydown" + this.eventNamespace, function(event) {
6578                                         if ( options.disabled ) {
6579                                                 return false;
6580                                         }
6581                                         if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
6582                                                 $( this ).addClass( "ui-state-active" );
6583                                         }
6584                                 })
6585                                 // see #8559, we bind to blur here in case the button element loses
6586                                 // focus between keydown and keyup, it would be left in an "active" state
6587                                 .bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() {
6588                                         $( this ).removeClass( "ui-state-active" );
6589                                 });
6590
6591                         if ( this.buttonElement.is("a") ) {
6592                                 this.buttonElement.keyup(function(event) {
6593                                         if ( event.keyCode === $.ui.keyCode.SPACE ) {
6594                                                 // TODO pass through original event correctly (just as 2nd argument doesn't work)
6595                                                 $( this ).click();
6596                                         }
6597                                 });
6598                         }
6599                 }
6600
6601                 // TODO: pull out $.Widget's handling for the disabled option into
6602                 // $.Widget.prototype._setOptionDisabled so it's easy to proxy and can
6603                 // be overridden by individual plugins
6604                 this._setOption( "disabled", options.disabled );
6605                 this._resetButton();
6606         },
6607
6608         _determineButtonType: function() {
6609                 var ancestor, labelSelector, checked;
6610
6611                 if ( this.element.is("[type=checkbox]") ) {
6612                         this.type = "checkbox";
6613                 } else if ( this.element.is("[type=radio]") ) {
6614                         this.type = "radio";
6615                 } else if ( this.element.is("input") ) {
6616                         this.type = "input";
6617                 } else {
6618                         this.type = "button";
6619                 }
6620
6621                 if ( this.type === "checkbox" || this.type === "radio" ) {
6622                         // we don't search against the document in case the element
6623                         // is disconnected from the DOM
6624                         ancestor = this.element.parents().last();
6625                         labelSelector = "label[for='" + this.element.attr("id") + "']";
6626                         this.buttonElement = ancestor.find( labelSelector );
6627                         if ( !this.buttonElement.length ) {
6628                                 ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
6629                                 this.buttonElement = ancestor.filter( labelSelector );
6630                                 if ( !this.buttonElement.length ) {
6631                                         this.buttonElement = ancestor.find( labelSelector );
6632                                 }
6633                         }
6634                         this.element.addClass( "ui-helper-hidden-accessible" );
6635
6636                         checked = this.element.is( ":checked" );
6637                         if ( checked ) {
6638                                 this.buttonElement.addClass( "ui-state-active" );
6639                         }
6640                         this.buttonElement.prop( "aria-pressed", checked );
6641                 } else {
6642                         this.buttonElement = this.element;
6643                 }
6644         },
6645
6646         widget: function() {
6647                 return this.buttonElement;
6648         },
6649
6650         _destroy: function() {
6651                 this.element
6652                         .removeClass( "ui-helper-hidden-accessible" );
6653                 this.buttonElement
6654                         .removeClass( baseClasses + " " + stateClasses + " " + typeClasses )
6655                         .removeAttr( "role" )
6656                         .removeAttr( "aria-pressed" )
6657                         .html( this.buttonElement.find(".ui-button-text").html() );
6658
6659                 if ( !this.hasTitle ) {
6660                         this.buttonElement.removeAttr( "title" );
6661                 }
6662         },
6663
6664         _setOption: function( key, value ) {
6665                 this._super( key, value );
6666                 if ( key === "disabled" ) {
6667                         if ( value ) {
6668                                 this.element.prop( "disabled", true );
6669                         } else {
6670                                 this.element.prop( "disabled", false );
6671                         }
6672                         return;
6673                 }
6674                 this._resetButton();
6675         },
6676
6677         refresh: function() {
6678                 //See #8237 & #8828
6679                 var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
6680
6681                 if ( isDisabled !== this.options.disabled ) {
6682                         this._setOption( "disabled", isDisabled );
6683                 }
6684                 if ( this.type === "radio" ) {
6685                         radioGroup( this.element[0] ).each(function() {
6686                                 if ( $( this ).is( ":checked" ) ) {
6687                                         $( this ).button( "widget" )
6688                                                 .addClass( "ui-state-active" )
6689                                                 .attr( "aria-pressed", "true" );
6690                                 } else {
6691                                         $( this ).button( "widget" )
6692                                                 .removeClass( "ui-state-active" )
6693                                                 .attr( "aria-pressed", "false" );
6694                                 }
6695                         });
6696                 } else if ( this.type === "checkbox" ) {
6697                         if ( this.element.is( ":checked" ) ) {
6698                                 this.buttonElement
6699                                         .addClass( "ui-state-active" )
6700                                         .attr( "aria-pressed", "true" );
6701                         } else {
6702                                 this.buttonElement
6703                                         .removeClass( "ui-state-active" )
6704                                         .attr( "aria-pressed", "false" );
6705                         }
6706                 }
6707         },
6708
6709         _resetButton: function() {
6710                 if ( this.type === "input" ) {
6711                         if ( this.options.label ) {
6712                                 this.element.val( this.options.label );
6713                         }
6714                         return;
6715                 }
6716                 var buttonElement = this.buttonElement.removeClass( typeClasses ),
6717                         buttonText = $( "<span></span>", this.document[0] )
6718                                 .addClass( "ui-button-text" )
6719                                 .html( this.options.label )
6720                                 .appendTo( buttonElement.empty() )
6721                                 .text(),
6722                         icons = this.options.icons,
6723                         multipleIcons = icons.primary && icons.secondary,
6724                         buttonClasses = [];
6725
6726                 if ( icons.primary || icons.secondary ) {
6727                         if ( this.options.text ) {
6728                                 buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
6729                         }
6730
6731                         if ( icons.primary ) {
6732                                 buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
6733                         }
6734
6735                         if ( icons.secondary ) {
6736                                 buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
6737                         }
6738
6739                         if ( !this.options.text ) {
6740                                 buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" );
6741
6742                                 if ( !this.hasTitle ) {
6743                                         buttonElement.attr( "title", $.trim( buttonText ) );
6744                                 }
6745                         }
6746                 } else {
6747                         buttonClasses.push( "ui-button-text-only" );
6748                 }
6749                 buttonElement.addClass( buttonClasses.join( " " ) );
6750         }
6751 });
6752
6753 $.widget( "ui.buttonset", {
6754         version: "1.10.3",
6755         options: {
6756                 items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)"
6757         },
6758
6759         _create: function() {
6760                 this.element.addClass( "ui-buttonset" );
6761         },
6762
6763         _init: function() {
6764                 this.refresh();
6765         },
6766
6767         _setOption: function( key, value ) {
6768                 if ( key === "disabled" ) {
6769                         this.buttons.button( "option", key, value );
6770                 }
6771
6772                 this._super( key, value );
6773         },
6774
6775         refresh: function() {
6776                 var rtl = this.element.css( "direction" ) === "rtl";
6777
6778                 this.buttons = this.element.find( this.options.items )
6779                         .filter( ":ui-button" )
6780                                 .button( "refresh" )
6781                         .end()
6782                         .not( ":ui-button" )
6783                                 .button()
6784                         .end()
6785                         .map(function() {
6786                                 return $( this ).button( "widget" )[ 0 ];
6787                         })
6788                                 .removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
6789                                 .filter( ":first" )
6790                                         .addClass( rtl ? "ui-corner-right" : "ui-corner-left" )
6791                                 .end()
6792                                 .filter( ":last" )
6793                                         .addClass( rtl ? "ui-corner-left" : "ui-corner-right" )
6794                                 .end()
6795                         .end();
6796         },
6797
6798         _destroy: function() {
6799                 this.element.removeClass( "ui-buttonset" );
6800                 this.buttons
6801                         .map(function() {
6802                                 return $( this ).button( "widget" )[ 0 ];
6803                         })
6804                                 .removeClass( "ui-corner-left ui-corner-right" )
6805                         .end()
6806                         .button( "destroy" );
6807         }
6808 });
6809
6810 }( jQuery ) );
6811 (function( $, undefined ) {
6812
6813 $.extend($.ui, { datepicker: { version: "1.10.3" } });
6814
6815 var PROP_NAME = "datepicker",
6816         instActive;
6817
6818 /* Date picker manager.
6819    Use the singleton instance of this class, $.datepicker, to interact with the date picker.
6820    Settings for (groups of) date pickers are maintained in an instance object,
6821    allowing multiple different settings on the same page. */
6822
6823 function Datepicker() {
6824         this._curInst = null; // The current instance in use
6825         this._keyEvent = false; // If the last event was a key event
6826         this._disabledInputs = []; // List of date picker inputs that have been disabled
6827         this._datepickerShowing = false; // True if the popup picker is showing , false if not
6828         this._inDialog = false; // True if showing within a "dialog", false if not
6829         this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
6830         this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
6831         this._appendClass = "ui-datepicker-append"; // The name of the append marker class
6832         this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
6833         this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
6834         this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
6835         this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
6836         this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
6837         this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
6838         this.regional = []; // Available regional settings, indexed by language code
6839         this.regional[""] = { // Default regional settings
6840                 closeText: "Done", // Display text for close link
6841                 prevText: "Prev", // Display text for previous month link
6842                 nextText: "Next", // Display text for next month link
6843                 currentText: "Today", // Display text for current month link
6844                 monthNames: ["January","February","March","April","May","June",
6845                         "July","August","September","October","November","December"], // Names of months for drop-down and formatting
6846                 monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
6847                 dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
6848                 dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting
6849                 dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday
6850                 weekHeader: "Wk", // Column header for week of the year
6851                 dateFormat: "mm/dd/yy", // See format options on parseDate
6852                 firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
6853                 isRTL: false, // True if right-to-left language, false if left-to-right
6854                 showMonthAfterYear: false, // True if the year select precedes month, false for month then year
6855                 yearSuffix: "" // Additional text to append to the year in the month headers
6856         };
6857         this._defaults = { // Global defaults for all the date picker instances
6858                 showOn: "focus", // "focus" for popup on focus,
6859                         // "button" for trigger button, or "both" for either
6860                 showAnim: "fadeIn", // Name of jQuery animation for popup
6861                 showOptions: {}, // Options for enhanced animations
6862                 defaultDate: null, // Used when field is blank: actual date,
6863                         // +/-number for offset from today, null for today
6864                 appendText: "", // Display text following the input box, e.g. showing the format
6865                 buttonText: "...", // Text for trigger button
6866                 buttonImage: "", // URL for trigger button image
6867                 buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
6868                 hideIfNoPrevNext: false, // True to hide next/previous month links
6869                         // if not applicable, false to just disable them
6870                 navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
6871                 gotoCurrent: false, // True if today link goes back to current selection instead
6872                 changeMonth: false, // True if month can be selected directly, false if only prev/next
6873                 changeYear: false, // True if year can be selected directly, false if only prev/next
6874                 yearRange: "c-10:c+10", // Range of years to display in drop-down,
6875                         // either relative to today's year (-nn:+nn), relative to currently displayed year
6876                         // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
6877                 showOtherMonths: false, // True to show dates in other months, false to leave blank
6878                 selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
6879                 showWeek: false, // True to show week of the year, false to not show it
6880                 calculateWeek: this.iso8601Week, // How to calculate the week of the year,
6881                         // takes a Date and returns the number of the week for it
6882                 shortYearCutoff: "+10", // Short year values < this are in the current century,
6883                         // > this are in the previous century,
6884                         // string value starting with "+" for current year + value
6885                 minDate: null, // The earliest selectable date, or null for no limit
6886                 maxDate: null, // The latest selectable date, or null for no limit
6887                 duration: "fast", // Duration of display/closure
6888                 beforeShowDay: null, // Function that takes a date and returns an array with
6889                         // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
6890                         // [2] = cell title (optional), e.g. $.datepicker.noWeekends
6891                 beforeShow: null, // Function that takes an input field and
6892                         // returns a set of custom settings for the date picker
6893                 onSelect: null, // Define a callback function when a date is selected
6894                 onChangeMonthYear: null, // Define a callback function when the month or year is changed
6895                 onClose: null, // Define a callback function when the datepicker is closed
6896                 numberOfMonths: 1, // Number of months to show at a time
6897                 showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
6898                 stepMonths: 1, // Number of months to step back/forward
6899                 stepBigMonths: 12, // Number of months to step back/forward for the big links
6900                 altField: "", // Selector for an alternate field to store selected dates into
6901                 altFormat: "", // The date format to use for the alternate field
6902                 constrainInput: true, // The input is constrained by the current date format
6903                 showButtonPanel: false, // True to show button panel, false to not show it
6904                 autoSize: false, // True to size the input for the date format, false to leave as is
6905                 disabled: false // The initial disabled state
6906         };
6907         $.extend(this._defaults, this.regional[""]);
6908         this.dpDiv = bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>"));
6909 }
6910
6911 $.extend(Datepicker.prototype, {
6912         /* Class name added to elements to indicate already configured with a date picker. */
6913         markerClassName: "hasDatepicker",
6914
6915         //Keep track of the maximum number of rows displayed (see #7043)
6916         maxRows: 4,
6917
6918         // TODO rename to "widget" when switching to widget factory
6919         _widgetDatepicker: function() {
6920                 return this.dpDiv;
6921         },
6922
6923         /* Override the default settings for all instances of the date picker.
6924          * @param  settings  object - the new settings to use as defaults (anonymous object)
6925          * @return the manager object
6926          */
6927         setDefaults: function(settings) {
6928                 extendRemove(this._defaults, settings || {});
6929                 return this;
6930         },
6931
6932         /* Attach the date picker to a jQuery selection.
6933          * @param  target       element - the target input field or division or span
6934          * @param  settings  object - the new settings to use for this date picker instance (anonymous)
6935          */
6936         _attachDatepicker: function(target, settings) {
6937                 var nodeName, inline, inst;
6938                 nodeName = target.nodeName.toLowerCase();
6939                 inline = (nodeName === "div" || nodeName === "span");
6940                 if (!target.id) {
6941                         this.uuid += 1;
6942                         target.id = "dp" + this.uuid;
6943                 }
6944                 inst = this._newInst($(target), inline);
6945                 inst.settings = $.extend({}, settings || {});
6946                 if (nodeName === "input") {
6947                         this._connectDatepicker(target, inst);
6948                 } else if (inline) {
6949                         this._inlineDatepicker(target, inst);
6950                 }
6951         },
6952
6953         /* Create a new instance object. */
6954         _newInst: function(target, inline) {
6955                 var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars
6956                 return {id: id, input: target, // associated target
6957                         selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
6958                         drawMonth: 0, drawYear: 0, // month being drawn
6959                         inline: inline, // is datepicker inline or not
6960                         dpDiv: (!inline ? this.dpDiv : // presentation div
6961                         bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))};
6962         },
6963
6964         /* Attach the date picker to an input field. */
6965         _connectDatepicker: function(target, inst) {
6966                 var input = $(target);
6967                 inst.append = $([]);
6968                 inst.trigger = $([]);
6969                 if (input.hasClass(this.markerClassName)) {
6970                         return;
6971                 }
6972                 this._attachments(input, inst);
6973                 input.addClass(this.markerClassName).keydown(this._doKeyDown).
6974                         keypress(this._doKeyPress).keyup(this._doKeyUp);
6975                 this._autoSize(inst);
6976                 $.data(target, PROP_NAME, inst);
6977                 //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
6978                 if( inst.settings.disabled ) {
6979                         this._disableDatepicker( target );
6980                 }
6981         },
6982
6983         /* Make attachments based on settings. */
6984         _attachments: function(input, inst) {
6985                 var showOn, buttonText, buttonImage,
6986                         appendText = this._get(inst, "appendText"),
6987                         isRTL = this._get(inst, "isRTL");
6988
6989                 if (inst.append) {
6990                         inst.append.remove();
6991                 }
6992                 if (appendText) {
6993                         inst.append = $("<span class='" + this._appendClass + "'>" + appendText + "</span>");
6994                         input[isRTL ? "before" : "after"](inst.append);
6995                 }
6996
6997                 input.unbind("focus", this._showDatepicker);
6998
6999                 if (inst.trigger) {
7000                         inst.trigger.remove();
7001                 }
7002
7003                 showOn = this._get(inst, "showOn");
7004                 if (showOn === "focus" || showOn === "both") { // pop-up date picker when in the marked field
7005                         input.focus(this._showDatepicker);
7006                 }
7007                 if (showOn === "button" || showOn === "both") { // pop-up date picker when button clicked
7008                         buttonText = this._get(inst, "buttonText");
7009                         buttonImage = this._get(inst, "buttonImage");
7010                         inst.trigger = $(this._get(inst, "buttonImageOnly") ?
7011                                 $("<img/>").addClass(this._triggerClass).
7012                                         attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
7013                                 $("<button type='button'></button>").addClass(this._triggerClass).
7014                                         html(!buttonImage ? buttonText : $("<img/>").attr(
7015                                         { src:buttonImage, alt:buttonText, title:buttonText })));
7016                         input[isRTL ? "before" : "after"](inst.trigger);
7017                         inst.trigger.click(function() {
7018                                 if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) {
7019                                         $.datepicker._hideDatepicker();
7020                                 } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) {
7021                                         $.datepicker._hideDatepicker();
7022                                         $.datepicker._showDatepicker(input[0]);
7023                                 } else {
7024                                         $.datepicker._showDatepicker(input[0]);
7025                                 }
7026                                 return false;
7027                         });
7028                 }
7029         },
7030
7031         /* Apply the maximum length for the date format. */
7032         _autoSize: function(inst) {
7033                 if (this._get(inst, "autoSize") && !inst.inline) {
7034                         var findMax, max, maxI, i,
7035                                 date = new Date(2009, 12 - 1, 20), // Ensure double digits
7036                                 dateFormat = this._get(inst, "dateFormat");
7037
7038                         if (dateFormat.match(/[DM]/)) {
7039                                 findMax = function(names) {
7040                                         max = 0;
7041                                         maxI = 0;
7042                                         for (i = 0; i < names.length; i++) {
7043                                                 if (names[i].length > max) {
7044                                                         max = names[i].length;
7045                                                         maxI = i;
7046                                                 }
7047                                         }
7048                                         return maxI;
7049                                 };
7050                                 date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
7051                                         "monthNames" : "monthNamesShort"))));
7052                                 date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
7053                                         "dayNames" : "dayNamesShort"))) + 20 - date.getDay());
7054                         }
7055                         inst.input.attr("size", this._formatDate(inst, date).length);
7056                 }
7057         },
7058
7059         /* Attach an inline date picker to a div. */
7060         _inlineDatepicker: function(target, inst) {
7061                 var divSpan = $(target);
7062                 if (divSpan.hasClass(this.markerClassName)) {
7063                         return;
7064                 }
7065                 divSpan.addClass(this.markerClassName).append(inst.dpDiv);
7066                 $.data(target, PROP_NAME, inst);
7067                 this._setDate(inst, this._getDefaultDate(inst), true);
7068                 this._updateDatepicker(inst);
7069                 this._updateAlternate(inst);
7070                 //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
7071                 if( inst.settings.disabled ) {
7072                         this._disableDatepicker( target );
7073                 }
7074                 // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
7075                 // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
7076                 inst.dpDiv.css( "display", "block" );
7077         },
7078
7079         /* Pop-up the date picker in a "dialog" box.
7080          * @param  input element - ignored
7081          * @param  date string or Date - the initial date to display
7082          * @param  onSelect  function - the function to call when a date is selected
7083          * @param  settings  object - update the dialog date picker instance's settings (anonymous object)
7084          * @param  pos int[2] - coordinates for the dialog's position within the screen or
7085          *                                      event - with x/y coordinates or
7086          *                                      leave empty for default (screen centre)
7087          * @return the manager object
7088          */
7089         _dialogDatepicker: function(input, date, onSelect, settings, pos) {
7090                 var id, browserWidth, browserHeight, scrollX, scrollY,
7091                         inst = this._dialogInst; // internal instance
7092
7093                 if (!inst) {
7094                         this.uuid += 1;
7095                         id = "dp" + this.uuid;
7096                         this._dialogInput = $("<input type='text' id='" + id +
7097                                 "' style='position: absolute; top: -100px; width: 0px;'/>");
7098                         this._dialogInput.keydown(this._doKeyDown);
7099                         $("body").append(this._dialogInput);
7100                         inst = this._dialogInst = this._newInst(this._dialogInput, false);
7101                         inst.settings = {};
7102                         $.data(this._dialogInput[0], PROP_NAME, inst);
7103                 }
7104                 extendRemove(inst.settings, settings || {});
7105                 date = (date && date.constructor === Date ? this._formatDate(inst, date) : date);
7106                 this._dialogInput.val(date);
7107
7108                 this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
7109                 if (!this._pos) {
7110                         browserWidth = document.documentElement.clientWidth;
7111                         browserHeight = document.documentElement.clientHeight;
7112                         scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
7113                         scrollY = document.documentElement.scrollTop || document.body.scrollTop;
7114                         this._pos = // should use actual width/height below
7115                                 [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
7116                 }
7117
7118                 // move input on screen for focus, but hidden behind dialog
7119                 this._dialogInput.css("left", (this._pos[0] + 20) + "px").css("top", this._pos[1] + "px");
7120                 inst.settings.onSelect = onSelect;
7121                 this._inDialog = true;
7122                 this.dpDiv.addClass(this._dialogClass);
7123                 this._showDatepicker(this._dialogInput[0]);
7124                 if ($.blockUI) {
7125                         $.blockUI(this.dpDiv);
7126                 }
7127                 $.data(this._dialogInput[0], PROP_NAME, inst);
7128                 return this;
7129         },
7130
7131         /* Detach a datepicker from its control.
7132          * @param  target       element - the target input field or division or span
7133          */
7134         _destroyDatepicker: function(target) {
7135                 var nodeName,
7136                         $target = $(target),
7137                         inst = $.data(target, PROP_NAME);
7138
7139                 if (!$target.hasClass(this.markerClassName)) {
7140                         return;
7141                 }
7142
7143                 nodeName = target.nodeName.toLowerCase();
7144                 $.removeData(target, PROP_NAME);
7145                 if (nodeName === "input") {
7146                         inst.append.remove();
7147                         inst.trigger.remove();
7148                         $target.removeClass(this.markerClassName).
7149                                 unbind("focus", this._showDatepicker).
7150                                 unbind("keydown", this._doKeyDown).
7151                                 unbind("keypress", this._doKeyPress).
7152                                 unbind("keyup", this._doKeyUp);
7153                 } else if (nodeName === "div" || nodeName === "span") {
7154                         $target.removeClass(this.markerClassName).empty();
7155                 }
7156         },
7157
7158         /* Enable the date picker to a jQuery selection.
7159          * @param  target       element - the target input field or division or span
7160          */
7161         _enableDatepicker: function(target) {
7162                 var nodeName, inline,
7163                         $target = $(target),
7164                         inst = $.data(target, PROP_NAME);
7165
7166                 if (!$target.hasClass(this.markerClassName)) {
7167                         return;
7168                 }
7169
7170                 nodeName = target.nodeName.toLowerCase();
7171                 if (nodeName === "input") {
7172                         target.disabled = false;
7173                         inst.trigger.filter("button").
7174                                 each(function() { this.disabled = false; }).end().
7175                                 filter("img").css({opacity: "1.0", cursor: ""});
7176                 } else if (nodeName === "div" || nodeName === "span") {
7177                         inline = $target.children("." + this._inlineClass);
7178                         inline.children().removeClass("ui-state-disabled");
7179                         inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
7180                                 prop("disabled", false);
7181                 }
7182                 this._disabledInputs = $.map(this._disabledInputs,
7183                         function(value) { return (value === target ? null : value); }); // delete entry
7184         },
7185
7186         /* Disable the date picker to a jQuery selection.
7187          * @param  target       element - the target input field or division or span
7188          */
7189         _disableDatepicker: function(target) {
7190                 var nodeName, inline,
7191                         $target = $(target),
7192                         inst = $.data(target, PROP_NAME);
7193
7194                 if (!$target.hasClass(this.markerClassName)) {
7195                         return;
7196                 }
7197
7198                 nodeName = target.nodeName.toLowerCase();
7199                 if (nodeName === "input") {
7200                         target.disabled = true;
7201                         inst.trigger.filter("button").
7202                                 each(function() { this.disabled = true; }).end().
7203                                 filter("img").css({opacity: "0.5", cursor: "default"});
7204                 } else if (nodeName === "div" || nodeName === "span") {
7205                         inline = $target.children("." + this._inlineClass);
7206                         inline.children().addClass("ui-state-disabled");
7207                         inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
7208                                 prop("disabled", true);
7209                 }
7210                 this._disabledInputs = $.map(this._disabledInputs,
7211                         function(value) { return (value === target ? null : value); }); // delete entry
7212                 this._disabledInputs[this._disabledInputs.length] = target;
7213         },
7214
7215         /* Is the first field in a jQuery collection disabled as a datepicker?
7216          * @param  target       element - the target input field or division or span
7217          * @return boolean - true if disabled, false if enabled
7218          */
7219         _isDisabledDatepicker: function(target) {
7220                 if (!target) {
7221                         return false;
7222                 }
7223                 for (var i = 0; i < this._disabledInputs.length; i++) {
7224                         if (this._disabledInputs[i] === target) {
7225                                 return true;
7226                         }
7227                 }
7228                 return false;
7229         },
7230
7231         /* Retrieve the instance data for the target control.
7232          * @param  target  element - the target input field or division or span
7233          * @return  object - the associated instance data
7234          * @throws  error if a jQuery problem getting data
7235          */
7236         _getInst: function(target) {
7237                 try {
7238                         return $.data(target, PROP_NAME);
7239                 }
7240                 catch (err) {
7241                         throw "Missing instance data for this datepicker";
7242                 }
7243         },
7244
7245         /* Update or retrieve the settings for a date picker attached to an input field or division.
7246          * @param  target  element - the target input field or division or span
7247          * @param  name object - the new settings to update or
7248          *                              string - the name of the setting to change or retrieve,
7249          *                              when retrieving also "all" for all instance settings or
7250          *                              "defaults" for all global defaults
7251          * @param  value   any - the new value for the setting
7252          *                              (omit if above is an object or to retrieve a value)
7253          */
7254         _optionDatepicker: function(target, name, value) {
7255                 var settings, date, minDate, maxDate,
7256                         inst = this._getInst(target);
7257
7258                 if (arguments.length === 2 && typeof name === "string") {
7259                         return (name === "defaults" ? $.extend({}, $.datepicker._defaults) :
7260                                 (inst ? (name === "all" ? $.extend({}, inst.settings) :
7261                                 this._get(inst, name)) : null));
7262                 }
7263
7264                 settings = name || {};
7265                 if (typeof name === "string") {
7266                         settings = {};
7267                         settings[name] = value;
7268                 }
7269
7270                 if (inst) {
7271                         if (this._curInst === inst) {
7272                                 this._hideDatepicker();
7273                         }
7274
7275                         date = this._getDateDatepicker(target, true);
7276                         minDate = this._getMinMaxDate(inst, "min");
7277                         maxDate = this._getMinMaxDate(inst, "max");
7278                         extendRemove(inst.settings, settings);
7279                         // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
7280                         if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) {
7281                                 inst.settings.minDate = this._formatDate(inst, minDate);
7282                         }
7283                         if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) {
7284                                 inst.settings.maxDate = this._formatDate(inst, maxDate);
7285                         }
7286                         if ( "disabled" in settings ) {
7287                                 if ( settings.disabled ) {
7288                                         this._disableDatepicker(target);
7289                                 } else {
7290                                         this._enableDatepicker(target);
7291                                 }
7292                         }
7293                         this._attachments($(target), inst);
7294                         this._autoSize(inst);
7295                         this._setDate(inst, date);
7296                         this._updateAlternate(inst);
7297                         this._updateDatepicker(inst);
7298                 }
7299         },
7300
7301         // change method deprecated
7302         _changeDatepicker: function(target, name, value) {
7303                 this._optionDatepicker(target, name, value);
7304         },
7305
7306         /* Redraw the date picker attached to an input field or division.
7307          * @param  target  element - the target input field or division or span
7308          */
7309         _refreshDatepicker: function(target) {
7310                 var inst = this._getInst(target);
7311                 if (inst) {
7312                         this._updateDatepicker(inst);
7313                 }
7314         },
7315
7316         /* Set the dates for a jQuery selection.
7317          * @param  target element - the target input field or division or span
7318          * @param  date Date - the new date
7319          */
7320         _setDateDatepicker: function(target, date) {
7321                 var inst = this._getInst(target);
7322                 if (inst) {
7323                         this._setDate(inst, date);
7324                         this._updateDatepicker(inst);
7325                         this._updateAlternate(inst);
7326                 }
7327         },
7328
7329         /* Get the date(s) for the first entry in a jQuery selection.
7330          * @param  target element - the target input field or division or span
7331          * @param  noDefault boolean - true if no default date is to be used
7332          * @return Date - the current date
7333          */
7334         _getDateDatepicker: function(target, noDefault) {
7335                 var inst = this._getInst(target);
7336                 if (inst && !inst.inline) {
7337                         this._setDateFromField(inst, noDefault);
7338                 }
7339                 return (inst ? this._getDate(inst) : null);
7340         },
7341
7342         /* Handle keystrokes. */
7343         _doKeyDown: function(event) {
7344                 var onSelect, dateStr, sel,
7345                         inst = $.datepicker._getInst(event.target),
7346                         handled = true,
7347                         isRTL = inst.dpDiv.is(".ui-datepicker-rtl");
7348
7349                 inst._keyEvent = true;
7350                 if ($.datepicker._datepickerShowing) {
7351                         switch (event.keyCode) {
7352                                 case 9: $.datepicker._hideDatepicker();
7353                                                 handled = false;
7354                                                 break; // hide on tab out
7355                                 case 13: sel = $("td." + $.datepicker._dayOverClass + ":not(." +
7356                                                                         $.datepicker._currentClass + ")", inst.dpDiv);
7357                                                 if (sel[0]) {
7358                                                         $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
7359                                                 }
7360
7361                                                 onSelect = $.datepicker._get(inst, "onSelect");
7362                                                 if (onSelect) {
7363                                                         dateStr = $.datepicker._formatDate(inst);
7364
7365                                                         // trigger custom callback
7366                                                         onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);
7367                                                 } else {
7368                                                         $.datepicker._hideDatepicker();
7369                                                 }
7370
7371                                                 return false; // don't submit the form
7372                                 case 27: $.datepicker._hideDatepicker();
7373                                                 break; // hide on escape
7374                                 case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
7375                                                         -$.datepicker._get(inst, "stepBigMonths") :
7376                                                         -$.datepicker._get(inst, "stepMonths")), "M");
7377                                                 break; // previous month/year on page up/+ ctrl
7378                                 case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
7379                                                         +$.datepicker._get(inst, "stepBigMonths") :
7380                                                         +$.datepicker._get(inst, "stepMonths")), "M");
7381                                                 break; // next month/year on page down/+ ctrl
7382                                 case 35: if (event.ctrlKey || event.metaKey) {
7383                                                         $.datepicker._clearDate(event.target);
7384                                                 }
7385                                                 handled = event.ctrlKey || event.metaKey;
7386                                                 break; // clear on ctrl or command +end
7387                                 case 36: if (event.ctrlKey || event.metaKey) {
7388                                                         $.datepicker._gotoToday(event.target);
7389                                                 }
7390                                                 handled = event.ctrlKey || event.metaKey;
7391                                                 break; // current on ctrl or command +home
7392                                 case 37: if (event.ctrlKey || event.metaKey) {
7393                                                         $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), "D");
7394                                                 }
7395                                                 handled = event.ctrlKey || event.metaKey;
7396                                                 // -1 day on ctrl or command +left
7397                                                 if (event.originalEvent.altKey) {
7398                                                         $.datepicker._adjustDate(event.target, (event.ctrlKey ?
7399                                                                 -$.datepicker._get(inst, "stepBigMonths") :
7400                                                                 -$.datepicker._get(inst, "stepMonths")), "M");
7401                                                 }
7402                                                 // next month/year on alt +left on Mac
7403                                                 break;
7404                                 case 38: if (event.ctrlKey || event.metaKey) {
7405                                                         $.datepicker._adjustDate(event.target, -7, "D");
7406                                                 }
7407                                                 handled = event.ctrlKey || event.metaKey;
7408                                                 break; // -1 week on ctrl or command +up
7409                                 case 39: if (event.ctrlKey || event.metaKey) {
7410                                                         $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), "D");
7411                                                 }
7412                                                 handled = event.ctrlKey || event.metaKey;
7413                                                 // +1 day on ctrl or command +right
7414                                                 if (event.originalEvent.altKey) {
7415                                                         $.datepicker._adjustDate(event.target, (event.ctrlKey ?
7416                                                                 +$.datepicker._get(inst, "stepBigMonths") :
7417                                                                 +$.datepicker._get(inst, "stepMonths")), "M");
7418                                                 }
7419                                                 // next month/year on alt +right
7420                                                 break;
7421                                 case 40: if (event.ctrlKey || event.metaKey) {
7422                                                         $.datepicker._adjustDate(event.target, +7, "D");
7423                                                 }
7424                                                 handled = event.ctrlKey || event.metaKey;
7425                                                 break; // +1 week on ctrl or command +down
7426                                 default: handled = false;
7427                         }
7428                 } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home
7429                         $.datepicker._showDatepicker(this);
7430                 } else {
7431                         handled = false;
7432                 }
7433
7434                 if (handled) {
7435                         event.preventDefault();
7436                         event.stopPropagation();
7437                 }
7438         },
7439
7440         /* Filter entered characters - based on date format. */
7441         _doKeyPress: function(event) {
7442                 var chars, chr,
7443                         inst = $.datepicker._getInst(event.target);
7444
7445                 if ($.datepicker._get(inst, "constrainInput")) {
7446                         chars = $.datepicker._possibleChars($.datepicker._get(inst, "dateFormat"));
7447                         chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode);
7448                         return event.ctrlKey || event.metaKey || (chr < " " || !chars || chars.indexOf(chr) > -1);
7449                 }
7450         },
7451
7452         /* Synchronise manual entry and field/alternate field. */
7453         _doKeyUp: function(event) {
7454                 var date,
7455                         inst = $.datepicker._getInst(event.target);
7456
7457                 if (inst.input.val() !== inst.lastVal) {
7458                         try {
7459                                 date = $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
7460                                         (inst.input ? inst.input.val() : null),
7461                                         $.datepicker._getFormatConfig(inst));
7462
7463                                 if (date) { // only if valid
7464                                         $.datepicker._setDateFromField(inst);
7465                                         $.datepicker._updateAlternate(inst);
7466                                         $.datepicker._updateDatepicker(inst);
7467                                 }
7468                         }
7469                         catch (err) {
7470                         }
7471                 }
7472                 return true;
7473         },
7474
7475         /* Pop-up the date picker for a given input field.
7476          * If false returned from beforeShow event handler do not show.
7477          * @param  input  element - the input field attached to the date picker or
7478          *                                      event - if triggered by focus
7479          */
7480         _showDatepicker: function(input) {
7481                 input = input.target || input;
7482                 if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger
7483                         input = $("input", input.parentNode)[0];
7484                 }
7485
7486                 if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here
7487                         return;
7488                 }
7489
7490                 var inst, beforeShow, beforeShowSettings, isFixed,
7491                         offset, showAnim, duration;
7492
7493                 inst = $.datepicker._getInst(input);
7494                 if ($.datepicker._curInst && $.datepicker._curInst !== inst) {
7495                         $.datepicker._curInst.dpDiv.stop(true, true);
7496                         if ( inst && $.datepicker._datepickerShowing ) {
7497                                 $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] );
7498                         }
7499                 }
7500
7501                 beforeShow = $.datepicker._get(inst, "beforeShow");
7502                 beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {};
7503                 if(beforeShowSettings === false){
7504                         return;
7505                 }
7506                 extendRemove(inst.settings, beforeShowSettings);
7507
7508                 inst.lastVal = null;
7509                 $.datepicker._lastInput = input;
7510                 $.datepicker._setDateFromField(inst);
7511
7512                 if ($.datepicker._inDialog) { // hide cursor
7513                         input.value = "";
7514                 }
7515                 if (!$.datepicker._pos) { // position below input
7516                         $.datepicker._pos = $.datepicker._findPos(input);
7517                         $.datepicker._pos[1] += input.offsetHeight; // add the height
7518                 }
7519
7520                 isFixed = false;
7521                 $(input).parents().each(function() {
7522                         isFixed |= $(this).css("position") === "fixed";
7523                         return !isFixed;
7524                 });
7525
7526                 offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
7527                 $.datepicker._pos = null;
7528                 //to avoid flashes on Firefox
7529                 inst.dpDiv.empty();
7530                 // determine sizing offscreen
7531                 inst.dpDiv.css({position: "absolute", display: "block", top: "-1000px"});
7532                 $.datepicker._updateDatepicker(inst);
7533                 // fix width for dynamic number of date pickers
7534                 // and adjust position before showing
7535                 offset = $.datepicker._checkOffset(inst, offset, isFixed);
7536                 inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
7537                         "static" : (isFixed ? "fixed" : "absolute")), display: "none",
7538                         left: offset.left + "px", top: offset.top + "px"});
7539
7540                 if (!inst.inline) {
7541                         showAnim = $.datepicker._get(inst, "showAnim");
7542                         duration = $.datepicker._get(inst, "duration");
7543                         inst.dpDiv.zIndex($(input).zIndex()+1);
7544                         $.datepicker._datepickerShowing = true;
7545
7546                         if ( $.effects && $.effects.effect[ showAnim ] ) {
7547                                 inst.dpDiv.show(showAnim, $.datepicker._get(inst, "showOptions"), duration);
7548                         } else {
7549                                 inst.dpDiv[showAnim || "show"](showAnim ? duration : null);
7550                         }
7551
7552                         if ( $.datepicker._shouldFocusInput( inst ) ) {
7553                                 inst.input.focus();
7554                         }
7555
7556                         $.datepicker._curInst = inst;
7557                 }
7558         },
7559
7560         /* Generate the date picker content. */
7561         _updateDatepicker: function(inst) {
7562                 this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
7563                 instActive = inst; // for delegate hover events
7564                 inst.dpDiv.empty().append(this._generateHTML(inst));
7565                 this._attachHandlers(inst);
7566                 inst.dpDiv.find("." + this._dayOverClass + " a").mouseover();
7567
7568                 var origyearshtml,
7569                         numMonths = this._getNumberOfMonths(inst),
7570                         cols = numMonths[1],
7571                         width = 17;
7572
7573                 inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width("");
7574                 if (cols > 1) {
7575                         inst.dpDiv.addClass("ui-datepicker-multi-" + cols).css("width", (width * cols) + "em");
7576                 }
7577                 inst.dpDiv[(numMonths[0] !== 1 || numMonths[1] !== 1 ? "add" : "remove") +
7578                         "Class"]("ui-datepicker-multi");
7579                 inst.dpDiv[(this._get(inst, "isRTL") ? "add" : "remove") +
7580                         "Class"]("ui-datepicker-rtl");
7581
7582                 if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
7583                         inst.input.focus();
7584                 }
7585
7586                 // deffered render of the years select (to avoid flashes on Firefox)
7587                 if( inst.yearshtml ){
7588                         origyearshtml = inst.yearshtml;
7589                         setTimeout(function(){
7590                                 //assure that inst.yearshtml didn't change.
7591                                 if( origyearshtml === inst.yearshtml && inst.yearshtml ){
7592                                         inst.dpDiv.find("select.ui-datepicker-year:first").replaceWith(inst.yearshtml);
7593                                 }
7594                                 origyearshtml = inst.yearshtml = null;
7595                         }, 0);
7596                 }
7597         },
7598
7599         // #6694 - don't focus the input if it's already focused
7600         // this breaks the change event in IE
7601         // Support: IE and jQuery <1.9
7602         _shouldFocusInput: function( inst ) {
7603                 return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
7604         },
7605
7606         /* Check positioning to remain on screen. */
7607         _checkOffset: function(inst, offset, isFixed) {
7608                 var dpWidth = inst.dpDiv.outerWidth(),
7609                         dpHeight = inst.dpDiv.outerHeight(),
7610                         inputWidth = inst.input ? inst.input.outerWidth() : 0,
7611                         inputHeight = inst.input ? inst.input.outerHeight() : 0,
7612                         viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()),
7613                         viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop());
7614
7615                 offset.left -= (this._get(inst, "isRTL") ? (dpWidth - inputWidth) : 0);
7616                 offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0;
7617                 offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
7618
7619                 // now check if datepicker is showing outside window viewport - move to a better place if so.
7620                 offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
7621                         Math.abs(offset.left + dpWidth - viewWidth) : 0);
7622                 offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
7623                         Math.abs(dpHeight + inputHeight) : 0);
7624
7625                 return offset;
7626         },
7627
7628         /* Find an object's position on the screen. */
7629         _findPos: function(obj) {
7630                 var position,
7631                         inst = this._getInst(obj),
7632                         isRTL = this._get(inst, "isRTL");
7633
7634                 while (obj && (obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden(obj))) {
7635                         obj = obj[isRTL ? "previousSibling" : "nextSibling"];
7636                 }
7637
7638                 position = $(obj).offset();
7639                 return [position.left, position.top];
7640         },
7641
7642         /* Hide the date picker from view.
7643          * @param  input  element - the input field attached to the date picker
7644          */
7645         _hideDatepicker: function(input) {
7646                 var showAnim, duration, postProcess, onClose,
7647                         inst = this._curInst;
7648
7649                 if (!inst || (input && inst !== $.data(input, PROP_NAME))) {
7650                         return;
7651                 }
7652
7653                 if (this._datepickerShowing) {
7654                         showAnim = this._get(inst, "showAnim");
7655                         duration = this._get(inst, "duration");
7656                         postProcess = function() {
7657                                 $.datepicker._tidyDialog(inst);
7658                         };
7659
7660                         // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
7661                         if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
7662                                 inst.dpDiv.hide(showAnim, $.datepicker._get(inst, "showOptions"), duration, postProcess);
7663                         } else {
7664                                 inst.dpDiv[(showAnim === "slideDown" ? "slideUp" :
7665                                         (showAnim === "fadeIn" ? "fadeOut" : "hide"))]((showAnim ? duration : null), postProcess);
7666                         }
7667
7668                         if (!showAnim) {
7669                                 postProcess();
7670                         }
7671                         this._datepickerShowing = false;
7672
7673                         onClose = this._get(inst, "onClose");
7674                         if (onClose) {
7675                                 onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]);
7676                         }
7677
7678                         this._lastInput = null;
7679                         if (this._inDialog) {
7680                                 this._dialogInput.css({ position: "absolute", left: "0", top: "-100px" });
7681                                 if ($.blockUI) {
7682                                         $.unblockUI();
7683                                         $("body").append(this.dpDiv);
7684                                 }
7685                         }
7686                         this._inDialog = false;
7687                 }
7688         },
7689
7690         /* Tidy up after a dialog display. */
7691         _tidyDialog: function(inst) {
7692                 inst.dpDiv.removeClass(this._dialogClass).unbind(".ui-datepicker-calendar");
7693         },
7694
7695         /* Close date picker if clicked elsewhere. */
7696         _checkExternalClick: function(event) {
7697                 if (!$.datepicker._curInst) {
7698                         return;
7699                 }
7700
7701                 var $target = $(event.target),
7702                         inst = $.datepicker._getInst($target[0]);
7703
7704                 if ( ( ( $target[0].id !== $.datepicker._mainDivId &&
7705                                 $target.parents("#" + $.datepicker._mainDivId).length === 0 &&
7706                                 !$target.hasClass($.datepicker.markerClassName) &&
7707                                 !$target.closest("." + $.datepicker._triggerClass).length &&
7708                                 $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) ||
7709                         ( $target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst ) ) {
7710                                 $.datepicker._hideDatepicker();
7711                 }
7712         },
7713
7714         /* Adjust one of the date sub-fields. */
7715         _adjustDate: function(id, offset, period) {
7716                 var target = $(id),
7717                         inst = this._getInst(target[0]);
7718
7719                 if (this._isDisabledDatepicker(target[0])) {
7720                         return;
7721                 }
7722                 this._adjustInstDate(inst, offset +
7723                         (period === "M" ? this._get(inst, "showCurrentAtPos") : 0), // undo positioning
7724                         period);
7725                 this._updateDatepicker(inst);
7726         },
7727
7728         /* Action for current link. */
7729         _gotoToday: function(id) {
7730                 var date,
7731                         target = $(id),
7732                         inst = this._getInst(target[0]);
7733
7734                 if (this._get(inst, "gotoCurrent") && inst.currentDay) {
7735                         inst.selectedDay = inst.currentDay;
7736                         inst.drawMonth = inst.selectedMonth = inst.currentMonth;
7737                         inst.drawYear = inst.selectedYear = inst.currentYear;
7738                 } else {
7739                         date = new Date();
7740                         inst.selectedDay = date.getDate();
7741                         inst.drawMonth = inst.selectedMonth = date.getMonth();
7742                         inst.drawYear = inst.selectedYear = date.getFullYear();
7743                 }
7744                 this._notifyChange(inst);
7745                 this._adjustDate(target);
7746         },
7747
7748         /* Action for selecting a new month/year. */
7749         _selectMonthYear: function(id, select, period) {
7750                 var target = $(id),
7751                         inst = this._getInst(target[0]);
7752
7753                 inst["selected" + (period === "M" ? "Month" : "Year")] =
7754                 inst["draw" + (period === "M" ? "Month" : "Year")] =
7755                         parseInt(select.options[select.selectedIndex].value,10);
7756
7757                 this._notifyChange(inst);
7758                 this._adjustDate(target);
7759         },
7760
7761         /* Action for selecting a day. */
7762         _selectDay: function(id, month, year, td) {
7763                 var inst,
7764                         target = $(id);
7765
7766                 if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
7767                         return;
7768                 }
7769
7770                 inst = this._getInst(target[0]);
7771                 inst.selectedDay = inst.currentDay = $("a", td).html();
7772                 inst.selectedMonth = inst.currentMonth = month;
7773                 inst.selectedYear = inst.currentYear = year;
7774                 this._selectDate(id, this._formatDate(inst,
7775                         inst.currentDay, inst.currentMonth, inst.currentYear));
7776         },
7777
7778         /* Erase the input field and hide the date picker. */
7779         _clearDate: function(id) {
7780                 var target = $(id);
7781                 this._selectDate(target, "");
7782         },
7783
7784         /* Update the input field with the selected date. */
7785         _selectDate: function(id, dateStr) {
7786                 var onSelect,
7787                         target = $(id),
7788                         inst = this._getInst(target[0]);
7789
7790                 dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
7791                 if (inst.input) {
7792                         inst.input.val(dateStr);
7793                 }
7794                 this._updateAlternate(inst);
7795
7796                 onSelect = this._get(inst, "onSelect");
7797                 if (onSelect) {
7798                         onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);  // trigger custom callback
7799                 } else if (inst.input) {
7800                         inst.input.trigger("change"); // fire the change event
7801                 }
7802
7803                 if (inst.inline){
7804                         this._updateDatepicker(inst);
7805                 } else {
7806                         this._hideDatepicker();
7807                         this._lastInput = inst.input[0];
7808                         if (typeof(inst.input[0]) !== "object") {
7809                                 inst.input.focus(); // restore focus
7810                         }
7811                         this._lastInput = null;
7812                 }
7813         },
7814
7815         /* Update any alternate field to synchronise with the main field. */
7816         _updateAlternate: function(inst) {
7817                 var altFormat, date, dateStr,
7818                         altField = this._get(inst, "altField");
7819
7820                 if (altField) { // update alternate field too
7821                         altFormat = this._get(inst, "altFormat") || this._get(inst, "dateFormat");
7822                         date = this._getDate(inst);
7823                         dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
7824                         $(altField).each(function() { $(this).val(dateStr); });
7825                 }
7826         },
7827
7828         /* Set as beforeShowDay function to prevent selection of weekends.
7829          * @param  date  Date - the date to customise
7830          * @return [boolean, string] - is this date selectable?, what is its CSS class?
7831          */
7832         noWeekends: function(date) {
7833                 var day = date.getDay();
7834                 return [(day > 0 && day < 6), ""];
7835         },
7836
7837         /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
7838          * @param  date  Date - the date to get the week for
7839          * @return  number - the number of the week within the year that contains this date
7840          */
7841         iso8601Week: function(date) {
7842                 var time,
7843                         checkDate = new Date(date.getTime());
7844
7845                 // Find Thursday of this week starting on Monday
7846                 checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
7847
7848                 time = checkDate.getTime();
7849                 checkDate.setMonth(0); // Compare with Jan 1
7850                 checkDate.setDate(1);
7851                 return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
7852         },
7853
7854         /* Parse a string value into a date object.
7855          * See formatDate below for the possible formats.
7856          *
7857          * @param  format string - the expected format of the date
7858          * @param  value string - the date in the above format
7859          * @param  settings Object - attributes include:
7860          *                                      shortYearCutoff  number - the cutoff year for determining the century (optional)
7861          *                                      dayNamesShort   string[7] - abbreviated names of the days from Sunday (optional)
7862          *                                      dayNames                string[7] - names of the days from Sunday (optional)
7863          *                                      monthNamesShort string[12] - abbreviated names of the months (optional)
7864          *                                      monthNames              string[12] - names of the months (optional)
7865          * @return  Date - the extracted date value or null if value is blank
7866          */
7867         parseDate: function (format, value, settings) {
7868                 if (format == null || value == null) {
7869                         throw "Invalid arguments";
7870                 }
7871
7872                 value = (typeof value === "object" ? value.toString() : value + "");
7873                 if (value === "") {
7874                         return null;
7875                 }
7876
7877                 var iFormat, dim, extra,
7878                         iValue = 0,
7879                         shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff,
7880                         shortYearCutoff = (typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
7881                                 new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)),
7882                         dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
7883                         dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
7884                         monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
7885                         monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
7886                         year = -1,
7887                         month = -1,
7888                         day = -1,
7889                         doy = -1,
7890                         literal = false,
7891                         date,
7892                         // Check whether a format character is doubled
7893                         lookAhead = function(match) {
7894                                 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
7895                                 if (matches) {
7896                                         iFormat++;
7897                                 }
7898                                 return matches;
7899                         },
7900                         // Extract a number from the string value
7901                         getNumber = function(match) {
7902                                 var isDoubled = lookAhead(match),
7903                                         size = (match === "@" ? 14 : (match === "!" ? 20 :
7904                                         (match === "y" && isDoubled ? 4 : (match === "o" ? 3 : 2)))),
7905                                         digits = new RegExp("^\\d{1," + size + "}"),
7906                                         num = value.substring(iValue).match(digits);
7907                                 if (!num) {
7908                                         throw "Missing number at position " + iValue;
7909                                 }
7910                                 iValue += num[0].length;
7911                                 return parseInt(num[0], 10);
7912                         },
7913                         // Extract a name from the string value and convert to an index
7914                         getName = function(match, shortNames, longNames) {
7915                                 var index = -1,
7916                                         names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
7917                                                 return [ [k, v] ];
7918                                         }).sort(function (a, b) {
7919                                                 return -(a[1].length - b[1].length);
7920                                         });
7921
7922                                 $.each(names, function (i, pair) {
7923                                         var name = pair[1];
7924                                         if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
7925                                                 index = pair[0];
7926                                                 iValue += name.length;
7927                                                 return false;
7928                                         }
7929                                 });
7930                                 if (index !== -1) {
7931                                         return index + 1;
7932                                 } else {
7933                                         throw "Unknown name at position " + iValue;
7934                                 }
7935                         },
7936                         // Confirm that a literal character matches the string value
7937                         checkLiteral = function() {
7938                                 if (value.charAt(iValue) !== format.charAt(iFormat)) {
7939                                         throw "Unexpected literal at position " + iValue;
7940                                 }
7941                                 iValue++;
7942                         };
7943
7944                 for (iFormat = 0; iFormat < format.length; iFormat++) {
7945                         if (literal) {
7946                                 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
7947                                         literal = false;
7948                                 } else {
7949                                         checkLiteral();
7950                                 }
7951                         } else {
7952                                 switch (format.charAt(iFormat)) {
7953                                         case "d":
7954                                                 day = getNumber("d");
7955                                                 break;
7956                                         case "D":
7957                                                 getName("D", dayNamesShort, dayNames);
7958                                                 break;
7959                                         case "o":
7960                                                 doy = getNumber("o");
7961                                                 break;
7962                                         case "m":
7963                                                 month = getNumber("m");
7964                                                 break;
7965                                         case "M":
7966                                                 month = getName("M", monthNamesShort, monthNames);
7967                                                 break;
7968                                         case "y":
7969                                                 year = getNumber("y");
7970                                                 break;
7971                                         case "@":
7972                                                 date = new Date(getNumber("@"));
7973                                                 year = date.getFullYear();
7974                                                 month = date.getMonth() + 1;
7975                                                 day = date.getDate();
7976                                                 break;
7977                                         case "!":
7978                                                 date = new Date((getNumber("!") - this._ticksTo1970) / 10000);
7979                                                 year = date.getFullYear();
7980                                                 month = date.getMonth() + 1;
7981                                                 day = date.getDate();
7982                                                 break;
7983                                         case "'":
7984                                                 if (lookAhead("'")){
7985                                                         checkLiteral();
7986                                                 } else {
7987                                                         literal = true;
7988                                                 }
7989                                                 break;
7990                                         default:
7991                                                 checkLiteral();
7992                                 }
7993                         }
7994                 }
7995
7996                 if (iValue < value.length){
7997                         extra = value.substr(iValue);
7998                         if (!/^\s+/.test(extra)) {
7999                                 throw "Extra/unparsed characters found in date: " + extra;
8000                         }
8001                 }
8002
8003                 if (year === -1) {
8004                         year = new Date().getFullYear();
8005                 } else if (year < 100) {
8006                         year += new Date().getFullYear() - new Date().getFullYear() % 100 +
8007                                 (year <= shortYearCutoff ? 0 : -100);
8008                 }
8009
8010                 if (doy > -1) {
8011                         month = 1;
8012                         day = doy;
8013                         do {
8014                                 dim = this._getDaysInMonth(year, month - 1);
8015                                 if (day <= dim) {
8016                                         break;
8017                                 }
8018                                 month++;
8019                                 day -= dim;
8020                         } while (true);
8021                 }
8022
8023                 date = this._daylightSavingAdjust(new Date(year, month - 1, day));
8024                 if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
8025                         throw "Invalid date"; // E.g. 31/02/00
8026                 }
8027                 return date;
8028         },
8029
8030         /* Standard date formats. */
8031         ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
8032         COOKIE: "D, dd M yy",
8033         ISO_8601: "yy-mm-dd",
8034         RFC_822: "D, d M y",
8035         RFC_850: "DD, dd-M-y",
8036         RFC_1036: "D, d M y",
8037         RFC_1123: "D, d M yy",
8038         RFC_2822: "D, d M yy",
8039         RSS: "D, d M y", // RFC 822
8040         TICKS: "!",
8041         TIMESTAMP: "@",
8042         W3C: "yy-mm-dd", // ISO 8601
8043
8044         _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
8045                 Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
8046
8047         /* Format a date object into a string value.
8048          * The format can be combinations of the following:
8049          * d  - day of month (no leading zero)
8050          * dd - day of month (two digit)
8051          * o  - day of year (no leading zeros)
8052          * oo - day of year (three digit)
8053          * D  - day name short
8054          * DD - day name long
8055          * m  - month of year (no leading zero)
8056          * mm - month of year (two digit)
8057          * M  - month name short
8058          * MM - month name long
8059          * y  - year (two digit)
8060          * yy - year (four digit)
8061          * @ - Unix timestamp (ms since 01/01/1970)
8062          * ! - Windows ticks (100ns since 01/01/0001)
8063          * "..." - literal text
8064          * '' - single quote
8065          *
8066          * @param  format string - the desired format of the date
8067          * @param  date Date - the date value to format
8068          * @param  settings Object - attributes include:
8069          *                                      dayNamesShort   string[7] - abbreviated names of the days from Sunday (optional)
8070          *                                      dayNames                string[7] - names of the days from Sunday (optional)
8071          *                                      monthNamesShort string[12] - abbreviated names of the months (optional)
8072          *                                      monthNames              string[12] - names of the months (optional)
8073          * @return  string - the date in the above format
8074          */
8075         formatDate: function (format, date, settings) {
8076                 if (!date) {
8077                         return "";
8078                 }
8079
8080                 var iFormat,
8081                         dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
8082                         dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
8083                         monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
8084                         monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
8085                         // Check whether a format character is doubled
8086                         lookAhead = function(match) {
8087                                 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
8088                                 if (matches) {
8089                                         iFormat++;
8090                                 }
8091                                 return matches;
8092                         },
8093                         // Format a number, with leading zero if necessary
8094                         formatNumber = function(match, value, len) {
8095                                 var num = "" + value;
8096                                 if (lookAhead(match)) {
8097                                         while (num.length < len) {
8098                                                 num = "0" + num;
8099                                         }
8100                                 }
8101                                 return num;
8102                         },
8103                         // Format a name, short or long as requested
8104                         formatName = function(match, value, shortNames, longNames) {
8105                                 return (lookAhead(match) ? longNames[value] : shortNames[value]);
8106                         },
8107                         output = "",
8108                         literal = false;
8109
8110                 if (date) {
8111                         for (iFormat = 0; iFormat < format.length; iFormat++) {
8112                                 if (literal) {
8113                                         if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
8114                                                 literal = false;
8115                                         } else {
8116                                                 output += format.charAt(iFormat);
8117                                         }
8118                                 } else {
8119                                         switch (format.charAt(iFormat)) {
8120                                                 case "d":
8121                                                         output += formatNumber("d", date.getDate(), 2);
8122                                                         break;
8123                                                 case "D":
8124                                                         output += formatName("D", date.getDay(), dayNamesShort, dayNames);
8125                                                         break;
8126                                                 case "o":
8127                                                         output += formatNumber("o",
8128                                                                 Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
8129                                                         break;
8130                                                 case "m":
8131                                                         output += formatNumber("m", date.getMonth() + 1, 2);
8132                                                         break;
8133                                                 case "M":
8134                                                         output += formatName("M", date.getMonth(), monthNamesShort, monthNames);
8135                                                         break;
8136                                                 case "y":
8137                                                         output += (lookAhead("y") ? date.getFullYear() :
8138                                                                 (date.getYear() % 100 < 10 ? "0" : "") + date.getYear() % 100);
8139                                                         break;
8140                                                 case "@":
8141                                                         output += date.getTime();
8142                                                         break;
8143                                                 case "!":
8144                                                         output += date.getTime() * 10000 + this._ticksTo1970;
8145                                                         break;
8146                                                 case "'":
8147                                                         if (lookAhead("'")) {
8148                                                                 output += "'";
8149                                                         } else {
8150                                                                 literal = true;
8151                                                         }
8152                                                         break;
8153                                                 default:
8154                                                         output += format.charAt(iFormat);
8155                                         }
8156                                 }
8157                         }
8158                 }
8159                 return output;
8160         },
8161
8162         /* Extract all possible characters from the date format. */
8163         _possibleChars: function (format) {
8164                 var iFormat,
8165                         chars = "",
8166                         literal = false,
8167                         // Check whether a format character is doubled
8168                         lookAhead = function(match) {
8169                                 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
8170                                 if (matches) {
8171                                         iFormat++;
8172                                 }
8173                                 return matches;
8174                         };
8175
8176                 for (iFormat = 0; iFormat < format.length; iFormat++) {
8177                         if (literal) {
8178                                 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
8179                                         literal = false;
8180                                 } else {
8181                                         chars += format.charAt(iFormat);
8182                                 }
8183                         } else {
8184                                 switch (format.charAt(iFormat)) {
8185                                         case "d": case "m": case "y": case "@":
8186                                                 chars += "0123456789";
8187                                                 break;
8188                                         case "D": case "M":
8189                                                 return null; // Accept anything
8190                                         case "'":
8191                                                 if (lookAhead("'")) {
8192                                                         chars += "'";
8193                                                 } else {
8194                                                         literal = true;
8195                                                 }
8196                                                 break;
8197                                         default:
8198                                                 chars += format.charAt(iFormat);
8199                                 }
8200                         }
8201                 }
8202                 return chars;
8203         },
8204
8205         /* Get a setting value, defaulting if necessary. */
8206         _get: function(inst, name) {
8207                 return inst.settings[name] !== undefined ?
8208                         inst.settings[name] : this._defaults[name];
8209         },
8210
8211         /* Parse existing date and initialise date picker. */
8212         _setDateFromField: function(inst, noDefault) {
8213                 if (inst.input.val() === inst.lastVal) {
8214                         return;
8215                 }
8216
8217                 var dateFormat = this._get(inst, "dateFormat"),
8218                         dates = inst.lastVal = inst.input ? inst.input.val() : null,
8219                         defaultDate = this._getDefaultDate(inst),
8220                         date = defaultDate,
8221                         settings = this._getFormatConfig(inst);
8222
8223                 try {
8224                         date = this.parseDate(dateFormat, dates, settings) || defaultDate;
8225                 } catch (event) {
8226                         dates = (noDefault ? "" : dates);
8227                 }
8228                 inst.selectedDay = date.getDate();
8229                 inst.drawMonth = inst.selectedMonth = date.getMonth();
8230                 inst.drawYear = inst.selectedYear = date.getFullYear();
8231                 inst.currentDay = (dates ? date.getDate() : 0);
8232                 inst.currentMonth = (dates ? date.getMonth() : 0);
8233                 inst.currentYear = (dates ? date.getFullYear() : 0);
8234                 this._adjustInstDate(inst);
8235         },
8236
8237         /* Retrieve the default date shown on opening. */
8238         _getDefaultDate: function(inst) {
8239                 return this._restrictMinMax(inst,
8240                         this._determineDate(inst, this._get(inst, "defaultDate"), new Date()));
8241         },
8242
8243         /* A date may be specified as an exact value or a relative one. */
8244         _determineDate: function(inst, date, defaultDate) {
8245                 var offsetNumeric = function(offset) {
8246                                 var date = new Date();
8247                                 date.setDate(date.getDate() + offset);
8248                                 return date;
8249                         },
8250                         offsetString = function(offset) {
8251                                 try {
8252                                         return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
8253                                                 offset, $.datepicker._getFormatConfig(inst));
8254                                 }
8255                                 catch (e) {
8256                                         // Ignore
8257                                 }
8258
8259                                 var date = (offset.toLowerCase().match(/^c/) ?
8260                                         $.datepicker._getDate(inst) : null) || new Date(),
8261                                         year = date.getFullYear(),
8262                                         month = date.getMonth(),
8263                                         day = date.getDate(),
8264                                         pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
8265                                         matches = pattern.exec(offset);
8266
8267                                 while (matches) {
8268                                         switch (matches[2] || "d") {
8269                                                 case "d" : case "D" :
8270                                                         day += parseInt(matches[1],10); break;
8271                                                 case "w" : case "W" :
8272                                                         day += parseInt(matches[1],10) * 7; break;
8273                                                 case "m" : case "M" :
8274                                                         month += parseInt(matches[1],10);
8275                                                         day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
8276                                                         break;
8277                                                 case "y": case "Y" :
8278                                                         year += parseInt(matches[1],10);
8279                                                         day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
8280                                                         break;
8281                                         }
8282                                         matches = pattern.exec(offset);
8283                                 }
8284                                 return new Date(year, month, day);
8285                         },
8286                         newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) :
8287                                 (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
8288
8289                 newDate = (newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate);
8290                 if (newDate) {
8291                         newDate.setHours(0);
8292                         newDate.setMinutes(0);
8293                         newDate.setSeconds(0);
8294                         newDate.setMilliseconds(0);
8295                 }
8296                 return this._daylightSavingAdjust(newDate);
8297         },
8298
8299         /* Handle switch to/from daylight saving.
8300          * Hours may be non-zero on daylight saving cut-over:
8301          * > 12 when midnight changeover, but then cannot generate
8302          * midnight datetime, so jump to 1AM, otherwise reset.
8303          * @param  date  (Date) the date to check
8304          * @return  (Date) the corrected date
8305          */
8306         _daylightSavingAdjust: function(date) {
8307                 if (!date) {
8308                         return null;
8309                 }
8310                 date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
8311                 return date;
8312         },
8313
8314         /* Set the date(s) directly. */
8315         _setDate: function(inst, date, noChange) {
8316                 var clear = !date,
8317                         origMonth = inst.selectedMonth,
8318                         origYear = inst.selectedYear,
8319                         newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
8320
8321                 inst.selectedDay = inst.currentDay = newDate.getDate();
8322                 inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
8323                 inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
8324                 if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) {
8325                         this._notifyChange(inst);
8326                 }
8327                 this._adjustInstDate(inst);
8328                 if (inst.input) {
8329                         inst.input.val(clear ? "" : this._formatDate(inst));
8330                 }
8331         },
8332
8333         /* Retrieve the date(s) directly. */
8334         _getDate: function(inst) {
8335                 var startDate = (!inst.currentYear || (inst.input && inst.input.val() === "") ? null :
8336                         this._daylightSavingAdjust(new Date(
8337                         inst.currentYear, inst.currentMonth, inst.currentDay)));
8338                         return startDate;
8339         },
8340
8341         /* Attach the onxxx handlers.  These are declared statically so
8342          * they work with static code transformers like Caja.
8343          */
8344         _attachHandlers: function(inst) {
8345                 var stepMonths = this._get(inst, "stepMonths"),
8346                         id = "#" + inst.id.replace( /\\\\/g, "\\" );
8347                 inst.dpDiv.find("[data-handler]").map(function () {
8348                         var handler = {
8349                                 prev: function () {
8350                                         $.datepicker._adjustDate(id, -stepMonths, "M");
8351                                 },
8352                                 next: function () {
8353                                         $.datepicker._adjustDate(id, +stepMonths, "M");
8354                                 },
8355                                 hide: function () {
8356                                         $.datepicker._hideDatepicker();
8357                                 },
8358                                 today: function () {
8359                                         $.datepicker._gotoToday(id);
8360                                 },
8361                                 selectDay: function () {
8362                                         $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this);
8363                                         return false;
8364                                 },
8365                                 selectMonth: function () {
8366                                         $.datepicker._selectMonthYear(id, this, "M");
8367                                         return false;
8368                                 },
8369                                 selectYear: function () {
8370                                         $.datepicker._selectMonthYear(id, this, "Y");
8371                                         return false;
8372                                 }
8373                         };
8374                         $(this).bind(this.getAttribute("data-event"), handler[this.getAttribute("data-handler")]);
8375                 });
8376         },
8377
8378         /* Generate the HTML for the current state of the date picker. */
8379         _generateHTML: function(inst) {
8380                 var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
8381                         controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
8382                         monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
8383                         selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
8384                         cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
8385                         printDate, dRow, tbody, daySettings, otherMonth, unselectable,
8386                         tempDate = new Date(),
8387                         today = this._daylightSavingAdjust(
8388                                 new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time
8389                         isRTL = this._get(inst, "isRTL"),
8390                         showButtonPanel = this._get(inst, "showButtonPanel"),
8391                         hideIfNoPrevNext = this._get(inst, "hideIfNoPrevNext"),
8392                         navigationAsDateFormat = this._get(inst, "navigationAsDateFormat"),
8393                         numMonths = this._getNumberOfMonths(inst),
8394                         showCurrentAtPos = this._get(inst, "showCurrentAtPos"),
8395                         stepMonths = this._get(inst, "stepMonths"),
8396                         isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1),
8397                         currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
8398                                 new Date(inst.currentYear, inst.currentMonth, inst.currentDay))),
8399                         minDate = this._getMinMaxDate(inst, "min"),
8400                         maxDate = this._getMinMaxDate(inst, "max"),
8401                         drawMonth = inst.drawMonth - showCurrentAtPos,
8402                         drawYear = inst.drawYear;
8403
8404                 if (drawMonth < 0) {
8405                         drawMonth += 12;
8406                         drawYear--;
8407                 }
8408                 if (maxDate) {
8409                         maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
8410                                 maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
8411                         maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
8412                         while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
8413                                 drawMonth--;
8414                                 if (drawMonth < 0) {
8415                                         drawMonth = 11;
8416                                         drawYear--;
8417                                 }
8418                         }
8419                 }
8420                 inst.drawMonth = drawMonth;
8421                 inst.drawYear = drawYear;
8422
8423                 prevText = this._get(inst, "prevText");
8424                 prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
8425                         this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
8426                         this._getFormatConfig(inst)));
8427
8428                 prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
8429                         "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" +
8430                         " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" :
8431                         (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>"));
8432
8433                 nextText = this._get(inst, "nextText");
8434                 nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
8435                         this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
8436                         this._getFormatConfig(inst)));
8437
8438                 next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
8439                         "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" +
8440                         " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" :
8441                         (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>"));
8442
8443                 currentText = this._get(inst, "currentText");
8444                 gotoDate = (this._get(inst, "gotoCurrent") && inst.currentDay ? currentDate : today);
8445                 currentText = (!navigationAsDateFormat ? currentText :
8446                         this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
8447
8448                 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'>" +
8449                         this._get(inst, "closeText") + "</button>" : "");
8450
8451                 buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") +
8452                         (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'" +
8453                         ">" + currentText + "</button>" : "") + (isRTL ? "" : controls) + "</div>" : "";
8454
8455                 firstDay = parseInt(this._get(inst, "firstDay"),10);
8456                 firstDay = (isNaN(firstDay) ? 0 : firstDay);
8457
8458                 showWeek = this._get(inst, "showWeek");
8459                 dayNames = this._get(inst, "dayNames");
8460                 dayNamesMin = this._get(inst, "dayNamesMin");
8461                 monthNames = this._get(inst, "monthNames");
8462                 monthNamesShort = this._get(inst, "monthNamesShort");
8463                 beforeShowDay = this._get(inst, "beforeShowDay");
8464                 showOtherMonths = this._get(inst, "showOtherMonths");
8465                 selectOtherMonths = this._get(inst, "selectOtherMonths");
8466                 defaultDate = this._getDefaultDate(inst);
8467                 html = "";
8468                 dow;
8469                 for (row = 0; row < numMonths[0]; row++) {
8470                         group = "";
8471                         this.maxRows = 4;
8472                         for (col = 0; col < numMonths[1]; col++) {
8473                                 selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
8474                                 cornerClass = " ui-corner-all";
8475                                 calender = "";
8476                                 if (isMultiMonth) {
8477                                         calender += "<div class='ui-datepicker-group";
8478                                         if (numMonths[1] > 1) {
8479                                                 switch (col) {
8480                                                         case 0: calender += " ui-datepicker-group-first";
8481                                                                 cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
8482                                                         case numMonths[1]-1: calender += " ui-datepicker-group-last";
8483                                                                 cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;
8484                                                         default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
8485                                                 }
8486                                         }
8487                                         calender += "'>";
8488                                 }
8489                                 calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
8490                                         (/all|left/.test(cornerClass) && row === 0 ? (isRTL ? next : prev) : "") +
8491                                         (/all|right/.test(cornerClass) && row === 0 ? (isRTL ? prev : next) : "") +
8492                                         this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
8493                                         row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
8494                                         "</div><table class='ui-datepicker-calendar'><thead>" +
8495                                         "<tr>";
8496                                 thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : "");
8497                                 for (dow = 0; dow < 7; dow++) { // days of the week
8498                                         day = (dow + firstDay) % 7;
8499                                         thead += "<th" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" +
8500                                                 "<span title='" + dayNames[day] + "'>" + dayNamesMin[day] + "</span></th>";
8501                                 }
8502                                 calender += thead + "</tr></thead><tbody>";
8503                                 daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
8504                                 if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) {
8505                                         inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
8506                                 }
8507                                 leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
8508                                 curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
8509                                 numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043)
8510                                 this.maxRows = numRows;
8511                                 printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
8512                                 for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows
8513                                         calender += "<tr>";
8514                                         tbody = (!showWeek ? "" : "<td class='ui-datepicker-week-col'>" +
8515                                                 this._get(inst, "calculateWeek")(printDate) + "</td>");
8516                                         for (dow = 0; dow < 7; dow++) { // create date picker days
8517                                                 daySettings = (beforeShowDay ?
8518                                                         beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, ""]);
8519                                                 otherMonth = (printDate.getMonth() !== drawMonth);
8520                                                 unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
8521                                                         (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
8522                                                 tbody += "<td class='" +
8523                                                         ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends
8524                                                         (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months
8525                                                         ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key
8526                                                         (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ?
8527                                                         // or defaultDate is current printedDate and defaultDate is selectedDate
8528                                                         " " + this._dayOverClass : "") + // highlight selected day
8529                                                         (unselectable ? " " + this._unselectableClass + " ui-state-disabled": "") +  // highlight unselectable days
8530                                                         (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates
8531                                                         (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day
8532                                                         (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different)
8533                                                         ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "&#39;") + "'" : "") + // cell title
8534                                                         (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions
8535                                                         (otherMonth && !showOtherMonths ? "&#xa0;" : // display for other months
8536                                                         (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
8537                                                         (printDate.getTime() === today.getTime() ? " ui-state-highlight" : "") +
8538                                                         (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day
8539                                                         (otherMonth ? " ui-priority-secondary" : "") + // distinguish dates from other months
8540                                                         "' href='#'>" + printDate.getDate() + "</a>")) + "</td>"; // display selectable date
8541                                                 printDate.setDate(printDate.getDate() + 1);
8542                                                 printDate = this._daylightSavingAdjust(printDate);
8543                                         }
8544                                         calender += tbody + "</tr>";
8545                                 }
8546                                 drawMonth++;
8547                                 if (drawMonth > 11) {
8548                                         drawMonth = 0;
8549                                         drawYear++;
8550                                 }
8551                                 calender += "</tbody></table>" + (isMultiMonth ? "</div>" +
8552                                                         ((numMonths[0] > 0 && col === numMonths[1]-1) ? "<div class='ui-datepicker-row-break'></div>" : "") : "");
8553                                 group += calender;
8554                         }
8555                         html += group;
8556                 }
8557                 html += buttonPanel;
8558                 inst._keyEvent = false;
8559                 return html;
8560         },
8561
8562         /* Generate the month and year header. */
8563         _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
8564                         secondary, monthNames, monthNamesShort) {
8565
8566                 var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
8567                         changeMonth = this._get(inst, "changeMonth"),
8568                         changeYear = this._get(inst, "changeYear"),
8569                         showMonthAfterYear = this._get(inst, "showMonthAfterYear"),
8570                         html = "<div class='ui-datepicker-title'>",
8571                         monthHtml = "";
8572
8573                 // month selection
8574                 if (secondary || !changeMonth) {
8575                         monthHtml += "<span class='ui-datepicker-month'>" + monthNames[drawMonth] + "</span>";
8576                 } else {
8577                         inMinYear = (minDate && minDate.getFullYear() === drawYear);
8578                         inMaxYear = (maxDate && maxDate.getFullYear() === drawYear);
8579                         monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
8580                         for ( month = 0; month < 12; month++) {
8581                                 if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) {
8582                                         monthHtml += "<option value='" + month + "'" +
8583                                                 (month === drawMonth ? " selected='selected'" : "") +
8584                                                 ">" + monthNamesShort[month] + "</option>";
8585                                 }
8586                         }
8587                         monthHtml += "</select>";
8588                 }
8589
8590                 if (!showMonthAfterYear) {
8591                         html += monthHtml + (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "");
8592                 }
8593
8594                 // year selection
8595                 if ( !inst.yearshtml ) {
8596                         inst.yearshtml = "";
8597                         if (secondary || !changeYear) {
8598                                 html += "<span class='ui-datepicker-year'>" + drawYear + "</span>";
8599                         } else {
8600                                 // determine range of years to display
8601                                 years = this._get(inst, "yearRange").split(":");
8602                                 thisYear = new Date().getFullYear();
8603                                 determineYear = function(value) {
8604                                         var year = (value.match(/c[+\-].*/) ? drawYear + parseInt(value.substring(1), 10) :
8605                                                 (value.match(/[+\-].*/) ? thisYear + parseInt(value, 10) :
8606                                                 parseInt(value, 10)));
8607                                         return (isNaN(year) ? thisYear : year);
8608                                 };
8609                                 year = determineYear(years[0]);
8610                                 endYear = Math.max(year, determineYear(years[1] || ""));
8611                                 year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
8612                                 endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
8613                                 inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
8614                                 for (; year <= endYear; year++) {
8615                                         inst.yearshtml += "<option value='" + year + "'" +
8616                                                 (year === drawYear ? " selected='selected'" : "") +
8617                                                 ">" + year + "</option>";
8618                                 }
8619                                 inst.yearshtml += "</select>";
8620
8621                                 html += inst.yearshtml;
8622                                 inst.yearshtml = null;
8623                         }
8624                 }
8625
8626                 html += this._get(inst, "yearSuffix");
8627                 if (showMonthAfterYear) {
8628                         html += (secondary || !(changeMonth && changeYear) ? "&#xa0;" : "") + monthHtml;
8629                 }
8630                 html += "</div>"; // Close datepicker_header
8631                 return html;
8632         },
8633
8634         /* Adjust one of the date sub-fields. */
8635         _adjustInstDate: function(inst, offset, period) {
8636                 var year = inst.drawYear + (period === "Y" ? offset : 0),
8637                         month = inst.drawMonth + (period === "M" ? offset : 0),
8638                         day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0),
8639                         date = this._restrictMinMax(inst, this._daylightSavingAdjust(new Date(year, month, day)));
8640
8641                 inst.selectedDay = date.getDate();
8642                 inst.drawMonth = inst.selectedMonth = date.getMonth();
8643                 inst.drawYear = inst.selectedYear = date.getFullYear();
8644                 if (period === "M" || period === "Y") {
8645                         this._notifyChange(inst);
8646                 }
8647         },
8648
8649         /* Ensure a date is within any min/max bounds. */
8650         _restrictMinMax: function(inst, date) {
8651                 var minDate = this._getMinMaxDate(inst, "min"),
8652                         maxDate = this._getMinMaxDate(inst, "max"),
8653                         newDate = (minDate && date < minDate ? minDate : date);
8654                 return (maxDate && newDate > maxDate ? maxDate : newDate);
8655         },
8656
8657         /* Notify change of month/year. */
8658         _notifyChange: function(inst) {
8659                 var onChange = this._get(inst, "onChangeMonthYear");
8660                 if (onChange) {
8661                         onChange.apply((inst.input ? inst.input[0] : null),
8662                                 [inst.selectedYear, inst.selectedMonth + 1, inst]);
8663                 }
8664         },
8665
8666         /* Determine the number of months to show. */
8667         _getNumberOfMonths: function(inst) {
8668                 var numMonths = this._get(inst, "numberOfMonths");
8669                 return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths));
8670         },
8671
8672         /* Determine the current maximum date - ensure no time components are set. */
8673         _getMinMaxDate: function(inst, minMax) {
8674                 return this._determineDate(inst, this._get(inst, minMax + "Date"), null);
8675         },
8676
8677         /* Find the number of days in a given month. */
8678         _getDaysInMonth: function(year, month) {
8679                 return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate();
8680         },
8681
8682         /* Find the day of the week of the first of a month. */
8683         _getFirstDayOfMonth: function(year, month) {
8684                 return new Date(year, month, 1).getDay();
8685         },
8686
8687         /* Determines if we should allow a "next/prev" month display change. */
8688         _canAdjustMonth: function(inst, offset, curYear, curMonth) {
8689                 var numMonths = this._getNumberOfMonths(inst),
8690                         date = this._daylightSavingAdjust(new Date(curYear,
8691                         curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
8692
8693                 if (offset < 0) {
8694                         date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
8695                 }
8696                 return this._isInRange(inst, date);
8697         },
8698
8699         /* Is the given date in the accepted range? */
8700         _isInRange: function(inst, date) {
8701                 var yearSplit, currentYear,
8702                         minDate = this._getMinMaxDate(inst, "min"),
8703                         maxDate = this._getMinMaxDate(inst, "max"),
8704                         minYear = null,
8705                         maxYear = null,
8706                         years = this._get(inst, "yearRange");
8707                         if (years){
8708                                 yearSplit = years.split(":");
8709                                 currentYear = new Date().getFullYear();
8710                                 minYear = parseInt(yearSplit[0], 10);
8711                                 maxYear = parseInt(yearSplit[1], 10);
8712                                 if ( yearSplit[0].match(/[+\-].*/) ) {
8713                                         minYear += currentYear;
8714                                 }
8715                                 if ( yearSplit[1].match(/[+\-].*/) ) {
8716                                         maxYear += currentYear;
8717                                 }
8718                         }
8719
8720                 return ((!minDate || date.getTime() >= minDate.getTime()) &&
8721                         (!maxDate || date.getTime() <= maxDate.getTime()) &&
8722                         (!minYear || date.getFullYear() >= minYear) &&
8723                         (!maxYear || date.getFullYear() <= maxYear));
8724         },
8725
8726         /* Provide the configuration settings for formatting/parsing. */
8727         _getFormatConfig: function(inst) {
8728                 var shortYearCutoff = this._get(inst, "shortYearCutoff");
8729                 shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff :
8730                         new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
8731                 return {shortYearCutoff: shortYearCutoff,
8732                         dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"),
8733                         monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")};
8734         },
8735
8736         /* Format the given date for display. */
8737         _formatDate: function(inst, day, month, year) {
8738                 if (!day) {
8739                         inst.currentDay = inst.selectedDay;
8740                         inst.currentMonth = inst.selectedMonth;
8741                         inst.currentYear = inst.selectedYear;
8742                 }
8743                 var date = (day ? (typeof day === "object" ? day :
8744                         this._daylightSavingAdjust(new Date(year, month, day))) :
8745                         this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
8746                 return this.formatDate(this._get(inst, "dateFormat"), date, this._getFormatConfig(inst));
8747         }
8748 });
8749
8750 /*
8751  * Bind hover events for datepicker elements.
8752  * Done via delegate so the binding only occurs once in the lifetime of the parent div.
8753  * Global instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
8754  */
8755 function bindHover(dpDiv) {
8756         var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
8757         return dpDiv.delegate(selector, "mouseout", function() {
8758                         $(this).removeClass("ui-state-hover");
8759                         if (this.className.indexOf("ui-datepicker-prev") !== -1) {
8760                                 $(this).removeClass("ui-datepicker-prev-hover");
8761                         }
8762                         if (this.className.indexOf("ui-datepicker-next") !== -1) {
8763                                 $(this).removeClass("ui-datepicker-next-hover");
8764                         }
8765                 })
8766                 .delegate(selector, "mouseover", function(){
8767                         if (!$.datepicker._isDisabledDatepicker( instActive.inline ? dpDiv.parent()[0] : instActive.input[0])) {
8768                                 $(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover");
8769                                 $(this).addClass("ui-state-hover");
8770                                 if (this.className.indexOf("ui-datepicker-prev") !== -1) {
8771                                         $(this).addClass("ui-datepicker-prev-hover");
8772                                 }
8773                                 if (this.className.indexOf("ui-datepicker-next") !== -1) {
8774                                         $(this).addClass("ui-datepicker-next-hover");
8775                                 }
8776                         }
8777                 });
8778 }
8779
8780 /* jQuery extend now ignores nulls! */
8781 function extendRemove(target, props) {
8782         $.extend(target, props);
8783         for (var name in props) {
8784                 if (props[name] == null) {
8785                         target[name] = props[name];
8786                 }
8787         }
8788         return target;
8789 }
8790
8791 /* Invoke the datepicker functionality.
8792    @param  options  string - a command, optionally followed by additional parameters or
8793                                         Object - settings for attaching new datepicker functionality
8794    @return  jQuery object */
8795 $.fn.datepicker = function(options){
8796
8797         /* Verify an empty collection wasn't passed - Fixes #6976 */
8798         if ( !this.length ) {
8799                 return this;
8800         }
8801
8802         /* Initialise the date picker. */
8803         if (!$.datepicker.initialized) {
8804                 $(document).mousedown($.datepicker._checkExternalClick);
8805                 $.datepicker.initialized = true;
8806         }
8807
8808         /* Append datepicker main container to body if not exist. */
8809         if ($("#"+$.datepicker._mainDivId).length === 0) {
8810                 $("body").append($.datepicker.dpDiv);
8811         }
8812
8813         var otherArgs = Array.prototype.slice.call(arguments, 1);
8814         if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) {
8815                 return $.datepicker["_" + options + "Datepicker"].
8816                         apply($.datepicker, [this[0]].concat(otherArgs));
8817         }
8818         if (options === "option" && arguments.length === 2 && typeof arguments[1] === "string") {
8819                 return $.datepicker["_" + options + "Datepicker"].
8820                         apply($.datepicker, [this[0]].concat(otherArgs));
8821         }
8822         return this.each(function() {
8823                 typeof options === "string" ?
8824                         $.datepicker["_" + options + "Datepicker"].
8825                                 apply($.datepicker, [this].concat(otherArgs)) :
8826                         $.datepicker._attachDatepicker(this, options);
8827         });
8828 };
8829
8830 $.datepicker = new Datepicker(); // singleton instance
8831 $.datepicker.initialized = false;
8832 $.datepicker.uuid = new Date().getTime();
8833 $.datepicker.version = "1.10.3";
8834
8835 })(jQuery);
8836 (function( $, undefined ) {
8837
8838 var sizeRelatedOptions = {
8839                 buttons: true,
8840                 height: true,
8841                 maxHeight: true,
8842                 maxWidth: true,
8843                 minHeight: true,
8844                 minWidth: true,
8845                 width: true
8846         },
8847         resizableRelatedOptions = {
8848                 maxHeight: true,
8849                 maxWidth: true,
8850                 minHeight: true,
8851                 minWidth: true
8852         };
8853
8854 $.widget( "ui.dialog", {
8855         version: "1.10.3",
8856         options: {
8857                 appendTo: "body",
8858                 autoOpen: true,
8859                 buttons: [],
8860                 closeOnEscape: true,
8861                 closeText: "close",
8862                 dialogClass: "",
8863                 draggable: true,
8864                 hide: null,
8865                 height: "auto",
8866                 maxHeight: null,
8867                 maxWidth: null,
8868                 minHeight: 150,
8869                 minWidth: 150,
8870                 modal: false,
8871                 position: {
8872                         my: "center",
8873                         at: "center",
8874                         of: window,
8875                         collision: "fit",
8876                         // Ensure the titlebar is always visible
8877                         using: function( pos ) {
8878                                 var topOffset = $( this ).css( pos ).offset().top;
8879                                 if ( topOffset < 0 ) {
8880                                         $( this ).css( "top", pos.top - topOffset );
8881                                 }
8882                         }
8883                 },
8884                 resizable: true,
8885                 show: null,
8886                 title: null,
8887                 width: 300,
8888
8889                 // callbacks
8890                 beforeClose: null,
8891                 close: null,
8892                 drag: null,
8893                 dragStart: null,
8894                 dragStop: null,
8895                 focus: null,
8896                 open: null,
8897                 resize: null,
8898                 resizeStart: null,
8899                 resizeStop: null
8900         },
8901
8902         _create: function() {
8903                 this.originalCss = {
8904                         display: this.element[0].style.display,
8905                         width: this.element[0].style.width,
8906                         minHeight: this.element[0].style.minHeight,
8907                         maxHeight: this.element[0].style.maxHeight,
8908                         height: this.element[0].style.height
8909                 };
8910                 this.originalPosition = {
8911                         parent: this.element.parent(),
8912                         index: this.element.parent().children().index( this.element )
8913                 };
8914                 this.originalTitle = this.element.attr("title");
8915                 this.options.title = this.options.title || this.originalTitle;
8916
8917                 this._createWrapper();
8918
8919                 this.element
8920                         .show()
8921                         .removeAttr("title")
8922                         .addClass("ui-dialog-content ui-widget-content")
8923                         .appendTo( this.uiDialog );
8924
8925                 this._createTitlebar();
8926                 this._createButtonPane();
8927
8928                 if ( this.options.draggable && $.fn.draggable ) {
8929                         this._makeDraggable();
8930                 }
8931                 if ( this.options.resizable && $.fn.resizable ) {
8932                         this._makeResizable();
8933                 }
8934
8935                 this._isOpen = false;
8936         },
8937
8938         _init: function() {
8939                 if ( this.options.autoOpen ) {
8940                         this.open();
8941                 }
8942         },
8943
8944         _appendTo: function() {
8945                 var element = this.options.appendTo;
8946                 if ( element && (element.jquery || element.nodeType) ) {
8947                         return $( element );
8948                 }
8949                 return this.document.find( element || "body" ).eq( 0 );
8950         },
8951
8952         _destroy: function() {
8953                 var next,
8954                         originalPosition = this.originalPosition;
8955
8956                 this._destroyOverlay();
8957
8958                 this.element
8959                         .removeUniqueId()
8960                         .removeClass("ui-dialog-content ui-widget-content")
8961                         .css( this.originalCss )
8962                         // Without detaching first, the following becomes really slow
8963                         .detach();
8964
8965                 this.uiDialog.stop( true, true ).remove();
8966
8967                 if ( this.originalTitle ) {
8968                         this.element.attr( "title", this.originalTitle );
8969                 }
8970
8971                 next = originalPosition.parent.children().eq( originalPosition.index );
8972                 // Don't try to place the dialog next to itself (#8613)
8973                 if ( next.length && next[0] !== this.element[0] ) {
8974                         next.before( this.element );
8975                 } else {
8976                         originalPosition.parent.append( this.element );
8977                 }
8978         },
8979
8980         widget: function() {
8981                 return this.uiDialog;
8982         },
8983
8984         disable: $.noop,
8985         enable: $.noop,
8986
8987         close: function( event ) {
8988                 var that = this;
8989
8990                 if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {
8991                         return;
8992                 }
8993
8994                 this._isOpen = false;
8995                 this._destroyOverlay();
8996
8997                 if ( !this.opener.filter(":focusable").focus().length ) {
8998                         // Hiding a focused element doesn't trigger blur in WebKit
8999                         // so in case we have nothing to focus on, explicitly blur the active element
9000                         // https://bugs.webkit.org/show_bug.cgi?id=47182
9001                         $( this.document[0].activeElement ).blur();
9002                 }
9003
9004                 this._hide( this.uiDialog, this.options.hide, function() {
9005                         that._trigger( "close", event );
9006                 });
9007         },
9008
9009         isOpen: function() {
9010                 return this._isOpen;
9011         },
9012
9013         moveToTop: function() {
9014                 this._moveToTop();
9015         },
9016
9017         _moveToTop: function( event, silent ) {
9018                 var moved = !!this.uiDialog.nextAll(":visible").insertBefore( this.uiDialog ).length;
9019                 if ( moved && !silent ) {
9020                         this._trigger( "focus", event );
9021                 }
9022                 return moved;
9023         },
9024
9025         open: function() {
9026                 var that = this;
9027                 if ( this._isOpen ) {
9028                         if ( this._moveToTop() ) {
9029                                 this._focusTabbable();
9030                         }
9031                         return;
9032                 }
9033
9034                 this._isOpen = true;
9035                 this.opener = $( this.document[0].activeElement );
9036
9037                 this._size();
9038                 this._position();
9039                 this._createOverlay();
9040                 this._moveToTop( null, true );
9041                 this._show( this.uiDialog, this.options.show, function() {
9042                         that._focusTabbable();
9043                         that._trigger("focus");
9044                 });
9045
9046                 this._trigger("open");
9047         },
9048
9049         _focusTabbable: function() {
9050                 // Set focus to the first match:
9051                 // 1. First element inside the dialog matching [autofocus]
9052                 // 2. Tabbable element inside the content element
9053                 // 3. Tabbable element inside the buttonpane
9054                 // 4. The close button
9055                 // 5. The dialog itself
9056                 var hasFocus = this.element.find("[autofocus]");
9057                 if ( !hasFocus.length ) {
9058                         hasFocus = this.element.find(":tabbable");
9059                 }
9060                 if ( !hasFocus.length ) {
9061                         hasFocus = this.uiDialogButtonPane.find(":tabbable");
9062                 }
9063                 if ( !hasFocus.length ) {
9064                         hasFocus = this.uiDialogTitlebarClose.filter(":tabbable");
9065                 }
9066                 if ( !hasFocus.length ) {
9067                         hasFocus = this.uiDialog;
9068                 }
9069                 hasFocus.eq( 0 ).focus();
9070         },
9071
9072         _keepFocus: function( event ) {
9073                 function checkFocus() {
9074                         var activeElement = this.document[0].activeElement,
9075                                 isActive = this.uiDialog[0] === activeElement ||
9076                                         $.contains( this.uiDialog[0], activeElement );
9077                         if ( !isActive ) {
9078                                 this._focusTabbable();
9079                         }
9080                 }
9081                 event.preventDefault();
9082                 checkFocus.call( this );
9083                 // support: IE
9084                 // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
9085                 // so we check again later
9086                 this._delay( checkFocus );
9087         },
9088
9089         _createWrapper: function() {
9090                 this.uiDialog = $("<div>")
9091                         .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
9092                                 this.options.dialogClass )
9093                         .hide()
9094                         .attr({
9095                                 // Setting tabIndex makes the div focusable
9096                                 tabIndex: -1,
9097                                 role: "dialog"
9098                         })
9099                         .appendTo( this._appendTo() );
9100
9101                 this._on( this.uiDialog, {
9102                         keydown: function( event ) {
9103                                 if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
9104                                                 event.keyCode === $.ui.keyCode.ESCAPE ) {
9105                                         event.preventDefault();
9106                                         this.close( event );
9107                                         return;
9108                                 }
9109
9110                                 // prevent tabbing out of dialogs
9111                                 if ( event.keyCode !== $.ui.keyCode.TAB ) {
9112                                         return;
9113                                 }
9114                                 var tabbables = this.uiDialog.find(":tabbable"),
9115                                         first = tabbables.filter(":first"),
9116                                         last  = tabbables.filter(":last");
9117
9118                                 if ( ( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey ) {
9119                                         first.focus( 1 );
9120                                         event.preventDefault();
9121                                 } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) {
9122                                         last.focus( 1 );
9123                                         event.preventDefault();
9124                                 }
9125                         },
9126                         mousedown: function( event ) {
9127                                 if ( this._moveToTop( event ) ) {
9128                                         this._focusTabbable();
9129                                 }
9130                         }
9131                 });
9132
9133                 // We assume that any existing aria-describedby attribute means
9134                 // that the dialog content is marked up properly
9135                 // otherwise we brute force the content as the description
9136                 if ( !this.element.find("[aria-describedby]").length ) {
9137                         this.uiDialog.attr({
9138                                 "aria-describedby": this.element.uniqueId().attr("id")
9139                         });
9140                 }
9141         },
9142
9143         _createTitlebar: function() {
9144                 var uiDialogTitle;
9145
9146                 this.uiDialogTitlebar = $("<div>")
9147                         .addClass("ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix")
9148                         .prependTo( this.uiDialog );
9149                 this._on( this.uiDialogTitlebar, {
9150                         mousedown: function( event ) {
9151                                 // Don't prevent click on close button (#8838)
9152                                 // Focusing a dialog that is partially scrolled out of view
9153                                 // causes the browser to scroll it into view, preventing the click event
9154                                 if ( !$( event.target ).closest(".ui-dialog-titlebar-close") ) {
9155                                         // Dialog isn't getting focus when dragging (#8063)
9156                                         this.uiDialog.focus();
9157                                 }
9158                         }
9159                 });
9160
9161                 this.uiDialogTitlebarClose = $("<button></button>")
9162                         .button({
9163                                 label: this.options.closeText,
9164                                 icons: {
9165                                         primary: "ui-icon-closethick"
9166                                 },
9167                                 text: false
9168                         })
9169                         .addClass("ui-dialog-titlebar-close")
9170                         .appendTo( this.uiDialogTitlebar );
9171                 this._on( this.uiDialogTitlebarClose, {
9172                         click: function( event ) {
9173                                 event.preventDefault();
9174                                 this.close( event );
9175                         }
9176                 });
9177
9178                 uiDialogTitle = $("<span>")
9179                         .uniqueId()
9180                         .addClass("ui-dialog-title")
9181                         .prependTo( this.uiDialogTitlebar );
9182                 this._title( uiDialogTitle );
9183
9184                 this.uiDialog.attr({
9185                         "aria-labelledby": uiDialogTitle.attr("id")
9186                 });
9187         },
9188
9189         _title: function( title ) {
9190                 if ( !this.options.title ) {
9191                         title.html("&#160;");
9192                 }
9193                 title.text( this.options.title );
9194         },
9195
9196         _createButtonPane: function() {
9197                 this.uiDialogButtonPane = $("<div>")
9198                         .addClass("ui-dialog-buttonpane ui-widget-content ui-helper-clearfix");
9199
9200                 this.uiButtonSet = $("<div>")
9201                         .addClass("ui-dialog-buttonset")
9202                         .appendTo( this.uiDialogButtonPane );
9203
9204                 this._createButtons();
9205         },
9206
9207         _createButtons: function() {
9208                 var that = this,
9209                         buttons = this.options.buttons;
9210
9211                 // if we already have a button pane, remove it
9212                 this.uiDialogButtonPane.remove();
9213                 this.uiButtonSet.empty();
9214
9215                 if ( $.isEmptyObject( buttons ) || ($.isArray( buttons ) && !buttons.length) ) {
9216                         this.uiDialog.removeClass("ui-dialog-buttons");
9217                         return;
9218                 }
9219
9220                 $.each( buttons, function( name, props ) {
9221                         var click, buttonOptions;
9222                         props = $.isFunction( props ) ?
9223                                 { click: props, text: name } :
9224                                 props;
9225                         // Default to a non-submitting button
9226                         props = $.extend( { type: "button" }, props );
9227                         // Change the context for the click callback to be the main element
9228                         click = props.click;
9229                         props.click = function() {
9230                                 click.apply( that.element[0], arguments );
9231                         };
9232                         buttonOptions = {
9233                                 icons: props.icons,
9234                                 text: props.showText
9235                         };
9236                         delete props.icons;
9237                         delete props.showText;
9238                         $( "<button></button>", props )
9239                                 .button( buttonOptions )
9240                                 .appendTo( that.uiButtonSet );
9241                 });
9242                 this.uiDialog.addClass("ui-dialog-buttons");
9243                 this.uiDialogButtonPane.appendTo( this.uiDialog );
9244         },
9245
9246         _makeDraggable: function() {
9247                 var that = this,
9248                         options = this.options;
9249
9250                 function filteredUi( ui ) {
9251                         return {
9252                                 position: ui.position,
9253                                 offset: ui.offset
9254                         };
9255                 }
9256
9257                 this.uiDialog.draggable({
9258                         cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
9259                         handle: ".ui-dialog-titlebar",
9260                         containment: "document",
9261                         start: function( event, ui ) {
9262                                 $( this ).addClass("ui-dialog-dragging");
9263                                 that._blockFrames();
9264                                 that._trigger( "dragStart", event, filteredUi( ui ) );
9265                         },
9266                         drag: function( event, ui ) {
9267                                 that._trigger( "drag", event, filteredUi( ui ) );
9268                         },
9269                         stop: function( event, ui ) {
9270                                 options.position = [
9271                                         ui.position.left - that.document.scrollLeft(),
9272                                         ui.position.top - that.document.scrollTop()
9273                                 ];
9274                                 $( this ).removeClass("ui-dialog-dragging");
9275                                 that._unblockFrames();
9276                                 that._trigger( "dragStop", event, filteredUi( ui ) );
9277                         }
9278                 });
9279         },
9280
9281         _makeResizable: function() {
9282                 var that = this,
9283                         options = this.options,
9284                         handles = options.resizable,
9285                         // .ui-resizable has position: relative defined in the stylesheet
9286                         // but dialogs have to use absolute or fixed positioning
9287                         position = this.uiDialog.css("position"),
9288                         resizeHandles = typeof handles === "string" ?
9289                                 handles :
9290                                 "n,e,s,w,se,sw,ne,nw";
9291
9292                 function filteredUi( ui ) {
9293                         return {
9294                                 originalPosition: ui.originalPosition,
9295                                 originalSize: ui.originalSize,
9296                                 position: ui.position,
9297                                 size: ui.size
9298                         };
9299                 }
9300
9301                 this.uiDialog.resizable({
9302                         cancel: ".ui-dialog-content",
9303                         containment: "document",
9304                         alsoResize: this.element,
9305                         maxWidth: options.maxWidth,
9306                         maxHeight: options.maxHeight,
9307                         minWidth: options.minWidth,
9308                         minHeight: this._minHeight(),
9309                         handles: resizeHandles,
9310                         start: function( event, ui ) {
9311                                 $( this ).addClass("ui-dialog-resizing");
9312                                 that._blockFrames();
9313                                 that._trigger( "resizeStart", event, filteredUi( ui ) );
9314                         },
9315                         resize: function( event, ui ) {
9316                                 that._trigger( "resize", event, filteredUi( ui ) );
9317                         },
9318                         stop: function( event, ui ) {
9319                                 options.height = $( this ).height();
9320                                 options.width = $( this ).width();
9321                                 $( this ).removeClass("ui-dialog-resizing");
9322                                 that._unblockFrames();
9323                                 that._trigger( "resizeStop", event, filteredUi( ui ) );
9324                         }
9325                 })
9326                 .css( "position", position );
9327         },
9328
9329         _minHeight: function() {
9330                 var options = this.options;
9331
9332                 return options.height === "auto" ?
9333                         options.minHeight :
9334                         Math.min( options.minHeight, options.height );
9335         },
9336
9337         _position: function() {
9338                 // Need to show the dialog to get the actual offset in the position plugin
9339                 var isVisible = this.uiDialog.is(":visible");
9340                 if ( !isVisible ) {
9341                         this.uiDialog.show();
9342                 }
9343                 this.uiDialog.position( this.options.position );
9344                 if ( !isVisible ) {
9345                         this.uiDialog.hide();
9346                 }
9347         },
9348
9349         _setOptions: function( options ) {
9350                 var that = this,
9351                         resize = false,
9352                         resizableOptions = {};
9353
9354                 $.each( options, function( key, value ) {
9355                         that._setOption( key, value );
9356
9357                         if ( key in sizeRelatedOptions ) {
9358                                 resize = true;
9359                         }
9360                         if ( key in resizableRelatedOptions ) {
9361                                 resizableOptions[ key ] = value;
9362                         }
9363                 });
9364
9365                 if ( resize ) {
9366                         this._size();
9367                         this._position();
9368                 }
9369                 if ( this.uiDialog.is(":data(ui-resizable)") ) {
9370                         this.uiDialog.resizable( "option", resizableOptions );
9371                 }
9372         },
9373
9374         _setOption: function( key, value ) {
9375                 /*jshint maxcomplexity:15*/
9376                 var isDraggable, isResizable,
9377                         uiDialog = this.uiDialog;
9378
9379                 if ( key === "dialogClass" ) {
9380                         uiDialog
9381                                 .removeClass( this.options.dialogClass )
9382                                 .addClass( value );
9383                 }
9384
9385                 if ( key === "disabled" ) {
9386                         return;
9387                 }
9388
9389                 this._super( key, value );
9390
9391                 if ( key === "appendTo" ) {
9392                         this.uiDialog.appendTo( this._appendTo() );
9393                 }
9394
9395                 if ( key === "buttons" ) {
9396                         this._createButtons();
9397                 }
9398
9399                 if ( key === "closeText" ) {
9400                         this.uiDialogTitlebarClose.button({
9401                                 // Ensure that we always pass a string
9402                                 label: "" + value
9403                         });
9404                 }
9405
9406                 if ( key === "draggable" ) {
9407                         isDraggable = uiDialog.is(":data(ui-draggable)");
9408                         if ( isDraggable && !value ) {
9409                                 uiDialog.draggable("destroy");
9410                         }
9411
9412                         if ( !isDraggable && value ) {
9413                                 this._makeDraggable();
9414                         }
9415                 }
9416
9417                 if ( key === "position" ) {
9418                         this._position();
9419                 }
9420
9421                 if ( key === "resizable" ) {
9422                         // currently resizable, becoming non-resizable
9423                         isResizable = uiDialog.is(":data(ui-resizable)");
9424                         if ( isResizable && !value ) {
9425                                 uiDialog.resizable("destroy");
9426                         }
9427
9428                         // currently resizable, changing handles
9429                         if ( isResizable && typeof value === "string" ) {
9430                                 uiDialog.resizable( "option", "handles", value );
9431                         }
9432
9433                         // currently non-resizable, becoming resizable
9434                         if ( !isResizable && value !== false ) {
9435                                 this._makeResizable();
9436                         }
9437                 }
9438
9439                 if ( key === "title" ) {
9440                         this._title( this.uiDialogTitlebar.find(".ui-dialog-title") );
9441                 }
9442         },
9443
9444         _size: function() {
9445                 // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
9446                 // divs will both have width and height set, so we need to reset them
9447                 var nonContentHeight, minContentHeight, maxContentHeight,
9448                         options = this.options;
9449
9450                 // Reset content sizing
9451                 this.element.show().css({
9452                         width: "auto",
9453                         minHeight: 0,
9454                         maxHeight: "none",
9455                         height: 0
9456                 });
9457
9458                 if ( options.minWidth > options.width ) {
9459                         options.width = options.minWidth;
9460                 }
9461
9462                 // reset wrapper sizing
9463                 // determine the height of all the non-content elements
9464                 nonContentHeight = this.uiDialog.css({
9465                                 height: "auto",
9466                                 width: options.width
9467                         })
9468                         .outerHeight();
9469                 minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
9470                 maxContentHeight = typeof options.maxHeight === "number" ?
9471                         Math.max( 0, options.maxHeight - nonContentHeight ) :
9472                         "none";
9473
9474                 if ( options.height === "auto" ) {
9475                         this.element.css({
9476                                 minHeight: minContentHeight,
9477                                 maxHeight: maxContentHeight,
9478                                 height: "auto"
9479                         });
9480                 } else {
9481                         this.element.height( Math.max( 0, options.height - nonContentHeight ) );
9482                 }
9483
9484                 if (this.uiDialog.is(":data(ui-resizable)") ) {
9485                         this.uiDialog.resizable( "option", "minHeight", this._minHeight() );
9486                 }
9487         },
9488
9489         _blockFrames: function() {
9490                 this.iframeBlocks = this.document.find( "iframe" ).map(function() {
9491                         var iframe = $( this );
9492
9493                         return $( "<div>" )
9494                                 .css({
9495                                         position: "absolute",
9496                                         width: iframe.outerWidth(),
9497                                         height: iframe.outerHeight()
9498                                 })
9499                                 .appendTo( iframe.parent() )
9500                                 .offset( iframe.offset() )[0];
9501                 });
9502         },
9503
9504         _unblockFrames: function() {
9505                 if ( this.iframeBlocks ) {
9506                         this.iframeBlocks.remove();
9507                         delete this.iframeBlocks;
9508                 }
9509         },
9510
9511         _allowInteraction: function( event ) {
9512                 if ( $( event.target ).closest(".ui-dialog").length ) {
9513                         return true;
9514                 }
9515
9516                 // TODO: Remove hack when datepicker implements
9517                 // the .ui-front logic (#8989)
9518                 return !!$( event.target ).closest(".ui-datepicker").length;
9519         },
9520
9521         _createOverlay: function() {
9522                 if ( !this.options.modal ) {
9523                         return;
9524                 }
9525
9526                 var that = this,
9527                         widgetFullName = this.widgetFullName;
9528                 if ( !$.ui.dialog.overlayInstances ) {
9529                         // Prevent use of anchors and inputs.
9530                         // We use a delay in case the overlay is created from an
9531                         // event that we're going to be cancelling. (#2804)
9532                         this._delay(function() {
9533                                 // Handle .dialog().dialog("close") (#4065)
9534                                 if ( $.ui.dialog.overlayInstances ) {
9535                                         this.document.bind( "focusin.dialog", function( event ) {
9536                                                 if ( !that._allowInteraction( event ) ) {
9537                                                         event.preventDefault();
9538                                                         $(".ui-dialog:visible:last .ui-dialog-content")
9539                                                                 .data( widgetFullName )._focusTabbable();
9540                                                 }
9541                                         });
9542                                 }
9543                         });
9544                 }
9545
9546                 this.overlay = $("<div>")
9547                         .addClass("ui-widget-overlay ui-front")
9548                         .appendTo( this._appendTo() );
9549                 this._on( this.overlay, {
9550                         mousedown: "_keepFocus"
9551                 });
9552                 $.ui.dialog.overlayInstances++;
9553         },
9554
9555         _destroyOverlay: function() {
9556                 if ( !this.options.modal ) {
9557                         return;
9558                 }
9559
9560                 if ( this.overlay ) {
9561                         $.ui.dialog.overlayInstances--;
9562
9563                         if ( !$.ui.dialog.overlayInstances ) {
9564                                 this.document.unbind( "focusin.dialog" );
9565                         }
9566                         this.overlay.remove();
9567                         this.overlay = null;
9568                 }
9569         }
9570 });
9571
9572 $.ui.dialog.overlayInstances = 0;
9573
9574 // DEPRECATED
9575 if ( $.uiBackCompat !== false ) {
9576         // position option with array notation
9577         // just override with old implementation
9578         $.widget( "ui.dialog", $.ui.dialog, {
9579                 _position: function() {
9580                         var position = this.options.position,
9581                                 myAt = [],
9582                                 offset = [ 0, 0 ],
9583                                 isVisible;
9584
9585                         if ( position ) {
9586                                 if ( typeof position === "string" || (typeof position === "object" && "0" in position ) ) {
9587                                         myAt = position.split ? position.split(" ") : [ position[0], position[1] ];
9588                                         if ( myAt.length === 1 ) {
9589                                                 myAt[1] = myAt[0];
9590                                         }
9591
9592                                         $.each( [ "left", "top" ], function( i, offsetPosition ) {
9593                                                 if ( +myAt[ i ] === myAt[ i ] ) {
9594                                                         offset[ i ] = myAt[ i ];
9595                                                         myAt[ i ] = offsetPosition;
9596                                                 }
9597                                         });
9598
9599                                         position = {
9600                                                 my: myAt[0] + (offset[0] < 0 ? offset[0] : "+" + offset[0]) + " " +
9601                                                         myAt[1] + (offset[1] < 0 ? offset[1] : "+" + offset[1]),
9602                                                 at: myAt.join(" ")
9603                                         };
9604                                 }
9605
9606                                 position = $.extend( {}, $.ui.dialog.prototype.options.position, position );
9607                         } else {
9608                                 position = $.ui.dialog.prototype.options.position;
9609                         }
9610
9611                         // need to show the dialog to get the actual offset in the position plugin
9612                         isVisible = this.uiDialog.is(":visible");
9613                         if ( !isVisible ) {
9614                                 this.uiDialog.show();
9615                         }
9616                         this.uiDialog.position( position );
9617                         if ( !isVisible ) {
9618                                 this.uiDialog.hide();
9619                         }
9620                 }
9621         });
9622 }
9623
9624 }( jQuery ) );
9625 (function( $, undefined ) {
9626
9627 $.widget( "ui.menu", {
9628         version: "1.10.3",
9629         defaultElement: "<ul>",
9630         delay: 300,
9631         options: {
9632                 icons: {
9633                         submenu: "ui-icon-carat-1-e"
9634                 },
9635                 menus: "ul",
9636                 position: {
9637                         my: "left top",
9638                         at: "right top"
9639                 },
9640                 role: "menu",
9641
9642                 // callbacks
9643                 blur: null,
9644                 focus: null,
9645                 select: null
9646         },
9647
9648         _create: function() {
9649                 this.activeMenu = this.element;
9650                 // flag used to prevent firing of the click handler
9651                 // as the event bubbles up through nested menus
9652                 this.mouseHandled = false;
9653                 this.element
9654                         .uniqueId()
9655                         .addClass( "ui-menu ui-widget ui-widget-content ui-corner-all" )
9656                         .toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
9657                         .attr({
9658                                 role: this.options.role,
9659                                 tabIndex: 0
9660                         })
9661                         // need to catch all clicks on disabled menu
9662                         // not possible through _on
9663                         .bind( "click" + this.eventNamespace, $.proxy(function( event ) {
9664                                 if ( this.options.disabled ) {
9665                                         event.preventDefault();
9666                                 }
9667                         }, this ));
9668
9669                 if ( this.options.disabled ) {
9670                         this.element
9671                                 .addClass( "ui-state-disabled" )
9672                                 .attr( "aria-disabled", "true" );
9673                 }
9674
9675                 this._on({
9676                         // Prevent focus from sticking to links inside menu after clicking
9677                         // them (focus should always stay on UL during navigation).
9678                         "mousedown .ui-menu-item > a": function( event ) {
9679                                 event.preventDefault();
9680                         },
9681                         "click .ui-state-disabled > a": function( event ) {
9682                                 event.preventDefault();
9683                         },
9684                         "click .ui-menu-item:has(a)": function( event ) {
9685                                 var target = $( event.target ).closest( ".ui-menu-item" );
9686                                 if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
9687                                         this.mouseHandled = true;
9688
9689                                         this.select( event );
9690                                         // Open submenu on click
9691                                         if ( target.has( ".ui-menu" ).length ) {
9692                                                 this.expand( event );
9693                                         } else if ( !this.element.is( ":focus" ) ) {
9694                                                 // Redirect focus to the menu
9695                                                 this.element.trigger( "focus", [ true ] );
9696
9697                                                 // If the active item is on the top level, let it stay active.
9698                                                 // Otherwise, blur the active item since it is no longer visible.
9699                                                 if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
9700                                                         clearTimeout( this.timer );
9701                                                 }
9702                                         }
9703                                 }
9704                         },
9705                         "mouseenter .ui-menu-item": function( event ) {
9706                                 var target = $( event.currentTarget );
9707                                 // Remove ui-state-active class from siblings of the newly focused menu item
9708                                 // to avoid a jump caused by adjacent elements both having a class with a border
9709                                 target.siblings().children( ".ui-state-active" ).removeClass( "ui-state-active" );
9710                                 this.focus( event, target );
9711                         },
9712                         mouseleave: "collapseAll",
9713                         "mouseleave .ui-menu": "collapseAll",
9714                         focus: function( event, keepActiveItem ) {
9715                                 // If there's already an active item, keep it active
9716                                 // If not, activate the first item
9717                                 var item = this.active || this.element.children( ".ui-menu-item" ).eq( 0 );
9718
9719                                 if ( !keepActiveItem ) {
9720                                         this.focus( event, item );
9721                                 }
9722                         },
9723                         blur: function( event ) {
9724                                 this._delay(function() {
9725                                         if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
9726                                                 this.collapseAll( event );
9727                                         }
9728                                 });
9729                         },
9730                         keydown: "_keydown"
9731                 });
9732
9733                 this.refresh();
9734
9735                 // Clicks outside of a menu collapse any open menus
9736                 this._on( this.document, {
9737                         click: function( event ) {
9738                                 if ( !$( event.target ).closest( ".ui-menu" ).length ) {
9739                                         this.collapseAll( event );
9740                                 }
9741
9742                                 // Reset the mouseHandled flag
9743                                 this.mouseHandled = false;
9744                         }
9745                 });
9746         },
9747
9748         _destroy: function() {
9749                 // Destroy (sub)menus
9750                 this.element
9751                         .removeAttr( "aria-activedescendant" )
9752                         .find( ".ui-menu" ).addBack()
9753                                 .removeClass( "ui-menu ui-widget ui-widget-content ui-corner-all ui-menu-icons" )
9754                                 .removeAttr( "role" )
9755                                 .removeAttr( "tabIndex" )
9756                                 .removeAttr( "aria-labelledby" )
9757                                 .removeAttr( "aria-expanded" )
9758                                 .removeAttr( "aria-hidden" )
9759                                 .removeAttr( "aria-disabled" )
9760                                 .removeUniqueId()
9761                                 .show();
9762
9763                 // Destroy menu items
9764                 this.element.find( ".ui-menu-item" )
9765                         .removeClass( "ui-menu-item" )
9766                         .removeAttr( "role" )
9767                         .removeAttr( "aria-disabled" )
9768                         .children( "a" )
9769                                 .removeUniqueId()
9770                                 .removeClass( "ui-corner-all ui-state-hover" )
9771                                 .removeAttr( "tabIndex" )
9772                                 .removeAttr( "role" )
9773                                 .removeAttr( "aria-haspopup" )
9774                                 .children().each( function() {
9775                                         var elem = $( this );
9776                                         if ( elem.data( "ui-menu-submenu-carat" ) ) {
9777                                                 elem.remove();
9778                                         }
9779                                 });
9780
9781                 // Destroy menu dividers
9782                 this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
9783         },
9784
9785         _keydown: function( event ) {
9786                 /*jshint maxcomplexity:20*/
9787                 var match, prev, character, skip, regex,
9788                         preventDefault = true;
9789
9790                 function escape( value ) {
9791                         return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
9792                 }
9793
9794                 switch ( event.keyCode ) {
9795                 case $.ui.keyCode.PAGE_UP:
9796                         this.previousPage( event );
9797                         break;
9798                 case $.ui.keyCode.PAGE_DOWN:
9799                         this.nextPage( event );
9800                         break;
9801                 case $.ui.keyCode.HOME:
9802                         this._move( "first", "first", event );
9803                         break;
9804                 case $.ui.keyCode.END:
9805                         this._move( "last", "last", event );
9806                         break;
9807                 case $.ui.keyCode.UP:
9808                         this.previous( event );
9809                         break;
9810                 case $.ui.keyCode.DOWN:
9811                         this.next( event );
9812                         break;
9813                 case $.ui.keyCode.LEFT:
9814                         this.collapse( event );
9815                         break;
9816                 case $.ui.keyCode.RIGHT:
9817                         if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
9818                                 this.expand( event );
9819                         }
9820                         break;
9821                 case $.ui.keyCode.ENTER:
9822                 case $.ui.keyCode.SPACE:
9823                         this._activate( event );
9824                         break;
9825                 case $.ui.keyCode.ESCAPE:
9826                         this.collapse( event );
9827                         break;
9828                 default:
9829                         preventDefault = false;
9830                         prev = this.previousFilter || "";
9831                         character = String.fromCharCode( event.keyCode );
9832                         skip = false;
9833
9834                         clearTimeout( this.filterTimer );
9835
9836                         if ( character === prev ) {
9837                                 skip = true;
9838                         } else {
9839                                 character = prev + character;
9840                         }
9841
9842                         regex = new RegExp( "^" + escape( character ), "i" );
9843                         match = this.activeMenu.children( ".ui-menu-item" ).filter(function() {
9844                                 return regex.test( $( this ).children( "a" ).text() );
9845                         });
9846                         match = skip && match.index( this.active.next() ) !== -1 ?
9847                                 this.active.nextAll( ".ui-menu-item" ) :
9848                                 match;
9849
9850                         // If no matches on the current filter, reset to the last character pressed
9851                         // to move down the menu to the first item that starts with that character
9852                         if ( !match.length ) {
9853                                 character = String.fromCharCode( event.keyCode );
9854                                 regex = new RegExp( "^" + escape( character ), "i" );
9855                                 match = this.activeMenu.children( ".ui-menu-item" ).filter(function() {
9856                                         return regex.test( $( this ).children( "a" ).text() );
9857                                 });
9858                         }
9859
9860                         if ( match.length ) {
9861                                 this.focus( event, match );
9862                                 if ( match.length > 1 ) {
9863                                         this.previousFilter = character;
9864                                         this.filterTimer = this._delay(function() {
9865                                                 delete this.previousFilter;
9866                                         }, 1000 );
9867                                 } else {
9868                                         delete this.previousFilter;
9869                                 }
9870                         } else {
9871                                 delete this.previousFilter;
9872                         }
9873                 }
9874
9875                 if ( preventDefault ) {
9876                         event.preventDefault();
9877                 }
9878         },
9879
9880         _activate: function( event ) {
9881                 if ( !this.active.is( ".ui-state-disabled" ) ) {
9882                         if ( this.active.children( "a[aria-haspopup='true']" ).length ) {
9883                                 this.expand( event );
9884                         } else {
9885                                 this.select( event );
9886                         }
9887                 }
9888         },
9889
9890         refresh: function() {
9891                 var menus,
9892                         icon = this.options.icons.submenu,
9893                         submenus = this.element.find( this.options.menus );
9894
9895                 // Initialize nested menus
9896                 submenus.filter( ":not(.ui-menu)" )
9897                         .addClass( "ui-menu ui-widget ui-widget-content ui-corner-all" )
9898                         .hide()
9899                         .attr({
9900                                 role: this.options.role,
9901                                 "aria-hidden": "true",
9902                                 "aria-expanded": "false"
9903                         })
9904                         .each(function() {
9905                                 var menu = $( this ),
9906                                         item = menu.prev( "a" ),
9907                                         submenuCarat = $( "<span>" )
9908                                                 .addClass( "ui-menu-icon ui-icon " + icon )
9909                                                 .data( "ui-menu-submenu-carat", true );
9910
9911                                 item
9912                                         .attr( "aria-haspopup", "true" )
9913                                         .prepend( submenuCarat );
9914                                 menu.attr( "aria-labelledby", item.attr( "id" ) );
9915                         });
9916
9917                 menus = submenus.add( this.element );
9918
9919                 // Don't refresh list items that are already adapted
9920                 menus.children( ":not(.ui-menu-item):has(a)" )
9921                         .addClass( "ui-menu-item" )
9922                         .attr( "role", "presentation" )
9923                         .children( "a" )
9924                                 .uniqueId()
9925                                 .addClass( "ui-corner-all" )
9926                                 .attr({
9927                                         tabIndex: -1,
9928                                         role: this._itemRole()
9929                                 });
9930
9931                 // Initialize unlinked menu-items containing spaces and/or dashes only as dividers
9932                 menus.children( ":not(.ui-menu-item)" ).each(function() {
9933                         var item = $( this );
9934                         // hyphen, em dash, en dash
9935                         if ( !/[^\-\u2014\u2013\s]/.test( item.text() ) ) {
9936                                 item.addClass( "ui-widget-content ui-menu-divider" );
9937                         }
9938                 });
9939
9940                 // Add aria-disabled attribute to any disabled menu item
9941                 menus.children( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
9942
9943                 // If the active item has been removed, blur the menu
9944                 if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
9945                         this.blur();
9946                 }
9947         },
9948
9949         _itemRole: function() {
9950                 return {
9951                         menu: "menuitem",
9952                         listbox: "option"
9953                 }[ this.options.role ];
9954         },
9955
9956         _setOption: function( key, value ) {
9957                 if ( key === "icons" ) {
9958                         this.element.find( ".ui-menu-icon" )
9959                                 .removeClass( this.options.icons.submenu )
9960                                 .addClass( value.submenu );
9961                 }
9962                 this._super( key, value );
9963         },
9964
9965         focus: function( event, item ) {
9966                 var nested, focused;
9967                 this.blur( event, event && event.type === "focus" );
9968
9969                 this._scrollIntoView( item );
9970
9971                 this.active = item.first();
9972                 focused = this.active.children( "a" ).addClass( "ui-state-focus" );
9973                 // Only update aria-activedescendant if there's a role
9974                 // otherwise we assume focus is managed elsewhere
9975                 if ( this.options.role ) {
9976                         this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
9977                 }
9978
9979                 // Highlight active parent menu item, if any
9980                 this.active
9981                         .parent()
9982                         .closest( ".ui-menu-item" )
9983                         .children( "a:first" )
9984                         .addClass( "ui-state-active" );
9985
9986                 if ( event && event.type === "keydown" ) {
9987                         this._close();
9988                 } else {
9989                         this.timer = this._delay(function() {
9990                                 this._close();
9991                         }, this.delay );
9992                 }
9993
9994                 nested = item.children( ".ui-menu" );
9995                 if ( nested.length && ( /^mouse/.test( event.type ) ) ) {
9996                         this._startOpening(nested);
9997                 }
9998                 this.activeMenu = item.parent();
9999
10000                 this._trigger( "focus", event, { item: item } );
10001         },
10002
10003         _scrollIntoView: function( item ) {
10004                 var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
10005                 if ( this._hasScroll() ) {
10006                         borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
10007                         paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
10008                         offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
10009                         scroll = this.activeMenu.scrollTop();
10010                         elementHeight = this.activeMenu.height();
10011                         itemHeight = item.height();
10012
10013                         if ( offset < 0 ) {
10014                                 this.activeMenu.scrollTop( scroll + offset );
10015                         } else if ( offset + itemHeight > elementHeight ) {
10016                                 this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
10017                         }
10018                 }
10019         },
10020
10021         blur: function( event, fromFocus ) {
10022                 if ( !fromFocus ) {
10023                         clearTimeout( this.timer );
10024                 }
10025
10026                 if ( !this.active ) {
10027                         return;
10028                 }
10029
10030                 this.active.children( "a" ).removeClass( "ui-state-focus" );
10031                 this.active = null;
10032
10033                 this._trigger( "blur", event, { item: this.active } );
10034         },
10035
10036         _startOpening: function( submenu ) {
10037                 clearTimeout( this.timer );
10038
10039                 // Don't open if already open fixes a Firefox bug that caused a .5 pixel
10040                 // shift in the submenu position when mousing over the carat icon
10041                 if ( submenu.attr( "aria-hidden" ) !== "true" ) {
10042                         return;
10043                 }
10044
10045                 this.timer = this._delay(function() {
10046                         this._close();
10047                         this._open( submenu );
10048                 }, this.delay );
10049         },
10050
10051         _open: function( submenu ) {
10052                 var position = $.extend({
10053                         of: this.active
10054                 }, this.options.position );
10055
10056                 clearTimeout( this.timer );
10057                 this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
10058                         .hide()
10059                         .attr( "aria-hidden", "true" );
10060
10061                 submenu
10062                         .show()
10063                         .removeAttr( "aria-hidden" )
10064                         .attr( "aria-expanded", "true" )
10065                         .position( position );
10066         },
10067
10068         collapseAll: function( event, all ) {
10069                 clearTimeout( this.timer );
10070                 this.timer = this._delay(function() {
10071                         // If we were passed an event, look for the submenu that contains the event
10072                         var currentMenu = all ? this.element :
10073                                 $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
10074
10075                         // If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
10076                         if ( !currentMenu.length ) {
10077                                 currentMenu = this.element;
10078                         }
10079
10080                         this._close( currentMenu );
10081
10082                         this.blur( event );
10083                         this.activeMenu = currentMenu;
10084                 }, this.delay );
10085         },
10086
10087         // With no arguments, closes the currently active menu - if nothing is active
10088         // it closes all menus.  If passed an argument, it will search for menus BELOW
10089         _close: function( startMenu ) {
10090                 if ( !startMenu ) {
10091                         startMenu = this.active ? this.active.parent() : this.element;
10092                 }
10093
10094                 startMenu
10095                         .find( ".ui-menu" )
10096                                 .hide()
10097                                 .attr( "aria-hidden", "true" )
10098                                 .attr( "aria-expanded", "false" )
10099                         .end()
10100                         .find( "a.ui-state-active" )
10101                                 .removeClass( "ui-state-active" );
10102         },
10103
10104         collapse: function( event ) {
10105                 var newItem = this.active &&
10106                         this.active.parent().closest( ".ui-menu-item", this.element );
10107                 if ( newItem && newItem.length ) {
10108                         this._close();
10109                         this.focus( event, newItem );
10110                 }
10111         },
10112
10113         expand: function( event ) {
10114                 var newItem = this.active &&
10115                         this.active
10116                                 .children( ".ui-menu " )
10117                                 .children( ".ui-menu-item" )
10118                                 .first();
10119
10120                 if ( newItem && newItem.length ) {
10121                         this._open( newItem.parent() );
10122
10123                         // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
10124                         this._delay(function() {
10125                                 this.focus( event, newItem );
10126                         });
10127                 }
10128         },
10129
10130         next: function( event ) {
10131                 this._move( "next", "first", event );
10132         },
10133
10134         previous: function( event ) {
10135                 this._move( "prev", "last", event );
10136         },
10137
10138         isFirstItem: function() {
10139                 return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
10140         },
10141
10142         isLastItem: function() {
10143                 return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
10144         },
10145
10146         _move: function( direction, filter, event ) {
10147                 var next;
10148                 if ( this.active ) {
10149                         if ( direction === "first" || direction === "last" ) {
10150                                 next = this.active
10151                                         [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
10152                                         .eq( -1 );
10153                         } else {
10154                                 next = this.active
10155                                         [ direction + "All" ]( ".ui-menu-item" )
10156                                         .eq( 0 );
10157                         }
10158                 }
10159                 if ( !next || !next.length || !this.active ) {
10160                         next = this.activeMenu.children( ".ui-menu-item" )[ filter ]();
10161                 }
10162
10163                 this.focus( event, next );
10164         },
10165
10166         nextPage: function( event ) {
10167                 var item, base, height;
10168
10169                 if ( !this.active ) {
10170                         this.next( event );
10171                         return;
10172                 }
10173                 if ( this.isLastItem() ) {
10174                         return;
10175                 }
10176                 if ( this._hasScroll() ) {
10177                         base = this.active.offset().top;
10178                         height = this.element.height();
10179                         this.active.nextAll( ".ui-menu-item" ).each(function() {
10180                                 item = $( this );
10181                                 return item.offset().top - base - height < 0;
10182                         });
10183
10184                         this.focus( event, item );
10185                 } else {
10186                         this.focus( event, this.activeMenu.children( ".ui-menu-item" )
10187                                 [ !this.active ? "first" : "last" ]() );
10188                 }
10189         },
10190
10191         previousPage: function( event ) {
10192                 var item, base, height;
10193                 if ( !this.active ) {
10194                         this.next( event );
10195                         return;
10196                 }
10197                 if ( this.isFirstItem() ) {
10198                         return;
10199                 }
10200                 if ( this._hasScroll() ) {
10201                         base = this.active.offset().top;
10202                         height = this.element.height();
10203                         this.active.prevAll( ".ui-menu-item" ).each(function() {
10204                                 item = $( this );
10205                                 return item.offset().top - base + height > 0;
10206                         });
10207
10208                         this.focus( event, item );
10209                 } else {
10210                         this.focus( event, this.activeMenu.children( ".ui-menu-item" ).first() );
10211                 }
10212         },
10213
10214         _hasScroll: function() {
10215                 return this.element.outerHeight() < this.element.prop( "scrollHeight" );
10216         },
10217
10218         select: function( event ) {
10219                 // TODO: It should never be possible to not have an active item at this
10220                 // point, but the tests don't trigger mouseenter before click.
10221                 this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
10222                 var ui = { item: this.active };
10223                 if ( !this.active.has( ".ui-menu" ).length ) {
10224                         this.collapseAll( event, true );
10225                 }
10226                 this._trigger( "select", event, ui );
10227         }
10228 });
10229
10230 }( jQuery ));
10231 (function( $, undefined ) {
10232
10233 $.widget( "ui.progressbar", {
10234         version: "1.10.3",
10235         options: {
10236                 max: 100,
10237                 value: 0,
10238
10239                 change: null,
10240                 complete: null
10241         },
10242
10243         min: 0,
10244
10245         _create: function() {
10246                 // Constrain initial value
10247                 this.oldValue = this.options.value = this._constrainedValue();
10248
10249                 this.element
10250                         .addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
10251                         .attr({
10252                                 // Only set static values, aria-valuenow and aria-valuemax are
10253                                 // set inside _refreshValue()
10254                                 role: "progressbar",
10255                                 "aria-valuemin": this.min
10256                         });
10257
10258                 this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
10259                         .appendTo( this.element );
10260
10261                 this._refreshValue();
10262         },
10263
10264         _destroy: function() {
10265                 this.element
10266                         .removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
10267                         .removeAttr( "role" )
10268                         .removeAttr( "aria-valuemin" )
10269                         .removeAttr( "aria-valuemax" )
10270                         .removeAttr( "aria-valuenow" );
10271
10272                 this.valueDiv.remove();
10273         },
10274
10275         value: function( newValue ) {
10276                 if ( newValue === undefined ) {
10277                         return this.options.value;
10278                 }
10279
10280                 this.options.value = this._constrainedValue( newValue );
10281                 this._refreshValue();
10282         },
10283
10284         _constrainedValue: function( newValue ) {
10285                 if ( newValue === undefined ) {
10286                         newValue = this.options.value;
10287                 }
10288
10289                 this.indeterminate = newValue === false;
10290
10291                 // sanitize value
10292                 if ( typeof newValue !== "number" ) {
10293                         newValue = 0;
10294                 }
10295
10296                 return this.indeterminate ? false :
10297                         Math.min( this.options.max, Math.max( this.min, newValue ) );
10298         },
10299
10300         _setOptions: function( options ) {
10301                 // Ensure "value" option is set after other values (like max)
10302                 var value = options.value;
10303                 delete options.value;
10304
10305                 this._super( options );
10306
10307                 this.options.value = this._constrainedValue( value );
10308                 this._refreshValue();
10309         },
10310
10311         _setOption: function( key, value ) {
10312                 if ( key === "max" ) {
10313                         // Don't allow a max less than min
10314                         value = Math.max( this.min, value );
10315                 }
10316
10317                 this._super( key, value );
10318         },
10319
10320         _percentage: function() {
10321                 return this.indeterminate ? 100 : 100 * ( this.options.value - this.min ) / ( this.options.max - this.min );
10322         },
10323
10324         _refreshValue: function() {
10325                 var value = this.options.value,
10326                         percentage = this._percentage();
10327
10328                 this.valueDiv
10329                         .toggle( this.indeterminate || value > this.min )
10330                         .toggleClass( "ui-corner-right", value === this.options.max )
10331                         .width( percentage.toFixed(0) + "%" );
10332
10333                 this.element.toggleClass( "ui-progressbar-indeterminate", this.indeterminate );
10334
10335                 if ( this.indeterminate ) {
10336                         this.element.removeAttr( "aria-valuenow" );
10337                         if ( !this.overlayDiv ) {
10338                                 this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv );
10339                         }
10340                 } else {
10341                         this.element.attr({
10342                                 "aria-valuemax": this.options.max,
10343                                 "aria-valuenow": value
10344                         });
10345                         if ( this.overlayDiv ) {
10346                                 this.overlayDiv.remove();
10347                                 this.overlayDiv = null;
10348                         }
10349                 }
10350
10351                 if ( this.oldValue !== value ) {
10352                         this.oldValue = value;
10353                         this._trigger( "change" );
10354                 }
10355                 if ( value === this.options.max ) {
10356                         this._trigger( "complete" );
10357                 }
10358         }
10359 });
10360
10361 })( jQuery );
10362 (function( $, undefined ) {
10363
10364 // number of pages in a slider
10365 // (how many times can you page up/down to go through the whole range)
10366 var numPages = 5;
10367
10368 $.widget( "ui.slider", $.ui.mouse, {
10369         version: "1.10.3",
10370         widgetEventPrefix: "slide",
10371
10372         options: {
10373                 animate: false,
10374                 distance: 0,
10375                 max: 100,
10376                 min: 0,
10377                 orientation: "horizontal",
10378                 range: false,
10379                 step: 1,
10380                 value: 0,
10381                 values: null,
10382
10383                 // callbacks
10384                 change: null,
10385                 slide: null,
10386                 start: null,
10387                 stop: null
10388         },
10389
10390         _create: function() {
10391                 this._keySliding = false;
10392                 this._mouseSliding = false;
10393                 this._animateOff = true;
10394                 this._handleIndex = null;
10395                 this._detectOrientation();
10396                 this._mouseInit();
10397
10398                 this.element
10399                         .addClass( "ui-slider" +
10400                                 " ui-slider-" + this.orientation +
10401                                 " ui-widget" +
10402                                 " ui-widget-content" +
10403                                 " ui-corner-all");
10404
10405                 this._refresh();
10406                 this._setOption( "disabled", this.options.disabled );
10407
10408                 this._animateOff = false;
10409         },
10410
10411         _refresh: function() {
10412                 this._createRange();
10413                 this._createHandles();
10414                 this._setupEvents();
10415                 this._refreshValue();
10416         },
10417
10418         _createHandles: function() {
10419                 var i, handleCount,
10420                         options = this.options,
10421                         existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
10422                         handle = "<a class='ui-slider-handle ui-state-default ui-corner-all' href='#'></a>",
10423                         handles = [];
10424
10425                 handleCount = ( options.values && options.values.length ) || 1;
10426
10427                 if ( existingHandles.length > handleCount ) {
10428                         existingHandles.slice( handleCount ).remove();
10429                         existingHandles = existingHandles.slice( 0, handleCount );
10430                 }
10431
10432                 for ( i = existingHandles.length; i < handleCount; i++ ) {
10433                         handles.push( handle );
10434                 }
10435
10436                 this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
10437
10438                 this.handle = this.handles.eq( 0 );
10439
10440                 this.handles.each(function( i ) {
10441                         $( this ).data( "ui-slider-handle-index", i );
10442                 });
10443         },
10444
10445         _createRange: function() {
10446                 var options = this.options,
10447                         classes = "";
10448
10449                 if ( options.range ) {
10450                         if ( options.range === true ) {
10451                                 if ( !options.values ) {
10452                                         options.values = [ this._valueMin(), this._valueMin() ];
10453                                 } else if ( options.values.length && options.values.length !== 2 ) {
10454                                         options.values = [ options.values[0], options.values[0] ];
10455                                 } else if ( $.isArray( options.values ) ) {
10456                                         options.values = options.values.slice(0);
10457                                 }
10458                         }
10459
10460                         if ( !this.range || !this.range.length ) {
10461                                 this.range = $( "<div></div>" )
10462                                         .appendTo( this.element );
10463
10464                                 classes = "ui-slider-range" +
10465                                 // note: this isn't the most fittingly semantic framework class for this element,
10466                                 // but worked best visually with a variety of themes
10467                                 " ui-widget-header ui-corner-all";
10468                         } else {
10469                                 this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
10470                                         // Handle range switching from true to min/max
10471                                         .css({
10472                                                 "left": "",
10473                                                 "bottom": ""
10474                                         });
10475                         }
10476
10477                         this.range.addClass( classes +
10478                                 ( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
10479                 } else {
10480                         this.range = $([]);
10481                 }
10482         },
10483
10484         _setupEvents: function() {
10485                 var elements = this.handles.add( this.range ).filter( "a" );
10486                 this._off( elements );
10487                 this._on( elements, this._handleEvents );
10488                 this._hoverable( elements );
10489                 this._focusable( elements );
10490         },
10491
10492         _destroy: function() {
10493                 this.handles.remove();
10494                 this.range.remove();
10495
10496                 this.element
10497                         .removeClass( "ui-slider" +
10498                                 " ui-slider-horizontal" +
10499                                 " ui-slider-vertical" +
10500                                 " ui-widget" +
10501                                 " ui-widget-content" +
10502                                 " ui-corner-all" );
10503
10504                 this._mouseDestroy();
10505         },
10506
10507         _mouseCapture: function( event ) {
10508                 var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
10509                         that = this,
10510                         o = this.options;
10511
10512                 if ( o.disabled ) {
10513                         return false;
10514                 }
10515
10516                 this.elementSize = {
10517                         width: this.element.outerWidth(),
10518                         height: this.element.outerHeight()
10519                 };
10520                 this.elementOffset = this.element.offset();
10521
10522                 position = { x: event.pageX, y: event.pageY };
10523                 normValue = this._normValueFromMouse( position );
10524                 distance = this._valueMax() - this._valueMin() + 1;
10525                 this.handles.each(function( i ) {
10526                         var thisDistance = Math.abs( normValue - that.values(i) );
10527                         if (( distance > thisDistance ) ||
10528                                 ( distance === thisDistance &&
10529                                         (i === that._lastChangedValue || that.values(i) === o.min ))) {
10530                                 distance = thisDistance;
10531                                 closestHandle = $( this );
10532                                 index = i;
10533                         }
10534                 });
10535
10536                 allowed = this._start( event, index );
10537                 if ( allowed === false ) {
10538                         return false;
10539                 }
10540                 this._mouseSliding = true;
10541
10542                 this._handleIndex = index;
10543
10544                 closestHandle
10545                         .addClass( "ui-state-active" )
10546                         .focus();
10547
10548                 offset = closestHandle.offset();
10549                 mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );
10550                 this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
10551                         left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
10552                         top: event.pageY - offset.top -
10553                                 ( closestHandle.height() / 2 ) -
10554                                 ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
10555                                 ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
10556                                 ( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
10557                 };
10558
10559                 if ( !this.handles.hasClass( "ui-state-hover" ) ) {
10560                         this._slide( event, index, normValue );
10561                 }
10562                 this._animateOff = true;
10563                 return true;
10564         },
10565
10566         _mouseStart: function() {
10567                 return true;
10568         },
10569
10570         _mouseDrag: function( event ) {
10571                 var position = { x: event.pageX, y: event.pageY },
10572                         normValue = this._normValueFromMouse( position );
10573
10574                 this._slide( event, this._handleIndex, normValue );
10575
10576                 return false;
10577         },
10578
10579         _mouseStop: function( event ) {
10580                 this.handles.removeClass( "ui-state-active" );
10581                 this._mouseSliding = false;
10582
10583                 this._stop( event, this._handleIndex );
10584                 this._change( event, this._handleIndex );
10585
10586                 this._handleIndex = null;
10587                 this._clickOffset = null;
10588                 this._animateOff = false;
10589
10590                 return false;
10591         },
10592
10593         _detectOrientation: function() {
10594                 this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
10595         },
10596
10597         _normValueFromMouse: function( position ) {
10598                 var pixelTotal,
10599                         pixelMouse,
10600                         percentMouse,
10601                         valueTotal,
10602                         valueMouse;
10603
10604                 if ( this.orientation === "horizontal" ) {
10605                         pixelTotal = this.elementSize.width;
10606                         pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
10607                 } else {
10608                         pixelTotal = this.elementSize.height;
10609                         pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
10610                 }
10611
10612                 percentMouse = ( pixelMouse / pixelTotal );
10613                 if ( percentMouse > 1 ) {
10614                         percentMouse = 1;
10615                 }
10616                 if ( percentMouse < 0 ) {
10617                         percentMouse = 0;
10618                 }
10619                 if ( this.orientation === "vertical" ) {
10620                         percentMouse = 1 - percentMouse;
10621                 }
10622
10623                 valueTotal = this._valueMax() - this._valueMin();
10624                 valueMouse = this._valueMin() + percentMouse * valueTotal;
10625
10626                 return this._trimAlignValue( valueMouse );
10627         },
10628
10629         _start: function( event, index ) {
10630                 var uiHash = {
10631                         handle: this.handles[ index ],
10632                         value: this.value()
10633                 };
10634                 if ( this.options.values && this.options.values.length ) {
10635                         uiHash.value = this.values( index );
10636                         uiHash.values = this.values();
10637                 }
10638                 return this._trigger( "start", event, uiHash );
10639         },
10640
10641         _slide: function( event, index, newVal ) {
10642                 var otherVal,
10643                         newValues,
10644                         allowed;
10645
10646                 if ( this.options.values && this.options.values.length ) {
10647                         otherVal = this.values( index ? 0 : 1 );
10648
10649                         if ( ( this.options.values.length === 2 && this.options.range === true ) &&
10650                                         ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
10651                                 ) {
10652                                 newVal = otherVal;
10653                         }
10654
10655                         if ( newVal !== this.values( index ) ) {
10656                                 newValues = this.values();
10657                                 newValues[ index ] = newVal;
10658                                 // A slide can be canceled by returning false from the slide callback
10659                                 allowed = this._trigger( "slide", event, {
10660                                         handle: this.handles[ index ],
10661                                         value: newVal,
10662                                         values: newValues
10663                                 } );
10664                                 otherVal = this.values( index ? 0 : 1 );
10665                                 if ( allowed !== false ) {
10666                                         this.values( index, newVal, true );
10667                                 }
10668                         }
10669                 } else {
10670                         if ( newVal !== this.value() ) {
10671                                 // A slide can be canceled by returning false from the slide callback
10672                                 allowed = this._trigger( "slide", event, {
10673                                         handle: this.handles[ index ],
10674                                         value: newVal
10675                                 } );
10676                                 if ( allowed !== false ) {
10677                                         this.value( newVal );
10678                                 }
10679                         }
10680                 }
10681         },
10682
10683         _stop: function( event, index ) {
10684                 var uiHash = {
10685                         handle: this.handles[ index ],
10686                         value: this.value()
10687                 };
10688                 if ( this.options.values && this.options.values.length ) {
10689                         uiHash.value = this.values( index );
10690                         uiHash.values = this.values();
10691                 }
10692
10693                 this._trigger( "stop", event, uiHash );
10694         },
10695
10696         _change: function( event, index ) {
10697                 if ( !this._keySliding && !this._mouseSliding ) {
10698                         var uiHash = {
10699                                 handle: this.handles[ index ],
10700                                 value: this.value()
10701                         };
10702                         if ( this.options.values && this.options.values.length ) {
10703                                 uiHash.value = this.values( index );
10704                                 uiHash.values = this.values();
10705                         }
10706
10707                         //store the last changed value index for reference when handles overlap
10708                         this._lastChangedValue = index;
10709
10710                         this._trigger( "change", event, uiHash );
10711                 }
10712         },
10713
10714         value: function( newValue ) {
10715                 if ( arguments.length ) {
10716                         this.options.value = this._trimAlignValue( newValue );
10717                         this._refreshValue();
10718                         this._change( null, 0 );
10719                         return;
10720                 }
10721
10722                 return this._value();
10723         },
10724
10725         values: function( index, newValue ) {
10726                 var vals,
10727                         newValues,
10728                         i;
10729
10730                 if ( arguments.length > 1 ) {
10731                         this.options.values[ index ] = this._trimAlignValue( newValue );
10732                         this._refreshValue();
10733                         this._change( null, index );
10734                         return;
10735                 }
10736
10737                 if ( arguments.length ) {
10738                         if ( $.isArray( arguments[ 0 ] ) ) {
10739                                 vals = this.options.values;
10740                                 newValues = arguments[ 0 ];
10741                                 for ( i = 0; i < vals.length; i += 1 ) {
10742                                         vals[ i ] = this._trimAlignValue( newValues[ i ] );
10743                                         this._change( null, i );
10744                                 }
10745                                 this._refreshValue();
10746                         } else {
10747                                 if ( this.options.values && this.options.values.length ) {
10748                                         return this._values( index );
10749                                 } else {
10750                                         return this.value();
10751                                 }
10752                         }
10753                 } else {
10754                         return this._values();
10755                 }
10756         },
10757
10758         _setOption: function( key, value ) {
10759                 var i,
10760                         valsLength = 0;
10761
10762                 if ( key === "range" && this.options.range === true ) {
10763                         if ( value === "min" ) {
10764                                 this.options.value = this._values( 0 );
10765                                 this.options.values = null;
10766                         } else if ( value === "max" ) {
10767                                 this.options.value = this._values( this.options.values.length-1 );
10768                                 this.options.values = null;
10769                         }
10770                 }
10771
10772                 if ( $.isArray( this.options.values ) ) {
10773                         valsLength = this.options.values.length;
10774                 }
10775
10776                 $.Widget.prototype._setOption.apply( this, arguments );
10777
10778                 switch ( key ) {
10779                         case "orientation":
10780                                 this._detectOrientation();
10781                                 this.element
10782                                         .removeClass( "ui-slider-horizontal ui-slider-vertical" )
10783                                         .addClass( "ui-slider-" + this.orientation );
10784                                 this._refreshValue();
10785                                 break;
10786                         case "value":
10787                                 this._animateOff = true;
10788                                 this._refreshValue();
10789                                 this._change( null, 0 );
10790                                 this._animateOff = false;
10791                                 break;
10792                         case "values":
10793                                 this._animateOff = true;
10794                                 this._refreshValue();
10795                                 for ( i = 0; i < valsLength; i += 1 ) {
10796                                         this._change( null, i );
10797                                 }
10798                                 this._animateOff = false;
10799                                 break;
10800                         case "min":
10801                         case "max":
10802                                 this._animateOff = true;
10803                                 this._refreshValue();
10804                                 this._animateOff = false;
10805                                 break;
10806                         case "range":
10807                                 this._animateOff = true;
10808                                 this._refresh();
10809                                 this._animateOff = false;
10810                                 break;
10811                 }
10812         },
10813
10814         //internal value getter
10815         // _value() returns value trimmed by min and max, aligned by step
10816         _value: function() {
10817                 var val = this.options.value;
10818                 val = this._trimAlignValue( val );
10819
10820                 return val;
10821         },
10822
10823         //internal values getter
10824         // _values() returns array of values trimmed by min and max, aligned by step
10825         // _values( index ) returns single value trimmed by min and max, aligned by step
10826         _values: function( index ) {
10827                 var val,
10828                         vals,
10829                         i;
10830
10831                 if ( arguments.length ) {
10832                         val = this.options.values[ index ];
10833                         val = this._trimAlignValue( val );
10834
10835                         return val;
10836                 } else if ( this.options.values && this.options.values.length ) {
10837                         // .slice() creates a copy of the array
10838                         // this copy gets trimmed by min and max and then returned
10839                         vals = this.options.values.slice();
10840                         for ( i = 0; i < vals.length; i+= 1) {
10841                                 vals[ i ] = this._trimAlignValue( vals[ i ] );
10842                         }
10843
10844                         return vals;
10845                 } else {
10846                         return [];
10847                 }
10848         },
10849
10850         // returns the step-aligned value that val is closest to, between (inclusive) min and max
10851         _trimAlignValue: function( val ) {
10852                 if ( val <= this._valueMin() ) {
10853                         return this._valueMin();
10854                 }
10855                 if ( val >= this._valueMax() ) {
10856                         return this._valueMax();
10857                 }
10858                 var step = ( this.options.step > 0 ) ? this.options.step : 1,
10859                         valModStep = (val - this._valueMin()) % step,
10860                         alignValue = val - valModStep;
10861
10862                 if ( Math.abs(valModStep) * 2 >= step ) {
10863                         alignValue += ( valModStep > 0 ) ? step : ( -step );
10864                 }
10865
10866                 // Since JavaScript has problems with large floats, round
10867                 // the final value to 5 digits after the decimal point (see #4124)
10868                 return parseFloat( alignValue.toFixed(5) );
10869         },
10870
10871         _valueMin: function() {
10872                 return this.options.min;
10873         },
10874
10875         _valueMax: function() {
10876                 return this.options.max;
10877         },
10878
10879         _refreshValue: function() {
10880                 var lastValPercent, valPercent, value, valueMin, valueMax,
10881                         oRange = this.options.range,
10882                         o = this.options,
10883                         that = this,
10884                         animate = ( !this._animateOff ) ? o.animate : false,
10885                         _set = {};
10886
10887                 if ( this.options.values && this.options.values.length ) {
10888                         this.handles.each(function( i ) {
10889                                 valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
10890                                 _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
10891                                 $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
10892                                 if ( that.options.range === true ) {
10893                                         if ( that.orientation === "horizontal" ) {
10894                                                 if ( i === 0 ) {
10895                                                         that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
10896                                                 }
10897                                                 if ( i === 1 ) {
10898                                                         that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
10899                                                 }
10900                                         } else {
10901                                                 if ( i === 0 ) {
10902                                                         that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
10903                                                 }
10904                                                 if ( i === 1 ) {
10905                                                         that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
10906                                                 }
10907                                         }
10908                                 }
10909                                 lastValPercent = valPercent;
10910                         });
10911                 } else {
10912                         value = this.value();
10913                         valueMin = this._valueMin();
10914                         valueMax = this._valueMax();
10915                         valPercent = ( valueMax !== valueMin ) ?
10916                                         ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
10917                                         0;
10918                         _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
10919                         this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
10920
10921                         if ( oRange === "min" && this.orientation === "horizontal" ) {
10922                                 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
10923                         }
10924                         if ( oRange === "max" && this.orientation === "horizontal" ) {
10925                                 this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
10926                         }
10927                         if ( oRange === "min" && this.orientation === "vertical" ) {
10928                                 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
10929                         }
10930                         if ( oRange === "max" && this.orientation === "vertical" ) {
10931                                 this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
10932                         }
10933                 }
10934         },
10935
10936         _handleEvents: {
10937                 keydown: function( event ) {
10938                         /*jshint maxcomplexity:25*/
10939                         var allowed, curVal, newVal, step,
10940                                 index = $( event.target ).data( "ui-slider-handle-index" );
10941
10942                         switch ( event.keyCode ) {
10943                                 case $.ui.keyCode.HOME:
10944                                 case $.ui.keyCode.END:
10945                                 case $.ui.keyCode.PAGE_UP:
10946                                 case $.ui.keyCode.PAGE_DOWN:
10947                                 case $.ui.keyCode.UP:
10948                                 case $.ui.keyCode.RIGHT:
10949                                 case $.ui.keyCode.DOWN:
10950                                 case $.ui.keyCode.LEFT:
10951                                         event.preventDefault();
10952                                         if ( !this._keySliding ) {
10953                                                 this._keySliding = true;
10954                                                 $( event.target ).addClass( "ui-state-active" );
10955                                                 allowed = this._start( event, index );
10956                                                 if ( allowed === false ) {
10957                                                         return;
10958                                                 }
10959                                         }
10960                                         break;
10961                         }
10962
10963                         step = this.options.step;
10964                         if ( this.options.values && this.options.values.length ) {
10965                                 curVal = newVal = this.values( index );
10966                         } else {
10967                                 curVal = newVal = this.value();
10968                         }
10969
10970                         switch ( event.keyCode ) {
10971                                 case $.ui.keyCode.HOME:
10972                                         newVal = this._valueMin();
10973                                         break;
10974                                 case $.ui.keyCode.END:
10975                                         newVal = this._valueMax();
10976                                         break;
10977                                 case $.ui.keyCode.PAGE_UP:
10978                                         newVal = this._trimAlignValue( curVal + ( (this._valueMax() - this._valueMin()) / numPages ) );
10979                                         break;
10980                                 case $.ui.keyCode.PAGE_DOWN:
10981                                         newVal = this._trimAlignValue( curVal - ( (this._valueMax() - this._valueMin()) / numPages ) );
10982                                         break;
10983                                 case $.ui.keyCode.UP:
10984                                 case $.ui.keyCode.RIGHT:
10985                                         if ( curVal === this._valueMax() ) {
10986                                                 return;
10987                                         }
10988                                         newVal = this._trimAlignValue( curVal + step );
10989                                         break;
10990                                 case $.ui.keyCode.DOWN:
10991                                 case $.ui.keyCode.LEFT:
10992                                         if ( curVal === this._valueMin() ) {
10993                                                 return;
10994                                         }
10995                                         newVal = this._trimAlignValue( curVal - step );
10996                                         break;
10997                         }
10998
10999                         this._slide( event, index, newVal );
11000                 },
11001                 click: function( event ) {
11002                         event.preventDefault();
11003                 },
11004                 keyup: function( event ) {
11005                         var index = $( event.target ).data( "ui-slider-handle-index" );
11006
11007                         if ( this._keySliding ) {
11008                                 this._keySliding = false;
11009                                 this._stop( event, index );
11010                                 this._change( event, index );
11011                                 $( event.target ).removeClass( "ui-state-active" );
11012                         }
11013                 }
11014         }
11015
11016 });
11017
11018 }(jQuery));
11019 (function( $ ) {
11020
11021 function modifier( fn ) {
11022         return function() {
11023                 var previous = this.element.val();
11024                 fn.apply( this, arguments );
11025                 this._refresh();
11026                 if ( previous !== this.element.val() ) {
11027                         this._trigger( "change" );
11028                 }
11029         };
11030 }
11031
11032 $.widget( "ui.spinner", {
11033         version: "1.10.3",
11034         defaultElement: "<input>",
11035         widgetEventPrefix: "spin",
11036         options: {
11037                 culture: null,
11038                 icons: {
11039                         down: "ui-icon-triangle-1-s",
11040                         up: "ui-icon-triangle-1-n"
11041                 },
11042                 incremental: true,
11043                 max: null,
11044                 min: null,
11045                 numberFormat: null,
11046                 page: 10,
11047                 step: 1,
11048
11049                 change: null,
11050                 spin: null,
11051                 start: null,
11052                 stop: null
11053         },
11054
11055         _create: function() {
11056                 // handle string values that need to be parsed
11057                 this._setOption( "max", this.options.max );
11058                 this._setOption( "min", this.options.min );
11059                 this._setOption( "step", this.options.step );
11060
11061                 // format the value, but don't constrain
11062                 this._value( this.element.val(), true );
11063
11064                 this._draw();
11065                 this._on( this._events );
11066                 this._refresh();
11067
11068                 // turning off autocomplete prevents the browser from remembering the
11069                 // value when navigating through history, so we re-enable autocomplete
11070                 // if the page is unloaded before the widget is destroyed. #7790
11071                 this._on( this.window, {
11072                         beforeunload: function() {
11073                                 this.element.removeAttr( "autocomplete" );
11074                         }
11075                 });
11076         },
11077
11078         _getCreateOptions: function() {
11079                 var options = {},
11080                         element = this.element;
11081
11082                 $.each( [ "min", "max", "step" ], function( i, option ) {
11083                         var value = element.attr( option );
11084                         if ( value !== undefined && value.length ) {
11085                                 options[ option ] = value;
11086                         }
11087                 });
11088
11089                 return options;
11090         },
11091
11092         _events: {
11093                 keydown: function( event ) {
11094                         if ( this._start( event ) && this._keydown( event ) ) {
11095                                 event.preventDefault();
11096                         }
11097                 },
11098                 keyup: "_stop",
11099                 focus: function() {
11100                         this.previous = this.element.val();
11101                 },
11102                 blur: function( event ) {
11103                         if ( this.cancelBlur ) {
11104                                 delete this.cancelBlur;
11105                                 return;
11106                         }
11107
11108                         this._stop();
11109                         this._refresh();
11110                         if ( this.previous !== this.element.val() ) {
11111                                 this._trigger( "change", event );
11112                         }
11113                 },
11114                 mousewheel: function( event, delta ) {
11115                         if ( !delta ) {
11116                                 return;
11117                         }
11118                         if ( !this.spinning && !this._start( event ) ) {
11119                                 return false;
11120                         }
11121
11122                         this._spin( (delta > 0 ? 1 : -1) * this.options.step, event );
11123                         clearTimeout( this.mousewheelTimer );
11124                         this.mousewheelTimer = this._delay(function() {
11125                                 if ( this.spinning ) {
11126                                         this._stop( event );
11127                                 }
11128                         }, 100 );
11129                         event.preventDefault();
11130                 },
11131                 "mousedown .ui-spinner-button": function( event ) {
11132                         var previous;
11133
11134                         // We never want the buttons to have focus; whenever the user is
11135                         // interacting with the spinner, the focus should be on the input.
11136                         // If the input is focused then this.previous is properly set from
11137                         // when the input first received focus. If the input is not focused
11138                         // then we need to set this.previous based on the value before spinning.
11139                         previous = this.element[0] === this.document[0].activeElement ?
11140                                 this.previous : this.element.val();
11141                         function checkFocus() {
11142                                 var isActive = this.element[0] === this.document[0].activeElement;
11143                                 if ( !isActive ) {
11144                                         this.element.focus();
11145                                         this.previous = previous;
11146                                         // support: IE
11147                                         // IE sets focus asynchronously, so we need to check if focus
11148                                         // moved off of the input because the user clicked on the button.
11149                                         this._delay(function() {
11150                                                 this.previous = previous;
11151                                         });
11152                                 }
11153                         }
11154
11155                         // ensure focus is on (or stays on) the text field
11156                         event.preventDefault();
11157                         checkFocus.call( this );
11158
11159                         // support: IE
11160                         // IE doesn't prevent moving focus even with event.preventDefault()
11161                         // so we set a flag to know when we should ignore the blur event
11162                         // and check (again) if focus moved off of the input.
11163                         this.cancelBlur = true;
11164                         this._delay(function() {
11165                                 delete this.cancelBlur;
11166                                 checkFocus.call( this );
11167                         });
11168
11169                         if ( this._start( event ) === false ) {
11170                                 return;
11171                         }
11172
11173                         this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
11174                 },
11175                 "mouseup .ui-spinner-button": "_stop",
11176                 "mouseenter .ui-spinner-button": function( event ) {
11177                         // button will add ui-state-active if mouse was down while mouseleave and kept down
11178                         if ( !$( event.currentTarget ).hasClass( "ui-state-active" ) ) {
11179                                 return;
11180                         }
11181
11182                         if ( this._start( event ) === false ) {
11183                                 return false;
11184                         }
11185                         this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
11186                 },
11187                 // TODO: do we really want to consider this a stop?
11188                 // shouldn't we just stop the repeater and wait until mouseup before
11189                 // we trigger the stop event?
11190                 "mouseleave .ui-spinner-button": "_stop"
11191         },
11192
11193         _draw: function() {
11194                 var uiSpinner = this.uiSpinner = this.element
11195                         .addClass( "ui-spinner-input" )
11196                         .attr( "autocomplete", "off" )
11197                         .wrap( this._uiSpinnerHtml() )
11198                         .parent()
11199                                 // add buttons
11200                                 .append( this._buttonHtml() );
11201
11202                 this.element.attr( "role", "spinbutton" );
11203
11204                 // button bindings
11205                 this.buttons = uiSpinner.find( ".ui-spinner-button" )
11206                         .attr( "tabIndex", -1 )
11207                         .button()
11208                         .removeClass( "ui-corner-all" );
11209
11210                 // IE 6 doesn't understand height: 50% for the buttons
11211                 // unless the wrapper has an explicit height
11212                 if ( this.buttons.height() > Math.ceil( uiSpinner.height() * 0.5 ) &&
11213                                 uiSpinner.height() > 0 ) {
11214                         uiSpinner.height( uiSpinner.height() );
11215                 }
11216
11217                 // disable spinner if element was already disabled
11218                 if ( this.options.disabled ) {
11219                         this.disable();
11220                 }
11221         },
11222
11223         _keydown: function( event ) {
11224                 var options = this.options,
11225                         keyCode = $.ui.keyCode;
11226
11227                 switch ( event.keyCode ) {
11228                 case keyCode.UP:
11229                         this._repeat( null, 1, event );
11230                         return true;
11231                 case keyCode.DOWN:
11232                         this._repeat( null, -1, event );
11233                         return true;
11234                 case keyCode.PAGE_UP:
11235                         this._repeat( null, options.page, event );
11236                         return true;
11237                 case keyCode.PAGE_DOWN:
11238                         this._repeat( null, -options.page, event );
11239                         return true;
11240                 }
11241
11242                 return false;
11243         },
11244
11245         _uiSpinnerHtml: function() {
11246                 return "<span class='ui-spinner ui-widget ui-widget-content ui-corner-all'></span>";
11247         },
11248
11249         _buttonHtml: function() {
11250                 return "" +
11251                         "<a class='ui-spinner-button ui-spinner-up ui-corner-tr'>" +
11252                                 "<span class='ui-icon " + this.options.icons.up + "'>&#9650;</span>" +
11253                         "</a>" +
11254                         "<a class='ui-spinner-button ui-spinner-down ui-corner-br'>" +
11255                                 "<span class='ui-icon " + this.options.icons.down + "'>&#9660;</span>" +
11256                         "</a>";
11257         },
11258
11259         _start: function( event ) {
11260                 if ( !this.spinning && this._trigger( "start", event ) === false ) {
11261                         return false;
11262                 }
11263
11264                 if ( !this.counter ) {
11265                         this.counter = 1;
11266                 }
11267                 this.spinning = true;
11268                 return true;
11269         },
11270
11271         _repeat: function( i, steps, event ) {
11272                 i = i || 500;
11273
11274                 clearTimeout( this.timer );
11275                 this.timer = this._delay(function() {
11276                         this._repeat( 40, steps, event );
11277                 }, i );
11278
11279                 this._spin( steps * this.options.step, event );
11280         },
11281
11282         _spin: function( step, event ) {
11283                 var value = this.value() || 0;
11284
11285                 if ( !this.counter ) {
11286                         this.counter = 1;
11287                 }
11288
11289                 value = this._adjustValue( value + step * this._increment( this.counter ) );
11290
11291                 if ( !this.spinning || this._trigger( "spin", event, { value: value } ) !== false) {
11292                         this._value( value );
11293                         this.counter++;
11294                 }
11295         },
11296
11297         _increment: function( i ) {
11298                 var incremental = this.options.incremental;
11299
11300                 if ( incremental ) {
11301                         return $.isFunction( incremental ) ?
11302                                 incremental( i ) :
11303                                 Math.floor( i*i*i/50000 - i*i/500 + 17*i/200 + 1 );
11304                 }
11305
11306                 return 1;
11307         },
11308
11309         _precision: function() {
11310                 var precision = this._precisionOf( this.options.step );
11311                 if ( this.options.min !== null ) {
11312                         precision = Math.max( precision, this._precisionOf( this.options.min ) );
11313                 }
11314                 return precision;
11315         },
11316
11317         _precisionOf: function( num ) {
11318                 var str = num.toString(),
11319                         decimal = str.indexOf( "." );
11320                 return decimal === -1 ? 0 : str.length - decimal - 1;
11321         },
11322
11323         _adjustValue: function( value ) {
11324                 var base, aboveMin,
11325                         options = this.options;
11326
11327                 // make sure we're at a valid step
11328                 // - find out where we are relative to the base (min or 0)
11329                 base = options.min !== null ? options.min : 0;
11330                 aboveMin = value - base;
11331                 // - round to the nearest step
11332                 aboveMin = Math.round(aboveMin / options.step) * options.step;
11333                 // - rounding is based on 0, so adjust back to our base
11334                 value = base + aboveMin;
11335
11336                 // fix precision from bad JS floating point math
11337                 value = parseFloat( value.toFixed( this._precision() ) );
11338
11339                 // clamp the value
11340                 if ( options.max !== null && value > options.max) {
11341                         return options.max;
11342                 }
11343                 if ( options.min !== null && value < options.min ) {
11344                         return options.min;
11345                 }
11346
11347                 return value;
11348         },
11349
11350         _stop: function( event ) {
11351                 if ( !this.spinning ) {
11352                         return;
11353                 }
11354
11355                 clearTimeout( this.timer );
11356                 clearTimeout( this.mousewheelTimer );
11357                 this.counter = 0;
11358                 this.spinning = false;
11359                 this._trigger( "stop", event );
11360         },
11361
11362         _setOption: function( key, value ) {
11363                 if ( key === "culture" || key === "numberFormat" ) {
11364                         var prevValue = this._parse( this.element.val() );
11365                         this.options[ key ] = value;
11366                         this.element.val( this._format( prevValue ) );
11367                         return;
11368                 }
11369
11370                 if ( key === "max" || key === "min" || key === "step" ) {
11371                         if ( typeof value === "string" ) {
11372                                 value = this._parse( value );
11373                         }
11374                 }
11375                 if ( key === "icons" ) {
11376                         this.buttons.first().find( ".ui-icon" )
11377                                 .removeClass( this.options.icons.up )
11378                                 .addClass( value.up );
11379                         this.buttons.last().find( ".ui-icon" )
11380                                 .removeClass( this.options.icons.down )
11381                                 .addClass( value.down );
11382                 }
11383
11384                 this._super( key, value );
11385
11386                 if ( key === "disabled" ) {
11387                         if ( value ) {
11388                                 this.element.prop( "disabled", true );
11389                                 this.buttons.button( "disable" );
11390                         } else {
11391                                 this.element.prop( "disabled", false );
11392                                 this.buttons.button( "enable" );
11393                         }
11394                 }
11395         },
11396
11397         _setOptions: modifier(function( options ) {
11398                 this._super( options );
11399                 this._value( this.element.val() );
11400         }),
11401
11402         _parse: function( val ) {
11403                 if ( typeof val === "string" && val !== "" ) {
11404                         val = window.Globalize && this.options.numberFormat ?
11405                                 Globalize.parseFloat( val, 10, this.options.culture ) : +val;
11406                 }
11407                 return val === "" || isNaN( val ) ? null : val;
11408         },
11409
11410         _format: function( value ) {
11411                 if ( value === "" ) {
11412                         return "";
11413                 }
11414                 return window.Globalize && this.options.numberFormat ?
11415                         Globalize.format( value, this.options.numberFormat, this.options.culture ) :
11416                         value;
11417         },
11418
11419         _refresh: function() {
11420                 this.element.attr({
11421                         "aria-valuemin": this.options.min,
11422                         "aria-valuemax": this.options.max,
11423                         // TODO: what should we do with values that can't be parsed?
11424                         "aria-valuenow": this._parse( this.element.val() )
11425                 });
11426         },
11427
11428         // update the value without triggering change
11429         _value: function( value, allowAny ) {
11430                 var parsed;
11431                 if ( value !== "" ) {
11432                         parsed = this._parse( value );
11433                         if ( parsed !== null ) {
11434                                 if ( !allowAny ) {
11435                                         parsed = this._adjustValue( parsed );
11436                                 }
11437                                 value = this._format( parsed );
11438                         }
11439                 }
11440                 this.element.val( value );
11441                 this._refresh();
11442         },
11443
11444         _destroy: function() {
11445                 this.element
11446                         .removeClass( "ui-spinner-input" )
11447                         .prop( "disabled", false )
11448                         .removeAttr( "autocomplete" )
11449                         .removeAttr( "role" )
11450                         .removeAttr( "aria-valuemin" )
11451                         .removeAttr( "aria-valuemax" )
11452                         .removeAttr( "aria-valuenow" );
11453                 this.uiSpinner.replaceWith( this.element );
11454         },
11455
11456         stepUp: modifier(function( steps ) {
11457                 this._stepUp( steps );
11458         }),
11459         _stepUp: function( steps ) {
11460                 if ( this._start() ) {
11461                         this._spin( (steps || 1) * this.options.step );
11462                         this._stop();
11463                 }
11464         },
11465
11466         stepDown: modifier(function( steps ) {
11467                 this._stepDown( steps );
11468         }),
11469         _stepDown: function( steps ) {
11470                 if ( this._start() ) {
11471                         this._spin( (steps || 1) * -this.options.step );
11472                         this._stop();
11473                 }
11474         },
11475
11476         pageUp: modifier(function( pages ) {
11477                 this._stepUp( (pages || 1) * this.options.page );
11478         }),
11479
11480         pageDown: modifier(function( pages ) {
11481                 this._stepDown( (pages || 1) * this.options.page );
11482         }),
11483
11484         value: function( newVal ) {
11485                 if ( !arguments.length ) {
11486                         return this._parse( this.element.val() );
11487                 }
11488                 modifier( this._value ).call( this, newVal );
11489         },
11490
11491         widget: function() {
11492                 return this.uiSpinner;
11493         }
11494 });
11495
11496 }( jQuery ) );
11497 (function( $, undefined ) {
11498
11499 var tabId = 0,
11500         rhash = /#.*$/;
11501
11502 function getNextTabId() {
11503         return ++tabId;
11504 }
11505
11506 function isLocal( anchor ) {
11507         return anchor.hash.length > 1 &&
11508                 decodeURIComponent( anchor.href.replace( rhash, "" ) ) ===
11509                         decodeURIComponent( location.href.replace( rhash, "" ) );
11510 }
11511
11512 $.widget( "ui.tabs", {
11513         version: "1.10.3",
11514         delay: 300,
11515         options: {
11516                 active: null,
11517                 collapsible: false,
11518                 event: "click",
11519                 heightStyle: "content",
11520                 hide: null,
11521                 show: null,
11522
11523                 // callbacks
11524                 activate: null,
11525                 beforeActivate: null,
11526                 beforeLoad: null,
11527                 load: null
11528         },
11529
11530         _create: function() {
11531                 var that = this,
11532                         options = this.options;
11533
11534                 this.running = false;
11535
11536                 this.element
11537                         .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
11538                         .toggleClass( "ui-tabs-collapsible", options.collapsible )
11539                         // Prevent users from focusing disabled tabs via click
11540                         .delegate( ".ui-tabs-nav > li", "mousedown" + this.eventNamespace, function( event ) {
11541                                 if ( $( this ).is( ".ui-state-disabled" ) ) {
11542                                         event.preventDefault();
11543                                 }
11544                         })
11545                         // support: IE <9
11546                         // Preventing the default action in mousedown doesn't prevent IE
11547                         // from focusing the element, so if the anchor gets focused, blur.
11548                         // We don't have to worry about focusing the previously focused
11549                         // element since clicking on a non-focusable element should focus
11550                         // the body anyway.
11551                         .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
11552                                 if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
11553                                         this.blur();
11554                                 }
11555                         });
11556
11557                 this._processTabs();
11558                 options.active = this._initialActive();
11559
11560                 // Take disabling tabs via class attribute from HTML
11561                 // into account and update option properly.
11562                 if ( $.isArray( options.disabled ) ) {
11563                         options.disabled = $.unique( options.disabled.concat(
11564                                 $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
11565                                         return that.tabs.index( li );
11566                                 })
11567                         ) ).sort();
11568                 }
11569
11570                 // check for length avoids error when initializing empty list
11571                 if ( this.options.active !== false && this.anchors.length ) {
11572                         this.active = this._findActive( options.active );
11573                 } else {
11574                         this.active = $();
11575                 }
11576
11577                 this._refresh();
11578
11579                 if ( this.active.length ) {
11580                         this.load( options.active );
11581                 }
11582         },
11583
11584         _initialActive: function() {
11585                 var active = this.options.active,
11586                         collapsible = this.options.collapsible,
11587                         locationHash = location.hash.substring( 1 );
11588
11589                 if ( active === null ) {
11590                         // check the fragment identifier in the URL
11591                         if ( locationHash ) {
11592                                 this.tabs.each(function( i, tab ) {
11593                                         if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
11594                                                 active = i;
11595                                                 return false;
11596                                         }
11597                                 });
11598                         }
11599
11600                         // check for a tab marked active via a class
11601                         if ( active === null ) {
11602                                 active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
11603                         }
11604
11605                         // no active tab, set to false
11606                         if ( active === null || active === -1 ) {
11607                                 active = this.tabs.length ? 0 : false;
11608                         }
11609                 }
11610
11611                 // handle numbers: negative, out of range
11612                 if ( active !== false ) {
11613                         active = this.tabs.index( this.tabs.eq( active ) );
11614                         if ( active === -1 ) {
11615                                 active = collapsible ? false : 0;
11616                         }
11617                 }
11618
11619                 // don't allow collapsible: false and active: false
11620                 if ( !collapsible && active === false && this.anchors.length ) {
11621                         active = 0;
11622                 }
11623
11624                 return active;
11625         },
11626
11627         _getCreateEventData: function() {
11628                 return {
11629                         tab: this.active,
11630                         panel: !this.active.length ? $() : this._getPanelForTab( this.active )
11631                 };
11632         },
11633
11634         _tabKeydown: function( event ) {
11635                 /*jshint maxcomplexity:15*/
11636                 var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
11637                         selectedIndex = this.tabs.index( focusedTab ),
11638                         goingForward = true;
11639
11640                 if ( this._handlePageNav( event ) ) {
11641                         return;
11642                 }
11643
11644                 switch ( event.keyCode ) {
11645                         case $.ui.keyCode.RIGHT:
11646                         case $.ui.keyCode.DOWN:
11647                                 selectedIndex++;
11648                                 break;
11649                         case $.ui.keyCode.UP:
11650                         case $.ui.keyCode.LEFT:
11651                                 goingForward = false;
11652                                 selectedIndex--;
11653                                 break;
11654                         case $.ui.keyCode.END:
11655                                 selectedIndex = this.anchors.length - 1;
11656                                 break;
11657                         case $.ui.keyCode.HOME:
11658                                 selectedIndex = 0;
11659                                 break;
11660                         case $.ui.keyCode.SPACE:
11661                                 // Activate only, no collapsing
11662                                 event.preventDefault();
11663                                 clearTimeout( this.activating );
11664                                 this._activate( selectedIndex );
11665                                 return;
11666                         case $.ui.keyCode.ENTER:
11667                                 // Toggle (cancel delayed activation, allow collapsing)
11668                                 event.preventDefault();
11669                                 clearTimeout( this.activating );
11670                                 // Determine if we should collapse or activate
11671                                 this._activate( selectedIndex === this.options.active ? false : selectedIndex );
11672                                 return;
11673                         default:
11674                                 return;
11675                 }
11676
11677                 // Focus the appropriate tab, based on which key was pressed
11678                 event.preventDefault();
11679                 clearTimeout( this.activating );
11680                 selectedIndex = this._focusNextTab( selectedIndex, goingForward );
11681
11682                 // Navigating with control key will prevent automatic activation
11683                 if ( !event.ctrlKey ) {
11684                         // Update aria-selected immediately so that AT think the tab is already selected.
11685                         // Otherwise AT may confuse the user by stating that they need to activate the tab,
11686                         // but the tab will already be activated by the time the announcement finishes.
11687                         focusedTab.attr( "aria-selected", "false" );
11688                         this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
11689
11690                         this.activating = this._delay(function() {
11691                                 this.option( "active", selectedIndex );
11692                         }, this.delay );
11693                 }
11694         },
11695
11696         _panelKeydown: function( event ) {
11697                 if ( this._handlePageNav( event ) ) {
11698                         return;
11699                 }
11700
11701                 // Ctrl+up moves focus to the current tab
11702                 if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
11703                         event.preventDefault();
11704                         this.active.focus();
11705                 }
11706         },
11707
11708         // Alt+page up/down moves focus to the previous/next tab (and activates)
11709         _handlePageNav: function( event ) {
11710                 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
11711                         this._activate( this._focusNextTab( this.options.active - 1, false ) );
11712                         return true;
11713                 }
11714                 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
11715                         this._activate( this._focusNextTab( this.options.active + 1, true ) );
11716                         return true;
11717                 }
11718         },
11719
11720         _findNextTab: function( index, goingForward ) {
11721                 var lastTabIndex = this.tabs.length - 1;
11722
11723                 function constrain() {
11724                         if ( index > lastTabIndex ) {
11725                                 index = 0;
11726                         }
11727                         if ( index < 0 ) {
11728                                 index = lastTabIndex;
11729                         }
11730                         return index;
11731                 }
11732
11733                 while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
11734                         index = goingForward ? index + 1 : index - 1;
11735                 }
11736
11737                 return index;
11738         },
11739
11740         _focusNextTab: function( index, goingForward ) {
11741                 index = this._findNextTab( index, goingForward );
11742                 this.tabs.eq( index ).focus();
11743                 return index;
11744         },
11745
11746         _setOption: function( key, value ) {
11747                 if ( key === "active" ) {
11748                         // _activate() will handle invalid values and update this.options
11749                         this._activate( value );
11750                         return;
11751                 }
11752
11753                 if ( key === "disabled" ) {
11754                         // don't use the widget factory's disabled handling
11755                         this._setupDisabled( value );
11756                         return;
11757                 }
11758
11759                 this._super( key, value);
11760
11761                 if ( key === "collapsible" ) {
11762                         this.element.toggleClass( "ui-tabs-collapsible", value );
11763                         // Setting collapsible: false while collapsed; open first panel
11764                         if ( !value && this.options.active === false ) {
11765                                 this._activate( 0 );
11766                         }
11767                 }
11768
11769                 if ( key === "event" ) {
11770                         this._setupEvents( value );
11771                 }
11772
11773                 if ( key === "heightStyle" ) {
11774                         this._setupHeightStyle( value );
11775                 }
11776         },
11777
11778         _tabId: function( tab ) {
11779                 return tab.attr( "aria-controls" ) || "ui-tabs-" + getNextTabId();
11780         },
11781
11782         _sanitizeSelector: function( hash ) {
11783                 return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
11784         },
11785
11786         refresh: function() {
11787                 var options = this.options,
11788                         lis = this.tablist.children( ":has(a[href])" );
11789
11790                 // get disabled tabs from class attribute from HTML
11791                 // this will get converted to a boolean if needed in _refresh()
11792                 options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
11793                         return lis.index( tab );
11794                 });
11795
11796                 this._processTabs();
11797
11798                 // was collapsed or no tabs
11799                 if ( options.active === false || !this.anchors.length ) {
11800                         options.active = false;
11801                         this.active = $();
11802                 // was active, but active tab is gone
11803                 } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
11804                         // all remaining tabs are disabled
11805                         if ( this.tabs.length === options.disabled.length ) {
11806                                 options.active = false;
11807                                 this.active = $();
11808                         // activate previous tab
11809                         } else {
11810                                 this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
11811                         }
11812                 // was active, active tab still exists
11813                 } else {
11814                         // make sure active index is correct
11815                         options.active = this.tabs.index( this.active );
11816                 }
11817
11818                 this._refresh();
11819         },
11820
11821         _refresh: function() {
11822                 this._setupDisabled( this.options.disabled );
11823                 this._setupEvents( this.options.event );
11824                 this._setupHeightStyle( this.options.heightStyle );
11825
11826                 this.tabs.not( this.active ).attr({
11827                         "aria-selected": "false",
11828                         tabIndex: -1
11829                 });
11830                 this.panels.not( this._getPanelForTab( this.active ) )
11831                         .hide()
11832                         .attr({
11833                                 "aria-expanded": "false",
11834                                 "aria-hidden": "true"
11835                         });
11836
11837                 // Make sure one tab is in the tab order
11838                 if ( !this.active.length ) {
11839                         this.tabs.eq( 0 ).attr( "tabIndex", 0 );
11840                 } else {
11841                         this.active
11842                                 .addClass( "ui-tabs-active ui-state-active" )
11843                                 .attr({
11844                                         "aria-selected": "true",
11845                                         tabIndex: 0
11846                                 });
11847                         this._getPanelForTab( this.active )
11848                                 .show()
11849                                 .attr({
11850                                         "aria-expanded": "true",
11851                                         "aria-hidden": "false"
11852                                 });
11853                 }
11854         },
11855
11856         _processTabs: function() {
11857                 var that = this;
11858
11859                 this.tablist = this._getList()
11860                         .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
11861                         .attr( "role", "tablist" );
11862
11863                 this.tabs = this.tablist.find( "> li:has(a[href])" )
11864                         .addClass( "ui-state-default ui-corner-top" )
11865                         .attr({
11866                                 role: "tab",
11867                                 tabIndex: -1
11868                         });
11869
11870                 this.anchors = this.tabs.map(function() {
11871                                 return $( "a", this )[ 0 ];
11872                         })
11873                         .addClass( "ui-tabs-anchor" )
11874                         .attr({
11875                                 role: "presentation",
11876                                 tabIndex: -1
11877                         });
11878
11879                 this.panels = $();
11880
11881                 this.anchors.each(function( i, anchor ) {
11882                         var selector, panel, panelId,
11883                                 anchorId = $( anchor ).uniqueId().attr( "id" ),
11884                                 tab = $( anchor ).closest( "li" ),
11885                                 originalAriaControls = tab.attr( "aria-controls" );
11886
11887                         // inline tab
11888                         if ( isLocal( anchor ) ) {
11889                                 selector = anchor.hash;
11890                                 panel = that.element.find( that._sanitizeSelector( selector ) );
11891                         // remote tab
11892                         } else {
11893                                 panelId = that._tabId( tab );
11894                                 selector = "#" + panelId;
11895                                 panel = that.element.find( selector );
11896                                 if ( !panel.length ) {
11897                                         panel = that._createPanel( panelId );
11898                                         panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
11899                                 }
11900                                 panel.attr( "aria-live", "polite" );
11901                         }
11902
11903                         if ( panel.length) {
11904                                 that.panels = that.panels.add( panel );
11905                         }
11906                         if ( originalAriaControls ) {
11907                                 tab.data( "ui-tabs-aria-controls", originalAriaControls );
11908                         }
11909                         tab.attr({
11910                                 "aria-controls": selector.substring( 1 ),
11911                                 "aria-labelledby": anchorId
11912                         });
11913                         panel.attr( "aria-labelledby", anchorId );
11914                 });
11915
11916                 this.panels
11917                         .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
11918                         .attr( "role", "tabpanel" );
11919         },
11920
11921         // allow overriding how to find the list for rare usage scenarios (#7715)
11922         _getList: function() {
11923                 return this.element.find( "ol,ul" ).eq( 0 );
11924         },
11925
11926         _createPanel: function( id ) {
11927                 return $( "<div>" )
11928                         .attr( "id", id )
11929                         .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
11930                         .data( "ui-tabs-destroy", true );
11931         },
11932
11933         _setupDisabled: function( disabled ) {
11934                 if ( $.isArray( disabled ) ) {
11935                         if ( !disabled.length ) {
11936                                 disabled = false;
11937                         } else if ( disabled.length === this.anchors.length ) {
11938                                 disabled = true;
11939                         }
11940                 }
11941
11942                 // disable tabs
11943                 for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
11944                         if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
11945                                 $( li )
11946                                         .addClass( "ui-state-disabled" )
11947                                         .attr( "aria-disabled", "true" );
11948                         } else {
11949                                 $( li )
11950                                         .removeClass( "ui-state-disabled" )
11951                                         .removeAttr( "aria-disabled" );
11952                         }
11953                 }
11954
11955                 this.options.disabled = disabled;
11956         },
11957
11958         _setupEvents: function( event ) {
11959                 var events = {
11960                         click: function( event ) {
11961                                 event.preventDefault();
11962                         }
11963                 };
11964                 if ( event ) {
11965                         $.each( event.split(" "), function( index, eventName ) {
11966                                 events[ eventName ] = "_eventHandler";
11967                         });
11968                 }
11969
11970                 this._off( this.anchors.add( this.tabs ).add( this.panels ) );
11971                 this._on( this.anchors, events );
11972                 this._on( this.tabs, { keydown: "_tabKeydown" } );
11973                 this._on( this.panels, { keydown: "_panelKeydown" } );
11974
11975                 this._focusable( this.tabs );
11976                 this._hoverable( this.tabs );
11977         },
11978
11979         _setupHeightStyle: function( heightStyle ) {
11980                 var maxHeight,
11981                         parent = this.element.parent();
11982
11983                 if ( heightStyle === "fill" ) {
11984                         maxHeight = parent.height();
11985                         maxHeight -= this.element.outerHeight() - this.element.height();
11986
11987                         this.element.siblings( ":visible" ).each(function() {
11988                                 var elem = $( this ),
11989                                         position = elem.css( "position" );
11990
11991                                 if ( position === "absolute" || position === "fixed" ) {
11992                                         return;
11993                                 }
11994                                 maxHeight -= elem.outerHeight( true );
11995                         });
11996
11997                         this.element.children().not( this.panels ).each(function() {
11998                                 maxHeight -= $( this ).outerHeight( true );
11999                         });
12000
12001                         this.panels.each(function() {
12002                                 $( this ).height( Math.max( 0, maxHeight -
12003                                         $( this ).innerHeight() + $( this ).height() ) );
12004                         })
12005                         .css( "overflow", "auto" );
12006                 } else if ( heightStyle === "auto" ) {
12007                         maxHeight = 0;
12008                         this.panels.each(function() {
12009                                 maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
12010                         }).height( maxHeight );
12011                 }
12012         },
12013
12014         _eventHandler: function( event ) {
12015                 var options = this.options,
12016                         active = this.active,
12017                         anchor = $( event.currentTarget ),
12018                         tab = anchor.closest( "li" ),
12019                         clickedIsActive = tab[ 0 ] === active[ 0 ],
12020                         collapsing = clickedIsActive && options.collapsible,
12021                         toShow = collapsing ? $() : this._getPanelForTab( tab ),
12022                         toHide = !active.length ? $() : this._getPanelForTab( active ),
12023                         eventData = {
12024                                 oldTab: active,
12025                                 oldPanel: toHide,
12026                                 newTab: collapsing ? $() : tab,
12027                                 newPanel: toShow
12028                         };
12029
12030                 event.preventDefault();
12031
12032                 if ( tab.hasClass( "ui-state-disabled" ) ||
12033                                 // tab is already loading
12034                                 tab.hasClass( "ui-tabs-loading" ) ||
12035                                 // can't switch durning an animation
12036                                 this.running ||
12037                                 // click on active header, but not collapsible
12038                                 ( clickedIsActive && !options.collapsible ) ||
12039                                 // allow canceling activation
12040                                 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
12041                         return;
12042                 }
12043
12044                 options.active = collapsing ? false : this.tabs.index( tab );
12045
12046                 this.active = clickedIsActive ? $() : tab;
12047                 if ( this.xhr ) {
12048                         this.xhr.abort();
12049                 }
12050
12051                 if ( !toHide.length && !toShow.length ) {
12052                         $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
12053                 }
12054
12055                 if ( toShow.length ) {
12056                         this.load( this.tabs.index( tab ), event );
12057                 }
12058                 this._toggle( event, eventData );
12059         },
12060
12061         // handles show/hide for selecting tabs
12062         _toggle: function( event, eventData ) {
12063                 var that = this,
12064                         toShow = eventData.newPanel,
12065                         toHide = eventData.oldPanel;
12066
12067                 this.running = true;
12068
12069                 function complete() {
12070                         that.running = false;
12071                         that._trigger( "activate", event, eventData );
12072                 }
12073
12074                 function show() {
12075                         eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
12076
12077                         if ( toShow.length && that.options.show ) {
12078                                 that._show( toShow, that.options.show, complete );
12079                         } else {
12080                                 toShow.show();
12081                                 complete();
12082                         }
12083                 }
12084
12085                 // start out by hiding, then showing, then completing
12086                 if ( toHide.length && this.options.hide ) {
12087                         this._hide( toHide, this.options.hide, function() {
12088                                 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
12089                                 show();
12090                         });
12091                 } else {
12092                         eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
12093                         toHide.hide();
12094                         show();
12095                 }
12096
12097                 toHide.attr({
12098                         "aria-expanded": "false",
12099                         "aria-hidden": "true"
12100                 });
12101                 eventData.oldTab.attr( "aria-selected", "false" );
12102                 // If we're switching tabs, remove the old tab from the tab order.
12103                 // If we're opening from collapsed state, remove the previous tab from the tab order.
12104                 // If we're collapsing, then keep the collapsing tab in the tab order.
12105                 if ( toShow.length && toHide.length ) {
12106                         eventData.oldTab.attr( "tabIndex", -1 );
12107                 } else if ( toShow.length ) {
12108                         this.tabs.filter(function() {
12109                                 return $( this ).attr( "tabIndex" ) === 0;
12110                         })
12111                         .attr( "tabIndex", -1 );
12112                 }
12113
12114                 toShow.attr({
12115                         "aria-expanded": "true",
12116                         "aria-hidden": "false"
12117                 });
12118                 eventData.newTab.attr({
12119                         "aria-selected": "true",
12120                         tabIndex: 0
12121                 });
12122         },
12123
12124         _activate: function( index ) {
12125                 var anchor,
12126                         active = this._findActive( index );
12127
12128                 // trying to activate the already active panel
12129                 if ( active[ 0 ] === this.active[ 0 ] ) {
12130                         return;
12131                 }
12132
12133                 // trying to collapse, simulate a click on the current active header
12134                 if ( !active.length ) {
12135                         active = this.active;
12136                 }
12137
12138                 anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
12139                 this._eventHandler({
12140                         target: anchor,
12141                         currentTarget: anchor,
12142                         preventDefault: $.noop
12143                 });
12144         },
12145
12146         _findActive: function( index ) {
12147                 return index === false ? $() : this.tabs.eq( index );
12148         },
12149
12150         _getIndex: function( index ) {
12151                 // meta-function to give users option to provide a href string instead of a numerical index.
12152                 if ( typeof index === "string" ) {
12153                         index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
12154                 }
12155
12156                 return index;
12157         },
12158
12159         _destroy: function() {
12160                 if ( this.xhr ) {
12161                         this.xhr.abort();
12162                 }
12163
12164                 this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
12165
12166                 this.tablist
12167                         .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
12168                         .removeAttr( "role" );
12169
12170                 this.anchors
12171                         .removeClass( "ui-tabs-anchor" )
12172                         .removeAttr( "role" )
12173                         .removeAttr( "tabIndex" )
12174                         .removeUniqueId();
12175
12176                 this.tabs.add( this.panels ).each(function() {
12177                         if ( $.data( this, "ui-tabs-destroy" ) ) {
12178                                 $( this ).remove();
12179                         } else {
12180                                 $( this )
12181                                         .removeClass( "ui-state-default ui-state-active ui-state-disabled " +
12182                                                 "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
12183                                         .removeAttr( "tabIndex" )
12184                                         .removeAttr( "aria-live" )
12185                                         .removeAttr( "aria-busy" )
12186                                         .removeAttr( "aria-selected" )
12187                                         .removeAttr( "aria-labelledby" )
12188                                         .removeAttr( "aria-hidden" )
12189                                         .removeAttr( "aria-expanded" )
12190                                         .removeAttr( "role" );
12191                         }
12192                 });
12193
12194                 this.tabs.each(function() {
12195                         var li = $( this ),
12196                                 prev = li.data( "ui-tabs-aria-controls" );
12197                         if ( prev ) {
12198                                 li
12199                                         .attr( "aria-controls", prev )
12200                                         .removeData( "ui-tabs-aria-controls" );
12201                         } else {
12202                                 li.removeAttr( "aria-controls" );
12203                         }
12204                 });
12205
12206                 this.panels.show();
12207
12208                 if ( this.options.heightStyle !== "content" ) {
12209                         this.panels.css( "height", "" );
12210                 }
12211         },
12212
12213         enable: function( index ) {
12214                 var disabled = this.options.disabled;
12215                 if ( disabled === false ) {
12216                         return;
12217                 }
12218
12219                 if ( index === undefined ) {
12220                         disabled = false;
12221                 } else {
12222                         index = this._getIndex( index );
12223                         if ( $.isArray( disabled ) ) {
12224                                 disabled = $.map( disabled, function( num ) {
12225                                         return num !== index ? num : null;
12226                                 });
12227                         } else {
12228                                 disabled = $.map( this.tabs, function( li, num ) {
12229                                         return num !== index ? num : null;
12230                                 });
12231                         }
12232                 }
12233                 this._setupDisabled( disabled );
12234         },
12235
12236         disable: function( index ) {
12237                 var disabled = this.options.disabled;
12238                 if ( disabled === true ) {
12239                         return;
12240                 }
12241
12242                 if ( index === undefined ) {
12243                         disabled = true;
12244                 } else {
12245                         index = this._getIndex( index );
12246                         if ( $.inArray( index, disabled ) !== -1 ) {
12247                                 return;
12248                         }
12249                         if ( $.isArray( disabled ) ) {
12250                                 disabled = $.merge( [ index ], disabled ).sort();
12251                         } else {
12252                                 disabled = [ index ];
12253                         }
12254                 }
12255                 this._setupDisabled( disabled );
12256         },
12257
12258         load: function( index, event ) {
12259                 index = this._getIndex( index );
12260                 var that = this,
12261                         tab = this.tabs.eq( index ),
12262                         anchor = tab.find( ".ui-tabs-anchor" ),
12263                         panel = this._getPanelForTab( tab ),
12264                         eventData = {
12265                                 tab: tab,
12266                                 panel: panel
12267                         };
12268
12269                 // not remote
12270                 if ( isLocal( anchor[ 0 ] ) ) {
12271                         return;
12272                 }
12273
12274                 this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
12275
12276                 // support: jQuery <1.8
12277                 // jQuery <1.8 returns false if the request is canceled in beforeSend,
12278                 // but as of 1.8, $.ajax() always returns a jqXHR object.
12279                 if ( this.xhr && this.xhr.statusText !== "canceled" ) {
12280                         tab.addClass( "ui-tabs-loading" );
12281                         panel.attr( "aria-busy", "true" );
12282
12283                         this.xhr
12284                                 .success(function( response ) {
12285                                         // support: jQuery <1.8
12286                                         // http://bugs.jquery.com/ticket/11778
12287                                         setTimeout(function() {
12288                                                 panel.html( response );
12289                                                 that._trigger( "load", event, eventData );
12290                                         }, 1 );
12291                                 })
12292                                 .complete(function( jqXHR, status ) {
12293                                         // support: jQuery <1.8
12294                                         // http://bugs.jquery.com/ticket/11778
12295                                         setTimeout(function() {
12296                                                 if ( status === "abort" ) {
12297                                                         that.panels.stop( false, true );
12298                                                 }
12299
12300                                                 tab.removeClass( "ui-tabs-loading" );
12301                                                 panel.removeAttr( "aria-busy" );
12302
12303                                                 if ( jqXHR === that.xhr ) {
12304                                                         delete that.xhr;
12305                                                 }
12306                                         }, 1 );
12307                                 });
12308                 }
12309         },
12310
12311         _ajaxSettings: function( anchor, event, eventData ) {
12312                 var that = this;
12313                 return {
12314                         url: anchor.attr( "href" ),
12315                         beforeSend: function( jqXHR, settings ) {
12316                                 return that._trigger( "beforeLoad", event,
12317                                         $.extend( { jqXHR : jqXHR, ajaxSettings: settings }, eventData ) );
12318                         }
12319                 };
12320         },
12321
12322         _getPanelForTab: function( tab ) {
12323                 var id = $( tab ).attr( "aria-controls" );
12324                 return this.element.find( this._sanitizeSelector( "#" + id ) );
12325         }
12326 });
12327
12328 })( jQuery );
12329 (function( $ ) {
12330
12331 var increments = 0;
12332
12333 function addDescribedBy( elem, id ) {
12334         var describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ );
12335         describedby.push( id );
12336         elem
12337                 .data( "ui-tooltip-id", id )
12338                 .attr( "aria-describedby", $.trim( describedby.join( " " ) ) );
12339 }
12340
12341 function removeDescribedBy( elem ) {
12342         var id = elem.data( "ui-tooltip-id" ),
12343                 describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ ),
12344                 index = $.inArray( id, describedby );
12345         if ( index !== -1 ) {
12346                 describedby.splice( index, 1 );
12347         }
12348
12349         elem.removeData( "ui-tooltip-id" );
12350         describedby = $.trim( describedby.join( " " ) );
12351         if ( describedby ) {
12352                 elem.attr( "aria-describedby", describedby );
12353         } else {
12354                 elem.removeAttr( "aria-describedby" );
12355         }
12356 }
12357
12358 $.widget( "ui.tooltip", {
12359         version: "1.10.3",
12360         options: {
12361                 content: function() {
12362                         // support: IE<9, Opera in jQuery <1.7
12363                         // .text() can't accept undefined, so coerce to a string
12364                         var title = $( this ).attr( "title" ) || "";
12365                         // Escape title, since we're going from an attribute to raw HTML
12366                         return $( "<a>" ).text( title ).html();
12367                 },
12368                 hide: true,
12369                 // Disabled elements have inconsistent behavior across browsers (#8661)
12370                 items: "[title]:not([disabled])",
12371                 position: {
12372                         my: "left top+15",
12373                         at: "left bottom",
12374                         collision: "flipfit flip"
12375                 },
12376                 show: true,
12377                 tooltipClass: null,
12378                 track: false,
12379
12380                 // callbacks
12381                 close: null,
12382                 open: null
12383         },
12384
12385         _create: function() {
12386                 this._on({
12387                         mouseover: "open",
12388                         focusin: "open"
12389                 });
12390
12391                 // IDs of generated tooltips, needed for destroy
12392                 this.tooltips = {};
12393                 // IDs of parent tooltips where we removed the title attribute
12394                 this.parents = {};
12395
12396                 if ( this.options.disabled ) {
12397                         this._disable();
12398                 }
12399         },
12400
12401         _setOption: function( key, value ) {
12402                 var that = this;
12403
12404                 if ( key === "disabled" ) {
12405                         this[ value ? "_disable" : "_enable" ]();
12406                         this.options[ key ] = value;
12407                         // disable element style changes
12408                         return;
12409                 }
12410
12411                 this._super( key, value );
12412
12413                 if ( key === "content" ) {
12414                         $.each( this.tooltips, function( id, element ) {
12415                                 that._updateContent( element );
12416                         });
12417                 }
12418         },
12419
12420         _disable: function() {
12421                 var that = this;
12422
12423                 // close open tooltips
12424                 $.each( this.tooltips, function( id, element ) {
12425                         var event = $.Event( "blur" );
12426                         event.target = event.currentTarget = element[0];
12427                         that.close( event, true );
12428                 });
12429
12430                 // remove title attributes to prevent native tooltips
12431                 this.element.find( this.options.items ).addBack().each(function() {
12432                         var element = $( this );
12433                         if ( element.is( "[title]" ) ) {
12434                                 element
12435                                         .data( "ui-tooltip-title", element.attr( "title" ) )
12436                                         .attr( "title", "" );
12437                         }
12438                 });
12439         },
12440
12441         _enable: function() {
12442                 // restore title attributes
12443                 this.element.find( this.options.items ).addBack().each(function() {
12444                         var element = $( this );
12445                         if ( element.data( "ui-tooltip-title" ) ) {
12446                                 element.attr( "title", element.data( "ui-tooltip-title" ) );
12447                         }
12448                 });
12449         },
12450
12451         open: function( event ) {
12452                 var that = this,
12453                         target = $( event ? event.target : this.element )
12454                                 // we need closest here due to mouseover bubbling,
12455                                 // but always pointing at the same event target
12456                                 .closest( this.options.items );
12457
12458                 // No element to show a tooltip for or the tooltip is already open
12459                 if ( !target.length || target.data( "ui-tooltip-id" ) ) {
12460                         return;
12461                 }
12462
12463                 if ( target.attr( "title" ) ) {
12464                         target.data( "ui-tooltip-title", target.attr( "title" ) );
12465                 }
12466
12467                 target.data( "ui-tooltip-open", true );
12468
12469                 // kill parent tooltips, custom or native, for hover
12470                 if ( event && event.type === "mouseover" ) {
12471                         target.parents().each(function() {
12472                                 var parent = $( this ),
12473                                         blurEvent;
12474                                 if ( parent.data( "ui-tooltip-open" ) ) {
12475                                         blurEvent = $.Event( "blur" );
12476                                         blurEvent.target = blurEvent.currentTarget = this;
12477                                         that.close( blurEvent, true );
12478                                 }
12479                                 if ( parent.attr( "title" ) ) {
12480                                         parent.uniqueId();
12481                                         that.parents[ this.id ] = {
12482                                                 element: this,
12483                                                 title: parent.attr( "title" )
12484                                         };
12485                                         parent.attr( "title", "" );
12486                                 }
12487                         });
12488                 }
12489
12490                 this._updateContent( target, event );
12491         },
12492
12493         _updateContent: function( target, event ) {
12494                 var content,
12495                         contentOption = this.options.content,
12496                         that = this,
12497                         eventType = event ? event.type : null;
12498
12499                 if ( typeof contentOption === "string" ) {
12500                         return this._open( event, target, contentOption );
12501                 }
12502
12503                 content = contentOption.call( target[0], function( response ) {
12504                         // ignore async response if tooltip was closed already
12505                         if ( !target.data( "ui-tooltip-open" ) ) {
12506                                 return;
12507                         }
12508                         // IE may instantly serve a cached response for ajax requests
12509                         // delay this call to _open so the other call to _open runs first
12510                         that._delay(function() {
12511                                 // jQuery creates a special event for focusin when it doesn't
12512                                 // exist natively. To improve performance, the native event
12513                                 // object is reused and the type is changed. Therefore, we can't
12514                                 // rely on the type being correct after the event finished
12515                                 // bubbling, so we set it back to the previous value. (#8740)
12516                                 if ( event ) {
12517                                         event.type = eventType;
12518                                 }
12519                                 this._open( event, target, response );
12520                         });
12521                 });
12522                 if ( content ) {
12523                         this._open( event, target, content );
12524                 }
12525         },
12526
12527         _open: function( event, target, content ) {
12528                 var tooltip, events, delayedShow,
12529                         positionOption = $.extend( {}, this.options.position );
12530
12531                 if ( !content ) {
12532                         return;
12533                 }
12534
12535                 // Content can be updated multiple times. If the tooltip already
12536                 // exists, then just update the content and bail.
12537                 tooltip = this._find( target );
12538                 if ( tooltip.length ) {
12539                         tooltip.find( ".ui-tooltip-content" ).html( content );
12540                         return;
12541                 }
12542
12543                 // if we have a title, clear it to prevent the native tooltip
12544                 // we have to check first to avoid defining a title if none exists
12545                 // (we don't want to cause an element to start matching [title])
12546                 //
12547                 // We use removeAttr only for key events, to allow IE to export the correct
12548                 // accessible attributes. For mouse events, set to empty string to avoid
12549                 // native tooltip showing up (happens only when removing inside mouseover).
12550                 if ( target.is( "[title]" ) ) {
12551                         if ( event && event.type === "mouseover" ) {
12552                                 target.attr( "title", "" );
12553                         } else {
12554                                 target.removeAttr( "title" );
12555                         }
12556                 }
12557
12558                 tooltip = this._tooltip( target );
12559                 addDescribedBy( target, tooltip.attr( "id" ) );
12560                 tooltip.find( ".ui-tooltip-content" ).html( content );
12561
12562                 function position( event ) {
12563                         positionOption.of = event;
12564                         if ( tooltip.is( ":hidden" ) ) {
12565                                 return;
12566                         }
12567                         tooltip.position( positionOption );
12568                 }
12569                 if ( this.options.track && event && /^mouse/.test( event.type ) ) {
12570                         this._on( this.document, {
12571                                 mousemove: position
12572                         });
12573                         // trigger once to override element-relative positioning
12574                         position( event );
12575                 } else {
12576                         tooltip.position( $.extend({
12577                                 of: target
12578                         }, this.options.position ) );
12579                 }
12580
12581                 tooltip.hide();
12582
12583                 this._show( tooltip, this.options.show );
12584                 // Handle tracking tooltips that are shown with a delay (#8644). As soon
12585                 // as the tooltip is visible, position the tooltip using the most recent
12586                 // event.
12587                 if ( this.options.show && this.options.show.delay ) {
12588                         delayedShow = this.delayedShow = setInterval(function() {
12589                                 if ( tooltip.is( ":visible" ) ) {
12590                                         position( positionOption.of );
12591                                         clearInterval( delayedShow );
12592                                 }
12593                         }, $.fx.interval );
12594                 }
12595
12596                 this._trigger( "open", event, { tooltip: tooltip } );
12597
12598                 events = {
12599                         keyup: function( event ) {
12600                                 if ( event.keyCode === $.ui.keyCode.ESCAPE ) {
12601                                         var fakeEvent = $.Event(event);
12602                                         fakeEvent.currentTarget = target[0];
12603                                         this.close( fakeEvent, true );
12604                                 }
12605                         },
12606                         remove: function() {
12607                                 this._removeTooltip( tooltip );
12608                         }
12609                 };
12610                 if ( !event || event.type === "mouseover" ) {
12611                         events.mouseleave = "close";
12612                 }
12613                 if ( !event || event.type === "focusin" ) {
12614                         events.focusout = "close";
12615                 }
12616                 this._on( true, target, events );
12617         },
12618
12619         close: function( event ) {
12620                 var that = this,
12621                         target = $( event ? event.currentTarget : this.element ),
12622                         tooltip = this._find( target );
12623
12624                 // disabling closes the tooltip, so we need to track when we're closing
12625                 // to avoid an infinite loop in case the tooltip becomes disabled on close
12626                 if ( this.closing ) {
12627                         return;
12628                 }
12629
12630                 // Clear the interval for delayed tracking tooltips
12631                 clearInterval( this.delayedShow );
12632
12633                 // only set title if we had one before (see comment in _open())
12634                 if ( target.data( "ui-tooltip-title" ) ) {
12635                         target.attr( "title", target.data( "ui-tooltip-title" ) );
12636                 }
12637
12638                 removeDescribedBy( target );
12639
12640                 tooltip.stop( true );
12641                 this._hide( tooltip, this.options.hide, function() {
12642                         that._removeTooltip( $( this ) );
12643                 });
12644
12645                 target.removeData( "ui-tooltip-open" );
12646                 this._off( target, "mouseleave focusout keyup" );
12647                 // Remove 'remove' binding only on delegated targets
12648                 if ( target[0] !== this.element[0] ) {
12649                         this._off( target, "remove" );
12650                 }
12651                 this._off( this.document, "mousemove" );
12652
12653                 if ( event && event.type === "mouseleave" ) {
12654                         $.each( this.parents, function( id, parent ) {
12655                                 $( parent.element ).attr( "title", parent.title );
12656                                 delete that.parents[ id ];
12657                         });
12658                 }
12659
12660                 this.closing = true;
12661                 this._trigger( "close", event, { tooltip: tooltip } );
12662                 this.closing = false;
12663         },
12664
12665         _tooltip: function( element ) {
12666                 var id = "ui-tooltip-" + increments++,
12667                         tooltip = $( "<div>" )
12668                                 .attr({
12669                                         id: id,
12670                                         role: "tooltip"
12671                                 })
12672                                 .addClass( "ui-tooltip ui-widget ui-corner-all ui-widget-content " +
12673                                         ( this.options.tooltipClass || "" ) );
12674                 $( "<div>" )
12675                         .addClass( "ui-tooltip-content" )
12676                         .appendTo( tooltip );
12677                 tooltip.appendTo( this.document[0].body );
12678                 this.tooltips[ id ] = element;
12679                 return tooltip;
12680         },
12681
12682         _find: function( target ) {
12683                 var id = target.data( "ui-tooltip-id" );
12684                 return id ? $( "#" + id ) : $();
12685         },
12686
12687         _removeTooltip: function( tooltip ) {
12688                 tooltip.remove();
12689                 delete this.tooltips[ tooltip.attr( "id" ) ];
12690         },
12691
12692         _destroy: function() {
12693                 var that = this;
12694
12695                 // close open tooltips
12696                 $.each( this.tooltips, function( id, element ) {
12697                         // Delegate to close method to handle common cleanup
12698                         var event = $.Event( "blur" );
12699                         event.target = event.currentTarget = element[0];
12700                         that.close( event, true );
12701
12702                         // Remove immediately; destroying an open tooltip doesn't use the
12703                         // hide animation
12704                         $( "#" + id ).remove();
12705
12706                         // Restore the title
12707                         if ( element.data( "ui-tooltip-title" ) ) {
12708                                 element.attr( "title", element.data( "ui-tooltip-title" ) );
12709                                 element.removeData( "ui-tooltip-title" );
12710                         }
12711                 });
12712         }
12713 });
12714
12715 }( jQuery ) );
12716 (function($, undefined) {
12717
12718 var dataSpace = "ui-effects-";
12719
12720 $.effects = {
12721         effect: {}
12722 };
12723
12724 /*!
12725  * jQuery Color Animations v2.1.2
12726  * https://github.com/jquery/jquery-color
12727  *
12728  * Copyright 2013 jQuery Foundation and other contributors
12729  * Released under the MIT license.
12730  * http://jquery.org/license
12731  *
12732  * Date: Wed Jan 16 08:47:09 2013 -0600
12733  */
12734 (function( jQuery, undefined ) {
12735
12736         var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
12737
12738         // plusequals test for += 100 -= 100
12739         rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
12740         // a set of RE's that can match strings and generate color tuples.
12741         stringParsers = [{
12742                         re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
12743                         parse: function( execResult ) {
12744                                 return [
12745                                         execResult[ 1 ],
12746                                         execResult[ 2 ],
12747                                         execResult[ 3 ],
12748                                         execResult[ 4 ]
12749                                 ];
12750                         }
12751                 }, {
12752                         re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
12753                         parse: function( execResult ) {
12754                                 return [
12755                                         execResult[ 1 ] * 2.55,
12756                                         execResult[ 2 ] * 2.55,
12757                                         execResult[ 3 ] * 2.55,
12758                                         execResult[ 4 ]
12759                                 ];
12760                         }
12761                 }, {
12762                         // this regex ignores A-F because it's compared against an already lowercased string
12763                         re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
12764                         parse: function( execResult ) {
12765                                 return [
12766                                         parseInt( execResult[ 1 ], 16 ),
12767                                         parseInt( execResult[ 2 ], 16 ),
12768                                         parseInt( execResult[ 3 ], 16 )
12769                                 ];
12770                         }
12771                 }, {
12772                         // this regex ignores A-F because it's compared against an already lowercased string
12773                         re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
12774                         parse: function( execResult ) {
12775                                 return [
12776                                         parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
12777                                         parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
12778                                         parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
12779                                 ];
12780                         }
12781                 }, {
12782                         re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
12783                         space: "hsla",
12784                         parse: function( execResult ) {
12785                                 return [
12786                                         execResult[ 1 ],
12787                                         execResult[ 2 ] / 100,
12788                                         execResult[ 3 ] / 100,
12789                                         execResult[ 4 ]
12790                                 ];
12791                         }
12792                 }],
12793
12794         // jQuery.Color( )
12795         color = jQuery.Color = function( color, green, blue, alpha ) {
12796                 return new jQuery.Color.fn.parse( color, green, blue, alpha );
12797         },
12798         spaces = {
12799                 rgba: {
12800                         props: {
12801                                 red: {
12802                                         idx: 0,
12803                                         type: "byte"
12804                                 },
12805                                 green: {
12806                                         idx: 1,
12807                                         type: "byte"
12808                                 },
12809                                 blue: {
12810                                         idx: 2,
12811                                         type: "byte"
12812                                 }
12813                         }
12814                 },
12815
12816                 hsla: {
12817                         props: {
12818                                 hue: {
12819                                         idx: 0,
12820                                         type: "degrees"
12821                                 },
12822                                 saturation: {
12823                                         idx: 1,
12824                                         type: "percent"
12825                                 },
12826                                 lightness: {
12827                                         idx: 2,
12828                                         type: "percent"
12829                                 }
12830                         }
12831                 }
12832         },
12833         propTypes = {
12834                 "byte": {
12835                         floor: true,
12836                         max: 255
12837                 },
12838                 "percent": {
12839                         max: 1
12840                 },
12841                 "degrees": {
12842                         mod: 360,
12843                         floor: true
12844                 }
12845         },
12846         support = color.support = {},
12847
12848         // element for support tests
12849         supportElem = jQuery( "<p>" )[ 0 ],
12850
12851         // colors = jQuery.Color.names
12852         colors,
12853
12854         // local aliases of functions called often
12855         each = jQuery.each;
12856
12857 // determine rgba support immediately
12858 supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
12859 support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
12860
12861 // define cache name and alpha properties
12862 // for rgba and hsla spaces
12863 each( spaces, function( spaceName, space ) {
12864         space.cache = "_" + spaceName;
12865         space.props.alpha = {
12866                 idx: 3,
12867                 type: "percent",
12868                 def: 1
12869         };
12870 });
12871
12872 function clamp( value, prop, allowEmpty ) {
12873         var type = propTypes[ prop.type ] || {};
12874
12875         if ( value == null ) {
12876                 return (allowEmpty || !prop.def) ? null : prop.def;
12877         }
12878
12879         // ~~ is an short way of doing floor for positive numbers
12880         value = type.floor ? ~~value : parseFloat( value );
12881
12882         // IE will pass in empty strings as value for alpha,
12883         // which will hit this case
12884         if ( isNaN( value ) ) {
12885                 return prop.def;
12886         }
12887
12888         if ( type.mod ) {
12889                 // we add mod before modding to make sure that negatives values
12890                 // get converted properly: -10 -> 350
12891                 return (value + type.mod) % type.mod;
12892         }
12893
12894         // for now all property types without mod have min and max
12895         return 0 > value ? 0 : type.max < value ? type.max : value;
12896 }
12897
12898 function stringParse( string ) {
12899         var inst = color(),
12900                 rgba = inst._rgba = [];
12901
12902         string = string.toLowerCase();
12903
12904         each( stringParsers, function( i, parser ) {
12905                 var parsed,
12906                         match = parser.re.exec( string ),
12907                         values = match && parser.parse( match ),
12908                         spaceName = parser.space || "rgba";
12909
12910                 if ( values ) {
12911                         parsed = inst[ spaceName ]( values );
12912
12913                         // if this was an rgba parse the assignment might happen twice
12914                         // oh well....
12915                         inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
12916                         rgba = inst._rgba = parsed._rgba;
12917
12918                         // exit each( stringParsers ) here because we matched
12919                         return false;
12920                 }
12921         });
12922
12923         // Found a stringParser that handled it
12924         if ( rgba.length ) {
12925
12926                 // if this came from a parsed string, force "transparent" when alpha is 0
12927                 // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
12928                 if ( rgba.join() === "0,0,0,0" ) {
12929                         jQuery.extend( rgba, colors.transparent );
12930                 }
12931                 return inst;
12932         }
12933
12934         // named colors
12935         return colors[ string ];
12936 }
12937
12938 color.fn = jQuery.extend( color.prototype, {
12939         parse: function( red, green, blue, alpha ) {
12940                 if ( red === undefined ) {
12941                         this._rgba = [ null, null, null, null ];
12942                         return this;
12943                 }
12944                 if ( red.jquery || red.nodeType ) {
12945                         red = jQuery( red ).css( green );
12946                         green = undefined;
12947                 }
12948
12949                 var inst = this,
12950                         type = jQuery.type( red ),
12951                         rgba = this._rgba = [];
12952
12953                 // more than 1 argument specified - assume ( red, green, blue, alpha )
12954                 if ( green !== undefined ) {
12955                         red = [ red, green, blue, alpha ];
12956                         type = "array";
12957                 }
12958
12959                 if ( type === "string" ) {
12960                         return this.parse( stringParse( red ) || colors._default );
12961                 }
12962
12963                 if ( type === "array" ) {
12964                         each( spaces.rgba.props, function( key, prop ) {
12965                                 rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
12966                         });
12967                         return this;
12968                 }
12969
12970                 if ( type === "object" ) {
12971                         if ( red instanceof color ) {
12972                                 each( spaces, function( spaceName, space ) {
12973                                         if ( red[ space.cache ] ) {
12974                                                 inst[ space.cache ] = red[ space.cache ].slice();
12975                                         }
12976                                 });
12977                         } else {
12978                                 each( spaces, function( spaceName, space ) {
12979                                         var cache = space.cache;
12980                                         each( space.props, function( key, prop ) {
12981
12982                                                 // if the cache doesn't exist, and we know how to convert
12983                                                 if ( !inst[ cache ] && space.to ) {
12984
12985                                                         // if the value was null, we don't need to copy it
12986                                                         // if the key was alpha, we don't need to copy it either
12987                                                         if ( key === "alpha" || red[ key ] == null ) {
12988                                                                 return;
12989                                                         }
12990                                                         inst[ cache ] = space.to( inst._rgba );
12991                                                 }
12992
12993                                                 // this is the only case where we allow nulls for ALL properties.
12994                                                 // call clamp with alwaysAllowEmpty
12995                                                 inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
12996                                         });
12997
12998                                         // everything defined but alpha?
12999                                         if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
13000                                                 // use the default of 1
13001                                                 inst[ cache ][ 3 ] = 1;
13002                                                 if ( space.from ) {
13003                                                         inst._rgba = space.from( inst[ cache ] );
13004                                                 }
13005                                         }
13006                                 });
13007                         }
13008                         return this;
13009                 }
13010         },
13011         is: function( compare ) {
13012                 var is = color( compare ),
13013                         same = true,
13014                         inst = this;
13015
13016                 each( spaces, function( _, space ) {
13017                         var localCache,
13018                                 isCache = is[ space.cache ];
13019                         if (isCache) {
13020                                 localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
13021                                 each( space.props, function( _, prop ) {
13022                                         if ( isCache[ prop.idx ] != null ) {
13023                                                 same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
13024                                                 return same;
13025                                         }
13026                                 });
13027                         }
13028                         return same;
13029                 });
13030                 return same;
13031         },
13032         _space: function() {
13033                 var used = [],
13034                         inst = this;
13035                 each( spaces, function( spaceName, space ) {
13036                         if ( inst[ space.cache ] ) {
13037                                 used.push( spaceName );
13038                         }
13039                 });
13040                 return used.pop();
13041         },
13042         transition: function( other, distance ) {
13043                 var end = color( other ),
13044                         spaceName = end._space(),
13045                         space = spaces[ spaceName ],
13046                         startColor = this.alpha() === 0 ? color( "transparent" ) : this,
13047                         start = startColor[ space.cache ] || space.to( startColor._rgba ),
13048                         result = start.slice();
13049
13050                 end = end[ space.cache ];
13051                 each( space.props, function( key, prop ) {
13052                         var index = prop.idx,
13053                                 startValue = start[ index ],
13054                                 endValue = end[ index ],
13055                                 type = propTypes[ prop.type ] || {};
13056
13057                         // if null, don't override start value
13058                         if ( endValue === null ) {
13059                                 return;
13060                         }
13061                         // if null - use end
13062                         if ( startValue === null ) {
13063                                 result[ index ] = endValue;
13064                         } else {
13065                                 if ( type.mod ) {
13066                                         if ( endValue - startValue > type.mod / 2 ) {
13067                                                 startValue += type.mod;
13068                                         } else if ( startValue - endValue > type.mod / 2 ) {
13069                                                 startValue -= type.mod;
13070                                         }
13071                                 }
13072                                 result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
13073                         }
13074                 });
13075                 return this[ spaceName ]( result );
13076         },
13077         blend: function( opaque ) {
13078                 // if we are already opaque - return ourself
13079                 if ( this._rgba[ 3 ] === 1 ) {
13080                         return this;
13081                 }
13082
13083                 var rgb = this._rgba.slice(),
13084                         a = rgb.pop(),
13085                         blend = color( opaque )._rgba;
13086
13087                 return color( jQuery.map( rgb, function( v, i ) {
13088                         return ( 1 - a ) * blend[ i ] + a * v;
13089                 }));
13090         },
13091         toRgbaString: function() {
13092                 var prefix = "rgba(",
13093                         rgba = jQuery.map( this._rgba, function( v, i ) {
13094                                 return v == null ? ( i > 2 ? 1 : 0 ) : v;
13095                         });
13096
13097                 if ( rgba[ 3 ] === 1 ) {
13098                         rgba.pop();
13099                         prefix = "rgb(";
13100                 }
13101
13102                 return prefix + rgba.join() + ")";
13103         },
13104         toHslaString: function() {
13105                 var prefix = "hsla(",
13106                         hsla = jQuery.map( this.hsla(), function( v, i ) {
13107                                 if ( v == null ) {
13108                                         v = i > 2 ? 1 : 0;
13109                                 }
13110
13111                                 // catch 1 and 2
13112                                 if ( i && i < 3 ) {
13113                                         v = Math.round( v * 100 ) + "%";
13114                                 }
13115                                 return v;
13116                         });
13117
13118                 if ( hsla[ 3 ] === 1 ) {
13119                         hsla.pop();
13120                         prefix = "hsl(";
13121                 }
13122                 return prefix + hsla.join() + ")";
13123         },
13124         toHexString: function( includeAlpha ) {
13125                 var rgba = this._rgba.slice(),
13126                         alpha = rgba.pop();
13127
13128                 if ( includeAlpha ) {
13129                         rgba.push( ~~( alpha * 255 ) );
13130                 }
13131
13132                 return "#" + jQuery.map( rgba, function( v ) {
13133
13134                         // default to 0 when nulls exist
13135                         v = ( v || 0 ).toString( 16 );
13136                         return v.length === 1 ? "0" + v : v;
13137                 }).join("");
13138         },
13139         toString: function() {
13140                 return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
13141         }
13142 });
13143 color.fn.parse.prototype = color.fn;
13144
13145 // hsla conversions adapted from:
13146 // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
13147
13148 function hue2rgb( p, q, h ) {
13149         h = ( h + 1 ) % 1;
13150         if ( h * 6 < 1 ) {
13151                 return p + (q - p) * h * 6;
13152         }
13153         if ( h * 2 < 1) {
13154                 return q;
13155         }
13156         if ( h * 3 < 2 ) {
13157                 return p + (q - p) * ((2/3) - h) * 6;
13158         }
13159         return p;
13160 }
13161
13162 spaces.hsla.to = function ( rgba ) {
13163         if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
13164                 return [ null, null, null, rgba[ 3 ] ];
13165         }
13166         var r = rgba[ 0 ] / 255,
13167                 g = rgba[ 1 ] / 255,
13168                 b = rgba[ 2 ] / 255,
13169                 a = rgba[ 3 ],
13170                 max = Math.max( r, g, b ),
13171                 min = Math.min( r, g, b ),
13172                 diff = max - min,
13173                 add = max + min,
13174                 l = add * 0.5,
13175                 h, s;
13176
13177         if ( min === max ) {
13178                 h = 0;
13179         } else if ( r === max ) {
13180                 h = ( 60 * ( g - b ) / diff ) + 360;
13181         } else if ( g === max ) {
13182                 h = ( 60 * ( b - r ) / diff ) + 120;
13183         } else {
13184                 h = ( 60 * ( r - g ) / diff ) + 240;
13185         }
13186
13187         // chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
13188         // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
13189         if ( diff === 0 ) {
13190                 s = 0;
13191         } else if ( l <= 0.5 ) {
13192                 s = diff / add;
13193         } else {
13194                 s = diff / ( 2 - add );
13195         }
13196         return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
13197 };
13198
13199 spaces.hsla.from = function ( hsla ) {
13200         if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
13201                 return [ null, null, null, hsla[ 3 ] ];
13202         }
13203         var h = hsla[ 0 ] / 360,
13204                 s = hsla[ 1 ],
13205                 l = hsla[ 2 ],
13206                 a = hsla[ 3 ],
13207                 q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
13208                 p = 2 * l - q;
13209
13210         return [
13211                 Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
13212                 Math.round( hue2rgb( p, q, h ) * 255 ),
13213                 Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
13214                 a
13215         ];
13216 };
13217
13218
13219 each( spaces, function( spaceName, space ) {
13220         var props = space.props,
13221                 cache = space.cache,
13222                 to = space.to,
13223                 from = space.from;
13224
13225         // makes rgba() and hsla()
13226         color.fn[ spaceName ] = function( value ) {
13227
13228                 // generate a cache for this space if it doesn't exist
13229                 if ( to && !this[ cache ] ) {
13230                         this[ cache ] = to( this._rgba );
13231                 }
13232                 if ( value === undefined ) {
13233                         return this[ cache ].slice();
13234                 }
13235
13236                 var ret,
13237                         type = jQuery.type( value ),
13238                         arr = ( type === "array" || type === "object" ) ? value : arguments,
13239                         local = this[ cache ].slice();
13240
13241                 each( props, function( key, prop ) {
13242                         var val = arr[ type === "object" ? key : prop.idx ];
13243                         if ( val == null ) {
13244                                 val = local[ prop.idx ];
13245                         }
13246                         local[ prop.idx ] = clamp( val, prop );
13247                 });
13248
13249                 if ( from ) {
13250                         ret = color( from( local ) );
13251                         ret[ cache ] = local;
13252                         return ret;
13253                 } else {
13254                         return color( local );
13255                 }
13256         };
13257
13258         // makes red() green() blue() alpha() hue() saturation() lightness()
13259         each( props, function( key, prop ) {
13260                 // alpha is included in more than one space
13261                 if ( color.fn[ key ] ) {
13262                         return;
13263                 }
13264                 color.fn[ key ] = function( value ) {
13265                         var vtype = jQuery.type( value ),
13266                                 fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
13267                                 local = this[ fn ](),
13268                                 cur = local[ prop.idx ],
13269                                 match;
13270
13271                         if ( vtype === "undefined" ) {
13272                                 return cur;
13273                         }
13274
13275                         if ( vtype === "function" ) {
13276                                 value = value.call( this, cur );
13277                                 vtype = jQuery.type( value );
13278                         }
13279                         if ( value == null && prop.empty ) {
13280                                 return this;
13281                         }
13282                         if ( vtype === "string" ) {
13283                                 match = rplusequals.exec( value );
13284                                 if ( match ) {
13285                                         value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
13286                                 }
13287                         }
13288                         local[ prop.idx ] = value;
13289                         return this[ fn ]( local );
13290                 };
13291         });
13292 });
13293
13294 // add cssHook and .fx.step function for each named hook.
13295 // accept a space separated string of properties
13296 color.hook = function( hook ) {
13297         var hooks = hook.split( " " );
13298         each( hooks, function( i, hook ) {
13299                 jQuery.cssHooks[ hook ] = {
13300                         set: function( elem, value ) {
13301                                 var parsed, curElem,
13302                                         backgroundColor = "";
13303
13304                                 if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
13305                                         value = color( parsed || value );
13306                                         if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
13307                                                 curElem = hook === "backgroundColor" ? elem.parentNode : elem;
13308                                                 while (
13309                                                         (backgroundColor === "" || backgroundColor === "transparent") &&
13310                                                         curElem && curElem.style
13311                                                 ) {
13312                                                         try {
13313                                                                 backgroundColor = jQuery.css( curElem, "backgroundColor" );
13314                                                                 curElem = curElem.parentNode;
13315                                                         } catch ( e ) {
13316                                                         }
13317                                                 }
13318
13319                                                 value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
13320                                                         backgroundColor :
13321                                                         "_default" );
13322                                         }
13323
13324                                         value = value.toRgbaString();
13325                                 }
13326                                 try {
13327                                         elem.style[ hook ] = value;
13328                                 } catch( e ) {
13329                                         // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
13330                                 }
13331                         }
13332                 };
13333                 jQuery.fx.step[ hook ] = function( fx ) {
13334                         if ( !fx.colorInit ) {
13335                                 fx.start = color( fx.elem, hook );
13336                                 fx.end = color( fx.end );
13337                                 fx.colorInit = true;
13338                         }
13339                         jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
13340                 };
13341         });
13342
13343 };
13344
13345 color.hook( stepHooks );
13346
13347 jQuery.cssHooks.borderColor = {
13348         expand: function( value ) {
13349                 var expanded = {};
13350
13351                 each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
13352                         expanded[ "border" + part + "Color" ] = value;
13353                 });
13354                 return expanded;
13355         }
13356 };
13357
13358 // Basic color names only.
13359 // Usage of any of the other color names requires adding yourself or including
13360 // jquery.color.svg-names.js.
13361 colors = jQuery.Color.names = {
13362         // 4.1. Basic color keywords
13363         aqua: "#00ffff",
13364         black: "#000000",
13365         blue: "#0000ff",
13366         fuchsia: "#ff00ff",
13367         gray: "#808080",
13368         green: "#008000",
13369         lime: "#00ff00",
13370         maroon: "#800000",
13371         navy: "#000080",
13372         olive: "#808000",
13373         purple: "#800080",
13374         red: "#ff0000",
13375         silver: "#c0c0c0",
13376         teal: "#008080",
13377         white: "#ffffff",
13378         yellow: "#ffff00",
13379
13380         // 4.2.3. "transparent" color keyword
13381         transparent: [ null, null, null, 0 ],
13382
13383         _default: "#ffffff"
13384 };
13385
13386 })( jQuery );
13387
13388
13389 /******************************************************************************/
13390 /****************************** CLASS ANIMATIONS ******************************/
13391 /******************************************************************************/
13392 (function() {
13393
13394 var classAnimationActions = [ "add", "remove", "toggle" ],
13395         shorthandStyles = {
13396                 border: 1,
13397                 borderBottom: 1,
13398                 borderColor: 1,
13399                 borderLeft: 1,
13400                 borderRight: 1,
13401                 borderTop: 1,
13402                 borderWidth: 1,
13403                 margin: 1,
13404                 padding: 1
13405         };
13406
13407 $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
13408         $.fx.step[ prop ] = function( fx ) {
13409                 if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
13410                         jQuery.style( fx.elem, prop, fx.end );
13411                         fx.setAttr = true;
13412                 }
13413         };
13414 });
13415
13416 function getElementStyles( elem ) {
13417         var key, len,
13418                 style = elem.ownerDocument.defaultView ?
13419                         elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
13420                         elem.currentStyle,
13421                 styles = {};
13422
13423         if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
13424                 len = style.length;
13425                 while ( len-- ) {
13426                         key = style[ len ];
13427                         if ( typeof style[ key ] === "string" ) {
13428                                 styles[ $.camelCase( key ) ] = style[ key ];
13429                         }
13430                 }
13431         // support: Opera, IE <9
13432         } else {
13433                 for ( key in style ) {
13434                         if ( typeof style[ key ] === "string" ) {
13435                                 styles[ key ] = style[ key ];
13436                         }
13437                 }
13438         }
13439
13440         return styles;
13441 }
13442
13443
13444 function styleDifference( oldStyle, newStyle ) {
13445         var diff = {},
13446                 name, value;
13447
13448         for ( name in newStyle ) {
13449                 value = newStyle[ name ];
13450                 if ( oldStyle[ name ] !== value ) {
13451                         if ( !shorthandStyles[ name ] ) {
13452                                 if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
13453                                         diff[ name ] = value;
13454                                 }
13455                         }
13456                 }
13457         }
13458
13459         return diff;
13460 }
13461
13462 // support: jQuery <1.8
13463 if ( !$.fn.addBack ) {
13464         $.fn.addBack = function( selector ) {
13465                 return this.add( selector == null ?
13466                         this.prevObject : this.prevObject.filter( selector )
13467                 );
13468         };
13469 }
13470
13471 $.effects.animateClass = function( value, duration, easing, callback ) {
13472         var o = $.speed( duration, easing, callback );
13473
13474         return this.queue( function() {
13475                 var animated = $( this ),
13476                         baseClass = animated.attr( "class" ) || "",
13477                         applyClassChange,
13478                         allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
13479
13480                 // map the animated objects to store the original styles.
13481                 allAnimations = allAnimations.map(function() {
13482                         var el = $( this );
13483                         return {
13484                                 el: el,
13485                                 start: getElementStyles( this )
13486                         };
13487                 });
13488
13489                 // apply class change
13490                 applyClassChange = function() {
13491                         $.each( classAnimationActions, function(i, action) {
13492                                 if ( value[ action ] ) {
13493                                         animated[ action + "Class" ]( value[ action ] );
13494                                 }
13495                         });
13496                 };
13497                 applyClassChange();
13498
13499                 // map all animated objects again - calculate new styles and diff
13500                 allAnimations = allAnimations.map(function() {
13501                         this.end = getElementStyles( this.el[ 0 ] );
13502                         this.diff = styleDifference( this.start, this.end );
13503                         return this;
13504                 });
13505
13506                 // apply original class
13507                 animated.attr( "class", baseClass );
13508
13509                 // map all animated objects again - this time collecting a promise
13510                 allAnimations = allAnimations.map(function() {
13511                         var styleInfo = this,
13512                                 dfd = $.Deferred(),
13513                                 opts = $.extend({}, o, {
13514                                         queue: false,
13515                                         complete: function() {
13516                                                 dfd.resolve( styleInfo );
13517                                         }
13518                                 });
13519
13520                         this.el.animate( this.diff, opts );
13521                         return dfd.promise();
13522                 });
13523
13524                 // once all animations have completed:
13525                 $.when.apply( $, allAnimations.get() ).done(function() {
13526
13527                         // set the final class
13528                         applyClassChange();
13529
13530                         // for each animated element,
13531                         // clear all css properties that were animated
13532                         $.each( arguments, function() {
13533                                 var el = this.el;
13534                                 $.each( this.diff, function(key) {
13535                                         el.css( key, "" );
13536                                 });
13537                         });
13538
13539                         // this is guarnteed to be there if you use jQuery.speed()
13540                         // it also handles dequeuing the next anim...
13541                         o.complete.call( animated[ 0 ] );
13542                 });
13543         });
13544 };
13545
13546 $.fn.extend({
13547         addClass: (function( orig ) {
13548                 return function( classNames, speed, easing, callback ) {
13549                         return speed ?
13550                                 $.effects.animateClass.call( this,
13551                                         { add: classNames }, speed, easing, callback ) :
13552                                 orig.apply( this, arguments );
13553                 };
13554         })( $.fn.addClass ),
13555
13556         removeClass: (function( orig ) {
13557                 return function( classNames, speed, easing, callback ) {
13558                         return arguments.length > 1 ?
13559                                 $.effects.animateClass.call( this,
13560                                         { remove: classNames }, speed, easing, callback ) :
13561                                 orig.apply( this, arguments );
13562                 };
13563         })( $.fn.removeClass ),
13564
13565         toggleClass: (function( orig ) {
13566                 return function( classNames, force, speed, easing, callback ) {
13567                         if ( typeof force === "boolean" || force === undefined ) {
13568                                 if ( !speed ) {
13569                                         // without speed parameter
13570                                         return orig.apply( this, arguments );
13571                                 } else {
13572                                         return $.effects.animateClass.call( this,
13573                                                 (force ? { add: classNames } : { remove: classNames }),
13574                                                 speed, easing, callback );
13575                                 }
13576                         } else {
13577                                 // without force parameter
13578                                 return $.effects.animateClass.call( this,
13579                                         { toggle: classNames }, force, speed, easing );
13580                         }
13581                 };
13582         })( $.fn.toggleClass ),
13583
13584         switchClass: function( remove, add, speed, easing, callback) {
13585                 return $.effects.animateClass.call( this, {
13586                         add: add,
13587                         remove: remove
13588                 }, speed, easing, callback );
13589         }
13590 });
13591
13592 })();
13593
13594 /******************************************************************************/
13595 /*********************************** EFFECTS **********************************/
13596 /******************************************************************************/
13597
13598 (function() {
13599
13600 $.extend( $.effects, {
13601         version: "1.10.3",
13602
13603         // Saves a set of properties in a data storage
13604         save: function( element, set ) {
13605                 for( var i=0; i < set.length; i++ ) {
13606                         if ( set[ i ] !== null ) {
13607                                 element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
13608                         }
13609                 }
13610         },
13611
13612         // Restores a set of previously saved properties from a data storage
13613         restore: function( element, set ) {
13614                 var val, i;
13615                 for( i=0; i < set.length; i++ ) {
13616                         if ( set[ i ] !== null ) {
13617                                 val = element.data( dataSpace + set[ i ] );
13618                                 // support: jQuery 1.6.2
13619                                 // http://bugs.jquery.com/ticket/9917
13620                                 // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
13621                                 // We can't differentiate between "" and 0 here, so we just assume
13622                                 // empty string since it's likely to be a more common value...
13623                                 if ( val === undefined ) {
13624                                         val = "";
13625                                 }
13626                                 element.css( set[ i ], val );
13627                         }
13628                 }
13629         },
13630
13631         setMode: function( el, mode ) {
13632                 if (mode === "toggle") {
13633                         mode = el.is( ":hidden" ) ? "show" : "hide";
13634                 }
13635                 return mode;
13636         },
13637
13638         // Translates a [top,left] array into a baseline value
13639         // this should be a little more flexible in the future to handle a string & hash
13640         getBaseline: function( origin, original ) {
13641                 var y, x;
13642                 switch ( origin[ 0 ] ) {
13643                         case "top": y = 0; break;
13644                         case "middle": y = 0.5; break;
13645                         case "bottom": y = 1; break;
13646                         default: y = origin[ 0 ] / original.height;
13647                 }
13648                 switch ( origin[ 1 ] ) {
13649                         case "left": x = 0; break;
13650                         case "center": x = 0.5; break;
13651                         case "right": x = 1; break;
13652                         default: x = origin[ 1 ] / original.width;
13653                 }
13654                 return {
13655                         x: x,
13656                         y: y
13657                 };
13658         },
13659
13660         // Wraps the element around a wrapper that copies position properties
13661         createWrapper: function( element ) {
13662
13663                 // if the element is already wrapped, return it
13664                 if ( element.parent().is( ".ui-effects-wrapper" )) {
13665                         return element.parent();
13666                 }
13667
13668                 // wrap the element
13669                 var props = {
13670                                 width: element.outerWidth(true),
13671                                 height: element.outerHeight(true),
13672                                 "float": element.css( "float" )
13673                         },
13674                         wrapper = $( "<div></div>" )
13675                                 .addClass( "ui-effects-wrapper" )
13676                                 .css({
13677                                         fontSize: "100%",
13678                                         background: "transparent",
13679                                         border: "none",
13680                                         margin: 0,
13681                                         padding: 0
13682                                 }),
13683                         // Store the size in case width/height are defined in % - Fixes #5245
13684                         size = {
13685                                 width: element.width(),
13686                                 height: element.height()
13687                         },
13688                         active = document.activeElement;
13689
13690                 // support: Firefox
13691                 // Firefox incorrectly exposes anonymous content
13692                 // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
13693                 try {
13694                         active.id;
13695                 } catch( e ) {
13696                         active = document.body;
13697                 }
13698
13699                 element.wrap( wrapper );
13700
13701                 // Fixes #7595 - Elements lose focus when wrapped.
13702                 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
13703                         $( active ).focus();
13704                 }
13705
13706                 wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
13707
13708                 // transfer positioning properties to the wrapper
13709                 if ( element.css( "position" ) === "static" ) {
13710                         wrapper.css({ position: "relative" });
13711                         element.css({ position: "relative" });
13712                 } else {
13713                         $.extend( props, {
13714                                 position: element.css( "position" ),
13715                                 zIndex: element.css( "z-index" )
13716                         });
13717                         $.each([ "top", "left", "bottom", "right" ], function(i, pos) {
13718                                 props[ pos ] = element.css( pos );
13719                                 if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
13720                                         props[ pos ] = "auto";
13721                                 }
13722                         });
13723                         element.css({
13724                                 position: "relative",
13725                                 top: 0,
13726                                 left: 0,
13727                                 right: "auto",
13728                                 bottom: "auto"
13729                         });
13730                 }
13731                 element.css(size);
13732
13733                 return wrapper.css( props ).show();
13734         },
13735
13736         removeWrapper: function( element ) {
13737                 var active = document.activeElement;
13738
13739                 if ( element.parent().is( ".ui-effects-wrapper" ) ) {
13740                         element.parent().replaceWith( element );
13741
13742                         // Fixes #7595 - Elements lose focus when wrapped.
13743                         if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
13744                                 $( active ).focus();
13745                         }
13746                 }
13747
13748
13749                 return element;
13750         },
13751
13752         setTransition: function( element, list, factor, value ) {
13753                 value = value || {};
13754                 $.each( list, function( i, x ) {
13755                         var unit = element.cssUnit( x );
13756                         if ( unit[ 0 ] > 0 ) {
13757                                 value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
13758                         }
13759                 });
13760                 return value;
13761         }
13762 });
13763
13764 // return an effect options object for the given parameters:
13765 function _normalizeArguments( effect, options, speed, callback ) {
13766
13767         // allow passing all options as the first parameter
13768         if ( $.isPlainObject( effect ) ) {
13769                 options = effect;
13770                 effect = effect.effect;
13771         }
13772
13773         // convert to an object
13774         effect = { effect: effect };
13775
13776         // catch (effect, null, ...)
13777         if ( options == null ) {
13778                 options = {};
13779         }
13780
13781         // catch (effect, callback)
13782         if ( $.isFunction( options ) ) {
13783                 callback = options;
13784                 speed = null;
13785                 options = {};
13786         }
13787
13788         // catch (effect, speed, ?)
13789         if ( typeof options === "number" || $.fx.speeds[ options ] ) {
13790                 callback = speed;
13791                 speed = options;
13792                 options = {};
13793         }
13794
13795         // catch (effect, options, callback)
13796         if ( $.isFunction( speed ) ) {
13797                 callback = speed;
13798                 speed = null;
13799         }
13800
13801         // add options to effect
13802         if ( options ) {
13803                 $.extend( effect, options );
13804         }
13805
13806         speed = speed || options.duration;
13807         effect.duration = $.fx.off ? 0 :
13808                 typeof speed === "number" ? speed :
13809                 speed in $.fx.speeds ? $.fx.speeds[ speed ] :
13810                 $.fx.speeds._default;
13811
13812         effect.complete = callback || options.complete;
13813
13814         return effect;
13815 }
13816
13817 function standardAnimationOption( option ) {
13818         // Valid standard speeds (nothing, number, named speed)
13819         if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
13820                 return true;
13821         }
13822
13823         // Invalid strings - treat as "normal" speed
13824         if ( typeof option === "string" && !$.effects.effect[ option ] ) {
13825                 return true;
13826         }
13827
13828         // Complete callback
13829         if ( $.isFunction( option ) ) {
13830                 return true;
13831         }
13832
13833         // Options hash (but not naming an effect)
13834         if ( typeof option === "object" && !option.effect ) {
13835                 return true;
13836         }
13837
13838         // Didn't match any standard API
13839         return false;
13840 }
13841
13842 $.fn.extend({
13843         effect: function( /* effect, options, speed, callback */ ) {
13844                 var args = _normalizeArguments.apply( this, arguments ),
13845                         mode = args.mode,
13846                         queue = args.queue,
13847                         effectMethod = $.effects.effect[ args.effect ];
13848
13849                 if ( $.fx.off || !effectMethod ) {
13850                         // delegate to the original method (e.g., .show()) if possible
13851                         if ( mode ) {
13852                                 return this[ mode ]( args.duration, args.complete );
13853                         } else {
13854                                 return this.each( function() {
13855                                         if ( args.complete ) {
13856                                                 args.complete.call( this );
13857                                         }
13858                                 });
13859                         }
13860                 }
13861
13862                 function run( next ) {
13863                         var elem = $( this ),
13864                                 complete = args.complete,
13865                                 mode = args.mode;
13866
13867                         function done() {
13868                                 if ( $.isFunction( complete ) ) {
13869                                         complete.call( elem[0] );
13870                                 }
13871                                 if ( $.isFunction( next ) ) {
13872                                         next();
13873                                 }
13874                         }
13875
13876                         // If the element already has the correct final state, delegate to
13877                         // the core methods so the internal tracking of "olddisplay" works.
13878                         if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
13879                                 elem[ mode ]();
13880                                 done();
13881                         } else {
13882                                 effectMethod.call( elem[0], args, done );
13883                         }
13884                 }
13885
13886                 return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
13887         },
13888
13889         show: (function( orig ) {
13890                 return function( option ) {
13891                         if ( standardAnimationOption( option ) ) {
13892                                 return orig.apply( this, arguments );
13893                         } else {
13894                                 var args = _normalizeArguments.apply( this, arguments );
13895                                 args.mode = "show";
13896                                 return this.effect.call( this, args );
13897                         }
13898                 };
13899         })( $.fn.show ),
13900
13901         hide: (function( orig ) {
13902                 return function( option ) {
13903                         if ( standardAnimationOption( option ) ) {
13904                                 return orig.apply( this, arguments );
13905                         } else {
13906                                 var args = _normalizeArguments.apply( this, arguments );
13907                                 args.mode = "hide";
13908                                 return this.effect.call( this, args );
13909                         }
13910                 };
13911         })( $.fn.hide ),
13912
13913         toggle: (function( orig ) {
13914                 return function( option ) {
13915                         if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
13916                                 return orig.apply( this, arguments );
13917                         } else {
13918                                 var args = _normalizeArguments.apply( this, arguments );
13919                                 args.mode = "toggle";
13920                                 return this.effect.call( this, args );
13921                         }
13922                 };
13923         })( $.fn.toggle ),
13924
13925         // helper functions
13926         cssUnit: function(key) {
13927                 var style = this.css( key ),
13928                         val = [];
13929
13930                 $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
13931                         if ( style.indexOf( unit ) > 0 ) {
13932                                 val = [ parseFloat( style ), unit ];
13933                         }
13934                 });
13935                 return val;
13936         }
13937 });
13938
13939 })();
13940
13941 /******************************************************************************/
13942 /*********************************** EASING ***********************************/
13943 /******************************************************************************/
13944
13945 (function() {
13946
13947 // based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
13948
13949 var baseEasings = {};
13950
13951 $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
13952         baseEasings[ name ] = function( p ) {
13953                 return Math.pow( p, i + 2 );
13954         };
13955 });
13956
13957 $.extend( baseEasings, {
13958         Sine: function ( p ) {
13959                 return 1 - Math.cos( p * Math.PI / 2 );
13960         },
13961         Circ: function ( p ) {
13962                 return 1 - Math.sqrt( 1 - p * p );
13963         },
13964         Elastic: function( p ) {
13965                 return p === 0 || p === 1 ? p :
13966                         -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
13967         },
13968         Back: function( p ) {
13969                 return p * p * ( 3 * p - 2 );
13970         },
13971         Bounce: function ( p ) {
13972                 var pow2,
13973                         bounce = 4;
13974
13975                 while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
13976                 return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
13977         }
13978 });
13979
13980 $.each( baseEasings, function( name, easeIn ) {
13981         $.easing[ "easeIn" + name ] = easeIn;
13982         $.easing[ "easeOut" + name ] = function( p ) {
13983                 return 1 - easeIn( 1 - p );
13984         };
13985         $.easing[ "easeInOut" + name ] = function( p ) {
13986                 return p < 0.5 ?
13987                         easeIn( p * 2 ) / 2 :
13988                         1 - easeIn( p * -2 + 2 ) / 2;
13989         };
13990 });
13991
13992 })();
13993
13994 })(jQuery);
13995 (function( $, undefined ) {
13996
13997 var rvertical = /up|down|vertical/,
13998         rpositivemotion = /up|left|vertical|horizontal/;
13999
14000 $.effects.effect.blind = function( o, done ) {
14001         // Create element
14002         var el = $( this ),
14003                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
14004                 mode = $.effects.setMode( el, o.mode || "hide" ),
14005                 direction = o.direction || "up",
14006                 vertical = rvertical.test( direction ),
14007                 ref = vertical ? "height" : "width",
14008                 ref2 = vertical ? "top" : "left",
14009                 motion = rpositivemotion.test( direction ),
14010                 animation = {},
14011                 show = mode === "show",
14012                 wrapper, distance, margin;
14013
14014         // if already wrapped, the wrapper's properties are my property. #6245
14015         if ( el.parent().is( ".ui-effects-wrapper" ) ) {
14016                 $.effects.save( el.parent(), props );
14017         } else {
14018                 $.effects.save( el, props );
14019         }
14020         el.show();
14021         wrapper = $.effects.createWrapper( el ).css({
14022                 overflow: "hidden"
14023         });
14024
14025         distance = wrapper[ ref ]();
14026         margin = parseFloat( wrapper.css( ref2 ) ) || 0;
14027
14028         animation[ ref ] = show ? distance : 0;
14029         if ( !motion ) {
14030                 el
14031                         .css( vertical ? "bottom" : "right", 0 )
14032                         .css( vertical ? "top" : "left", "auto" )
14033                         .css({ position: "absolute" });
14034
14035                 animation[ ref2 ] = show ? margin : distance + margin;
14036         }
14037
14038         // start at 0 if we are showing
14039         if ( show ) {
14040                 wrapper.css( ref, 0 );
14041                 if ( ! motion ) {
14042                         wrapper.css( ref2, margin + distance );
14043                 }
14044         }
14045
14046         // Animate
14047         wrapper.animate( animation, {
14048                 duration: o.duration,
14049                 easing: o.easing,
14050                 queue: false,
14051                 complete: function() {
14052                         if ( mode === "hide" ) {
14053                                 el.hide();
14054                         }
14055                         $.effects.restore( el, props );
14056                         $.effects.removeWrapper( el );
14057                         done();
14058                 }
14059         });
14060
14061 };
14062
14063 })(jQuery);
14064 (function( $, undefined ) {
14065
14066 $.effects.effect.bounce = function( o, done ) {
14067         var el = $( this ),
14068                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
14069
14070                 // defaults:
14071                 mode = $.effects.setMode( el, o.mode || "effect" ),
14072                 hide = mode === "hide",
14073                 show = mode === "show",
14074                 direction = o.direction || "up",
14075                 distance = o.distance,
14076                 times = o.times || 5,
14077
14078                 // number of internal animations
14079                 anims = times * 2 + ( show || hide ? 1 : 0 ),
14080                 speed = o.duration / anims,
14081                 easing = o.easing,
14082
14083                 // utility:
14084                 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
14085                 motion = ( direction === "up" || direction === "left" ),
14086                 i,
14087                 upAnim,
14088                 downAnim,
14089
14090                 // we will need to re-assemble the queue to stack our animations in place
14091                 queue = el.queue(),
14092                 queuelen = queue.length;
14093
14094         // Avoid touching opacity to prevent clearType and PNG issues in IE
14095         if ( show || hide ) {
14096                 props.push( "opacity" );
14097         }
14098
14099         $.effects.save( el, props );
14100         el.show();
14101         $.effects.createWrapper( el ); // Create Wrapper
14102
14103         // default distance for the BIGGEST bounce is the outer Distance / 3
14104         if ( !distance ) {
14105                 distance = el[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
14106         }
14107
14108         if ( show ) {
14109                 downAnim = { opacity: 1 };
14110                 downAnim[ ref ] = 0;
14111
14112                 // if we are showing, force opacity 0 and set the initial position
14113                 // then do the "first" animation
14114                 el.css( "opacity", 0 )
14115                         .css( ref, motion ? -distance * 2 : distance * 2 )
14116                         .animate( downAnim, speed, easing );
14117         }
14118
14119         // start at the smallest distance if we are hiding
14120         if ( hide ) {
14121                 distance = distance / Math.pow( 2, times - 1 );
14122         }
14123
14124         downAnim = {};
14125         downAnim[ ref ] = 0;
14126         // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
14127         for ( i = 0; i < times; i++ ) {
14128                 upAnim = {};
14129                 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
14130
14131                 el.animate( upAnim, speed, easing )
14132                         .animate( downAnim, speed, easing );
14133
14134                 distance = hide ? distance * 2 : distance / 2;
14135         }
14136
14137         // Last Bounce when Hiding
14138         if ( hide ) {
14139                 upAnim = { opacity: 0 };
14140                 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
14141
14142                 el.animate( upAnim, speed, easing );
14143         }
14144
14145         el.queue(function() {
14146                 if ( hide ) {
14147                         el.hide();
14148                 }
14149                 $.effects.restore( el, props );
14150                 $.effects.removeWrapper( el );
14151                 done();
14152         });
14153
14154         // inject all the animations we just queued to be first in line (after "inprogress")
14155         if ( queuelen > 1) {
14156                 queue.splice.apply( queue,
14157                         [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
14158         }
14159         el.dequeue();
14160
14161 };
14162
14163 })(jQuery);
14164 (function( $, undefined ) {
14165
14166 $.effects.effect.clip = function( o, done ) {
14167         // Create element
14168         var el = $( this ),
14169                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
14170                 mode = $.effects.setMode( el, o.mode || "hide" ),
14171                 show = mode === "show",
14172                 direction = o.direction || "vertical",
14173                 vert = direction === "vertical",
14174                 size = vert ? "height" : "width",
14175                 position = vert ? "top" : "left",
14176                 animation = {},
14177                 wrapper, animate, distance;
14178
14179         // Save & Show
14180         $.effects.save( el, props );
14181         el.show();
14182
14183         // Create Wrapper
14184         wrapper = $.effects.createWrapper( el ).css({
14185                 overflow: "hidden"
14186         });
14187         animate = ( el[0].tagName === "IMG" ) ? wrapper : el;
14188         distance = animate[ size ]();
14189
14190         // Shift
14191         if ( show ) {
14192                 animate.css( size, 0 );
14193                 animate.css( position, distance / 2 );
14194         }
14195
14196         // Create Animation Object:
14197         animation[ size ] = show ? distance : 0;
14198         animation[ position ] = show ? 0 : distance / 2;
14199
14200         // Animate
14201         animate.animate( animation, {
14202                 queue: false,
14203                 duration: o.duration,
14204                 easing: o.easing,
14205                 complete: function() {
14206                         if ( !show ) {
14207                                 el.hide();
14208                         }
14209                         $.effects.restore( el, props );
14210                         $.effects.removeWrapper( el );
14211                         done();
14212                 }
14213         });
14214
14215 };
14216
14217 })(jQuery);
14218 (function( $, undefined ) {
14219
14220 $.effects.effect.drop = function( o, done ) {
14221
14222         var el = $( this ),
14223                 props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
14224                 mode = $.effects.setMode( el, o.mode || "hide" ),
14225                 show = mode === "show",
14226                 direction = o.direction || "left",
14227                 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
14228                 motion = ( direction === "up" || direction === "left" ) ? "pos" : "neg",
14229                 animation = {
14230                         opacity: show ? 1 : 0
14231                 },
14232                 distance;
14233
14234         // Adjust
14235         $.effects.save( el, props );
14236         el.show();
14237         $.effects.createWrapper( el );
14238
14239         distance = o.distance || el[ ref === "top" ? "outerHeight": "outerWidth" ]( true ) / 2;
14240
14241         if ( show ) {
14242                 el
14243                         .css( "opacity", 0 )
14244                         .css( ref, motion === "pos" ? -distance : distance );
14245         }
14246
14247         // Animation
14248         animation[ ref ] = ( show ?
14249                 ( motion === "pos" ? "+=" : "-=" ) :
14250                 ( motion === "pos" ? "-=" : "+=" ) ) +
14251                 distance;
14252
14253         // Animate
14254         el.animate( animation, {
14255                 queue: false,
14256                 duration: o.duration,
14257                 easing: o.easing,
14258                 complete: function() {
14259                         if ( mode === "hide" ) {
14260                                 el.hide();
14261                         }
14262                         $.effects.restore( el, props );
14263                         $.effects.removeWrapper( el );
14264                         done();
14265                 }
14266         });
14267 };
14268
14269 })(jQuery);
14270 (function( $, undefined ) {
14271
14272 $.effects.effect.explode = function( o, done ) {
14273
14274         var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3,
14275                 cells = rows,
14276                 el = $( this ),
14277                 mode = $.effects.setMode( el, o.mode || "hide" ),
14278                 show = mode === "show",
14279
14280                 // show and then visibility:hidden the element before calculating offset
14281                 offset = el.show().css( "visibility", "hidden" ).offset(),
14282
14283                 // width and height of a piece
14284                 width = Math.ceil( el.outerWidth() / cells ),
14285                 height = Math.ceil( el.outerHeight() / rows ),
14286                 pieces = [],
14287
14288                 // loop
14289                 i, j, left, top, mx, my;
14290
14291         // children animate complete:
14292         function childComplete() {
14293                 pieces.push( this );
14294                 if ( pieces.length === rows * cells ) {
14295                         animComplete();
14296                 }
14297         }
14298
14299         // clone the element for each row and cell.
14300         for( i = 0; i < rows ; i++ ) { // ===>
14301                 top = offset.top + i * height;
14302                 my = i - ( rows - 1 ) / 2 ;
14303
14304                 for( j = 0; j < cells ; j++ ) { // |||
14305                         left = offset.left + j * width;
14306                         mx = j - ( cells - 1 ) / 2 ;
14307
14308                         // Create a clone of the now hidden main element that will be absolute positioned
14309                         // within a wrapper div off the -left and -top equal to size of our pieces
14310                         el
14311                                 .clone()
14312                                 .appendTo( "body" )
14313                                 .wrap( "<div></div>" )
14314                                 .css({
14315                                         position: "absolute",
14316                                         visibility: "visible",
14317                                         left: -j * width,
14318                                         top: -i * height
14319                                 })
14320
14321                         // select the wrapper - make it overflow: hidden and absolute positioned based on
14322                         // where the original was located +left and +top equal to the size of pieces
14323                                 .parent()
14324                                 .addClass( "ui-effects-explode" )
14325                                 .css({
14326                                         position: "absolute",
14327                                         overflow: "hidden",
14328                                         width: width,
14329                                         height: height,
14330                                         left: left + ( show ? mx * width : 0 ),
14331                                         top: top + ( show ? my * height : 0 ),
14332                                         opacity: show ? 0 : 1
14333                                 }).animate({
14334                                         left: left + ( show ? 0 : mx * width ),
14335                                         top: top + ( show ? 0 : my * height ),
14336                                         opacity: show ? 1 : 0
14337                                 }, o.duration || 500, o.easing, childComplete );
14338                 }
14339         }
14340
14341         function animComplete() {
14342                 el.css({
14343                         visibility: "visible"
14344                 });
14345                 $( pieces ).remove();
14346                 if ( !show ) {
14347                         el.hide();
14348                 }
14349                 done();
14350         }
14351 };
14352
14353 })(jQuery);
14354 (function( $, undefined ) {
14355
14356 $.effects.effect.fade = function( o, done ) {
14357         var el = $( this ),
14358                 mode = $.effects.setMode( el, o.mode || "toggle" );
14359
14360         el.animate({
14361                 opacity: mode
14362         }, {
14363                 queue: false,
14364                 duration: o.duration,
14365                 easing: o.easing,
14366                 complete: done
14367         });
14368 };
14369
14370 })( jQuery );
14371 (function( $, undefined ) {
14372
14373 $.effects.effect.fold = function( o, done ) {
14374
14375         // Create element
14376         var el = $( this ),
14377                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
14378                 mode = $.effects.setMode( el, o.mode || "hide" ),
14379                 show = mode === "show",
14380                 hide = mode === "hide",
14381                 size = o.size || 15,
14382                 percent = /([0-9]+)%/.exec( size ),
14383                 horizFirst = !!o.horizFirst,
14384                 widthFirst = show !== horizFirst,
14385                 ref = widthFirst ? [ "width", "height" ] : [ "height", "width" ],
14386                 duration = o.duration / 2,
14387                 wrapper, distance,
14388                 animation1 = {},
14389                 animation2 = {};
14390
14391         $.effects.save( el, props );
14392         el.show();
14393
14394         // Create Wrapper
14395         wrapper = $.effects.createWrapper( el ).css({
14396                 overflow: "hidden"
14397         });
14398         distance = widthFirst ?
14399                 [ wrapper.width(), wrapper.height() ] :
14400                 [ wrapper.height(), wrapper.width() ];
14401
14402         if ( percent ) {
14403                 size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
14404         }
14405         if ( show ) {
14406                 wrapper.css( horizFirst ? {
14407                         height: 0,
14408                         width: size
14409                 } : {
14410                         height: size,
14411                         width: 0
14412                 });
14413         }
14414
14415         // Animation
14416         animation1[ ref[ 0 ] ] = show ? distance[ 0 ] : size;
14417         animation2[ ref[ 1 ] ] = show ? distance[ 1 ] : 0;
14418
14419         // Animate
14420         wrapper
14421                 .animate( animation1, duration, o.easing )
14422                 .animate( animation2, duration, o.easing, function() {
14423                         if ( hide ) {
14424                                 el.hide();
14425                         }
14426                         $.effects.restore( el, props );
14427                         $.effects.removeWrapper( el );
14428                         done();
14429                 });
14430
14431 };
14432
14433 })(jQuery);
14434 (function( $, undefined ) {
14435
14436 $.effects.effect.highlight = function( o, done ) {
14437         var elem = $( this ),
14438                 props = [ "backgroundImage", "backgroundColor", "opacity" ],
14439                 mode = $.effects.setMode( elem, o.mode || "show" ),
14440                 animation = {
14441                         backgroundColor: elem.css( "backgroundColor" )
14442                 };
14443
14444         if (mode === "hide") {
14445                 animation.opacity = 0;
14446         }
14447
14448         $.effects.save( elem, props );
14449
14450         elem
14451                 .show()
14452                 .css({
14453                         backgroundImage: "none",
14454                         backgroundColor: o.color || "#ffff99"
14455                 })
14456                 .animate( animation, {
14457                         queue: false,
14458                         duration: o.duration,
14459                         easing: o.easing,
14460                         complete: function() {
14461                                 if ( mode === "hide" ) {
14462                                         elem.hide();
14463                                 }
14464                                 $.effects.restore( elem, props );
14465                                 done();
14466                         }
14467                 });
14468 };
14469
14470 })(jQuery);
14471 (function( $, undefined ) {
14472
14473 $.effects.effect.pulsate = function( o, done ) {
14474         var elem = $( this ),
14475                 mode = $.effects.setMode( elem, o.mode || "show" ),
14476                 show = mode === "show",
14477                 hide = mode === "hide",
14478                 showhide = ( show || mode === "hide" ),
14479
14480                 // showing or hiding leaves of the "last" animation
14481                 anims = ( ( o.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
14482                 duration = o.duration / anims,
14483                 animateTo = 0,
14484                 queue = elem.queue(),
14485                 queuelen = queue.length,
14486                 i;
14487
14488         if ( show || !elem.is(":visible")) {
14489                 elem.css( "opacity", 0 ).show();
14490                 animateTo = 1;
14491         }
14492
14493         // anims - 1 opacity "toggles"
14494         for ( i = 1; i < anims; i++ ) {
14495                 elem.animate({
14496                         opacity: animateTo
14497                 }, duration, o.easing );
14498                 animateTo = 1 - animateTo;
14499         }
14500
14501         elem.animate({
14502                 opacity: animateTo
14503         }, duration, o.easing);
14504
14505         elem.queue(function() {
14506                 if ( hide ) {
14507                         elem.hide();
14508                 }
14509                 done();
14510         });
14511
14512         // We just queued up "anims" animations, we need to put them next in the queue
14513         if ( queuelen > 1 ) {
14514                 queue.splice.apply( queue,
14515                         [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
14516         }
14517         elem.dequeue();
14518 };
14519
14520 })(jQuery);
14521 (function( $, undefined ) {
14522
14523 $.effects.effect.puff = function( o, done ) {
14524         var elem = $( this ),
14525                 mode = $.effects.setMode( elem, o.mode || "hide" ),
14526                 hide = mode === "hide",
14527                 percent = parseInt( o.percent, 10 ) || 150,
14528                 factor = percent / 100,
14529                 original = {
14530                         height: elem.height(),
14531                         width: elem.width(),
14532                         outerHeight: elem.outerHeight(),
14533                         outerWidth: elem.outerWidth()
14534                 };
14535
14536         $.extend( o, {
14537                 effect: "scale",
14538                 queue: false,
14539                 fade: true,
14540                 mode: mode,
14541                 complete: done,
14542                 percent: hide ? percent : 100,
14543                 from: hide ?
14544                         original :
14545                         {
14546                                 height: original.height * factor,
14547                                 width: original.width * factor,
14548                                 outerHeight: original.outerHeight * factor,
14549                                 outerWidth: original.outerWidth * factor
14550                         }
14551         });
14552
14553         elem.effect( o );
14554 };
14555
14556 $.effects.effect.scale = function( o, done ) {
14557
14558         // Create element
14559         var el = $( this ),
14560                 options = $.extend( true, {}, o ),
14561                 mode = $.effects.setMode( el, o.mode || "effect" ),
14562                 percent = parseInt( o.percent, 10 ) ||
14563                         ( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ),
14564                 direction = o.direction || "both",
14565                 origin = o.origin,
14566                 original = {
14567                         height: el.height(),
14568                         width: el.width(),
14569                         outerHeight: el.outerHeight(),
14570                         outerWidth: el.outerWidth()
14571                 },
14572                 factor = {
14573                         y: direction !== "horizontal" ? (percent / 100) : 1,
14574                         x: direction !== "vertical" ? (percent / 100) : 1
14575                 };
14576
14577         // We are going to pass this effect to the size effect:
14578         options.effect = "size";
14579         options.queue = false;
14580         options.complete = done;
14581
14582         // Set default origin and restore for show/hide
14583         if ( mode !== "effect" ) {
14584                 options.origin = origin || ["middle","center"];
14585                 options.restore = true;
14586         }
14587
14588         options.from = o.from || ( mode === "show" ? {
14589                 height: 0,
14590                 width: 0,
14591                 outerHeight: 0,
14592                 outerWidth: 0
14593         } : original );
14594         options.to = {
14595                 height: original.height * factor.y,
14596                 width: original.width * factor.x,
14597                 outerHeight: original.outerHeight * factor.y,
14598                 outerWidth: original.outerWidth * factor.x
14599         };
14600
14601         // Fade option to support puff
14602         if ( options.fade ) {
14603                 if ( mode === "show" ) {
14604                         options.from.opacity = 0;
14605                         options.to.opacity = 1;
14606                 }
14607                 if ( mode === "hide" ) {
14608                         options.from.opacity = 1;
14609                         options.to.opacity = 0;
14610                 }
14611         }
14612
14613         // Animate
14614         el.effect( options );
14615
14616 };
14617
14618 $.effects.effect.size = function( o, done ) {
14619
14620         // Create element
14621         var original, baseline, factor,
14622                 el = $( this ),
14623                 props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
14624
14625                 // Always restore
14626                 props1 = [ "position", "top", "bottom", "left", "right", "overflow", "opacity" ],
14627
14628                 // Copy for children
14629                 props2 = [ "width", "height", "overflow" ],
14630                 cProps = [ "fontSize" ],
14631                 vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
14632                 hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
14633
14634                 // Set options
14635                 mode = $.effects.setMode( el, o.mode || "effect" ),
14636                 restore = o.restore || mode !== "effect",
14637                 scale = o.scale || "both",
14638                 origin = o.origin || [ "middle", "center" ],
14639                 position = el.css( "position" ),
14640                 props = restore ? props0 : props1,
14641                 zero = {
14642                         height: 0,
14643                         width: 0,
14644                         outerHeight: 0,
14645                         outerWidth: 0
14646                 };
14647
14648         if ( mode === "show" ) {
14649                 el.show();
14650         }
14651         original = {
14652                 height: el.height(),
14653                 width: el.width(),
14654                 outerHeight: el.outerHeight(),
14655                 outerWidth: el.outerWidth()
14656         };
14657
14658         if ( o.mode === "toggle" && mode === "show" ) {
14659                 el.from = o.to || zero;
14660                 el.to = o.from || original;
14661         } else {
14662                 el.from = o.from || ( mode === "show" ? zero : original );
14663                 el.to = o.to || ( mode === "hide" ? zero : original );
14664         }
14665
14666         // Set scaling factor
14667         factor = {
14668                 from: {
14669                         y: el.from.height / original.height,
14670                         x: el.from.width / original.width
14671                 },
14672                 to: {
14673                         y: el.to.height / original.height,
14674                         x: el.to.width / original.width
14675                 }
14676         };
14677
14678         // Scale the css box
14679         if ( scale === "box" || scale === "both" ) {
14680
14681                 // Vertical props scaling
14682                 if ( factor.from.y !== factor.to.y ) {
14683                         props = props.concat( vProps );
14684                         el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from );
14685                         el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to );
14686                 }
14687
14688                 // Horizontal props scaling
14689                 if ( factor.from.x !== factor.to.x ) {
14690                         props = props.concat( hProps );
14691                         el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from );
14692                         el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to );
14693                 }
14694         }
14695
14696         // Scale the content
14697         if ( scale === "content" || scale === "both" ) {
14698
14699                 // Vertical props scaling
14700                 if ( factor.from.y !== factor.to.y ) {
14701                         props = props.concat( cProps ).concat( props2 );
14702                         el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from );
14703                         el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to );
14704                 }
14705         }
14706
14707         $.effects.save( el, props );
14708         el.show();
14709         $.effects.createWrapper( el );
14710         el.css( "overflow", "hidden" ).css( el.from );
14711
14712         // Adjust
14713         if (origin) { // Calculate baseline shifts
14714                 baseline = $.effects.getBaseline( origin, original );
14715                 el.from.top = ( original.outerHeight - el.outerHeight() ) * baseline.y;
14716                 el.from.left = ( original.outerWidth - el.outerWidth() ) * baseline.x;
14717                 el.to.top = ( original.outerHeight - el.to.outerHeight ) * baseline.y;
14718                 el.to.left = ( original.outerWidth - el.to.outerWidth ) * baseline.x;
14719         }
14720         el.css( el.from ); // set top & left
14721
14722         // Animate
14723         if ( scale === "content" || scale === "both" ) { // Scale the children
14724
14725                 // Add margins/font-size
14726                 vProps = vProps.concat([ "marginTop", "marginBottom" ]).concat(cProps);
14727                 hProps = hProps.concat([ "marginLeft", "marginRight" ]);
14728                 props2 = props0.concat(vProps).concat(hProps);
14729
14730                 el.find( "*[width]" ).each( function(){
14731                         var child = $( this ),
14732                                 c_original = {
14733                                         height: child.height(),
14734                                         width: child.width(),
14735                                         outerHeight: child.outerHeight(),
14736                                         outerWidth: child.outerWidth()
14737                                 };
14738                         if (restore) {
14739                                 $.effects.save(child, props2);
14740                         }
14741
14742                         child.from = {
14743                                 height: c_original.height * factor.from.y,
14744                                 width: c_original.width * factor.from.x,
14745                                 outerHeight: c_original.outerHeight * factor.from.y,
14746                                 outerWidth: c_original.outerWidth * factor.from.x
14747                         };
14748                         child.to = {
14749                                 height: c_original.height * factor.to.y,
14750                                 width: c_original.width * factor.to.x,
14751                                 outerHeight: c_original.height * factor.to.y,
14752                                 outerWidth: c_original.width * factor.to.x
14753                         };
14754
14755                         // Vertical props scaling
14756                         if ( factor.from.y !== factor.to.y ) {
14757                                 child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from );
14758                                 child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to );
14759                         }
14760
14761                         // Horizontal props scaling
14762                         if ( factor.from.x !== factor.to.x ) {
14763                                 child.from = $.effects.setTransition( child, hProps, factor.from.x, child.from );
14764                                 child.to = $.effects.setTransition( child, hProps, factor.to.x, child.to );
14765                         }
14766
14767                         // Animate children
14768                         child.css( child.from );
14769                         child.animate( child.to, o.duration, o.easing, function() {
14770
14771                                 // Restore children
14772                                 if ( restore ) {
14773                                         $.effects.restore( child, props2 );
14774                                 }
14775                         });
14776                 });
14777         }
14778
14779         // Animate
14780         el.animate( el.to, {
14781                 queue: false,
14782                 duration: o.duration,
14783                 easing: o.easing,
14784                 complete: function() {
14785                         if ( el.to.opacity === 0 ) {
14786                                 el.css( "opacity", el.from.opacity );
14787                         }
14788                         if( mode === "hide" ) {
14789                                 el.hide();
14790                         }
14791                         $.effects.restore( el, props );
14792                         if ( !restore ) {
14793
14794                                 // we need to calculate our new positioning based on the scaling
14795                                 if ( position === "static" ) {
14796                                         el.css({
14797                                                 position: "relative",
14798                                                 top: el.to.top,
14799                                                 left: el.to.left
14800                                         });
14801                                 } else {
14802                                         $.each([ "top", "left" ], function( idx, pos ) {
14803                                                 el.css( pos, function( _, str ) {
14804                                                         var val = parseInt( str, 10 ),
14805                                                                 toRef = idx ? el.to.left : el.to.top;
14806
14807                                                         // if original was "auto", recalculate the new value from wrapper
14808                                                         if ( str === "auto" ) {
14809                                                                 return toRef + "px";
14810                                                         }
14811
14812                                                         return val + toRef + "px";
14813                                                 });
14814                                         });
14815                                 }
14816                         }
14817
14818                         $.effects.removeWrapper( el );
14819                         done();
14820                 }
14821         });
14822
14823 };
14824
14825 })(jQuery);
14826 (function( $, undefined ) {
14827
14828 $.effects.effect.shake = function( o, done ) {
14829
14830         var el = $( this ),
14831                 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
14832                 mode = $.effects.setMode( el, o.mode || "effect" ),
14833                 direction = o.direction || "left",
14834                 distance = o.distance || 20,
14835                 times = o.times || 3,
14836                 anims = times * 2 + 1,
14837                 speed = Math.round(o.duration/anims),
14838                 ref = (direction === "up" || direction === "down") ? "top" : "left",
14839                 positiveMotion = (direction === "up" || direction === "left"),
14840                 animation = {},
14841                 animation1 = {},
14842                 animation2 = {},
14843                 i,
14844
14845                 // we will need to re-assemble the queue to stack our animations in place
14846                 queue = el.queue(),
14847                 queuelen = queue.length;
14848
14849         $.effects.save( el, props );
14850         el.show();
14851         $.effects.createWrapper( el );
14852
14853         // Animation
14854         animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
14855         animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
14856         animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
14857
14858         // Animate
14859         el.animate( animation, speed, o.easing );
14860
14861         // Shakes
14862         for ( i = 1; i < times; i++ ) {
14863                 el.animate( animation1, speed, o.easing ).animate( animation2, speed, o.easing );
14864         }
14865         el
14866                 .animate( animation1, speed, o.easing )
14867                 .animate( animation, speed / 2, o.easing )
14868                 .queue(function() {
14869                         if ( mode === "hide" ) {
14870                                 el.hide();
14871                         }
14872                         $.effects.restore( el, props );
14873                         $.effects.removeWrapper( el );
14874                         done();
14875                 });
14876
14877         // inject all the animations we just queued to be first in line (after "inprogress")
14878         if ( queuelen > 1) {
14879                 queue.splice.apply( queue,
14880                         [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
14881         }
14882         el.dequeue();
14883
14884 };
14885
14886 })(jQuery);
14887 (function( $, undefined ) {
14888
14889 $.effects.effect.slide = function( o, done ) {
14890
14891         // Create element
14892         var el = $( this ),
14893                 props = [ "position", "top", "bottom", "left", "right", "width", "height" ],
14894                 mode = $.effects.setMode( el, o.mode || "show" ),
14895                 show = mode === "show",
14896                 direction = o.direction || "left",
14897                 ref = (direction === "up" || direction === "down") ? "top" : "left",
14898                 positiveMotion = (direction === "up" || direction === "left"),
14899                 distance,
14900                 animation = {};
14901
14902         // Adjust
14903         $.effects.save( el, props );
14904         el.show();
14905         distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true );
14906
14907         $.effects.createWrapper( el ).css({
14908                 overflow: "hidden"
14909         });
14910
14911         if ( show ) {
14912                 el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance );
14913         }
14914
14915         // Animation
14916         animation[ ref ] = ( show ?
14917                 ( positiveMotion ? "+=" : "-=") :
14918                 ( positiveMotion ? "-=" : "+=")) +
14919                 distance;
14920
14921         // Animate
14922         el.animate( animation, {
14923                 queue: false,
14924                 duration: o.duration,
14925                 easing: o.easing,
14926                 complete: function() {
14927                         if ( mode === "hide" ) {
14928                                 el.hide();
14929                         }
14930                         $.effects.restore( el, props );
14931                         $.effects.removeWrapper( el );
14932                         done();
14933                 }
14934         });
14935 };
14936
14937 })(jQuery);
14938 (function( $, undefined ) {
14939
14940 $.effects.effect.transfer = function( o, done ) {
14941         var elem = $( this ),
14942                 target = $( o.to ),
14943                 targetFixed = target.css( "position" ) === "fixed",
14944                 body = $("body"),
14945                 fixTop = targetFixed ? body.scrollTop() : 0,
14946                 fixLeft = targetFixed ? body.scrollLeft() : 0,
14947                 endPosition = target.offset(),
14948                 animation = {
14949                         top: endPosition.top - fixTop ,
14950                         left: endPosition.left - fixLeft ,
14951                         height: target.innerHeight(),
14952                         width: target.innerWidth()
14953                 },
14954                 startPosition = elem.offset(),
14955                 transfer = $( "<div class='ui-effects-transfer'></div>" )
14956                         .appendTo( document.body )
14957                         .addClass( o.className )
14958                         .css({
14959                                 top: startPosition.top - fixTop ,
14960                                 left: startPosition.left - fixLeft ,
14961                                 height: elem.innerHeight(),
14962                                 width: elem.innerWidth(),
14963                                 position: targetFixed ? "fixed" : "absolute"
14964                         })
14965                         .animate( animation, o.duration, o.easing, function() {
14966                                 transfer.remove();
14967                                 done();
14968                         });
14969 };
14970
14971 })(jQuery);