js/jquery/jquery-ui-1.8.custom.js

   1 /*!
   2  * jQuery UI 1.8
   3  *
   4  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
   5  * Dual licensed under the MIT (MIT-LICENSE.txt)
   6  * and GPL (GPL-LICENSE.txt) licenses.
   7  *
   8  * http://docs.jquery.com/UI
   9  */
  10 ;jQuery.ui || (function($) {
  11
  12 //Helper functions and ui object
  13 $.ui = {
  14         version: "1.8",
  15
  16         // $.ui.plugin is deprecated.  Use the proxy pattern instead.
  17         plugin: {
  18                 add: function(module, option, set) {
  19                         var proto = $.ui[module].prototype;
  20                         for(var i in set) {
  21                                 proto.plugins[i] = proto.plugins[i] || [];
  22                                 proto.plugins[i].push([option, set[i]]);
  23                         }
  24                 },
  25                 call: function(instance, name, args) {
  26                         var set = instance.plugins[name];
  27                         if(!set || !instance.element[0].parentNode) { return; }
  28
  29                         for (var i = 0; i < set.length; i++) {
  30                                 if (instance.options[set[i][0]]) {
  31                                         set[i][1].apply(instance.element, args);
  32                                 }
  33                         }
  34                 }
  35         },
  36
  37         contains: function(a, b) {
  38                 return document.compareDocumentPosition
  39                         ? a.compareDocumentPosition(b) & 16
  40                         : a !== b && a.contains(b);
  41         },
  42
  43         hasScroll: function(el, a) {
  44
  45                 //If overflow is hidden, the element might have extra content, but the user wants to hide it
  46                 if ($(el).css('overflow') == 'hidden') { return false; }
  47
  48                 var scroll = (a && a == 'left') ? 'scrollLeft' : 'scrollTop',
  49                         has = false;
  50
  51                 if (el[scroll] > 0) { return true; }
  52
  53                 // TODO: determine which cases actually cause this to happen
  54                 // if the element doesn't have the scroll set, see if it's possible to
  55                 // set the scroll
  56                 el[scroll] = 1;
  57                 has = (el[scroll] > 0);
  58                 el[scroll] = 0;
  59                 return has;
  60         },
  61
  62         isOverAxis: function(x, reference, size) {
  63                 //Determines when x coordinate is over "b" element axis
  64                 return (x > reference) && (x < (reference + size));
  65         },
  66
  67         isOver: function(y, x, top, left, height, width) {
  68                 //Determines when x, y coordinates is over "b" element
  69                 return $.ui.isOverAxis(y, top, height) && $.ui.isOverAxis(x, left, width);
  70         },
  71
  72         keyCode: {
  73                 BACKSPACE: 8,
  74                 CAPS_LOCK: 20,
  75                 COMMA: 188,
  76                 CONTROL: 17,
  77                 DELETE: 46,
  78                 DOWN: 40,
  79                 END: 35,
  80                 ENTER: 13,
  81                 ESCAPE: 27,
  82                 HOME: 36,
  83                 INSERT: 45,
  84                 LEFT: 37,
  85                 NUMPAD_ADD: 107,
  86                 NUMPAD_DECIMAL: 110,
  87                 NUMPAD_DIVIDE: 111,
  88                 NUMPAD_ENTER: 108,
  89                 NUMPAD_MULTIPLY: 106,
  90                 NUMPAD_SUBTRACT: 109,
  91                 PAGE_DOWN: 34,
  92                 PAGE_UP: 33,
  93                 PERIOD: 190,
  94                 RIGHT: 39,
  95                 SHIFT: 16,
  96                 SPACE: 32,
  97                 TAB: 9,
  98                 UP: 38
  99         }
 100 };
 101
 102 //jQuery plugins
 103 $.fn.extend({
 104         _focus: $.fn.focus,
 105         focus: function(delay, fn) {
 106                 return typeof delay === 'number'
 107                         ? this.each(function() {
 108                                 var elem = this;
 109                                 setTimeout(function() {
 110                                         $(elem).focus();
 111                                         (fn && fn.call(elem));
 112                                 }, delay);
 113                         })
 114                         : this._focus.apply(this, arguments);
 115         },
 116
 117         enableSelection: function() {
 118                 return this
 119                         .attr('unselectable', 'off')
 120                         .css('MozUserSelect', '')
 121                         .unbind('selectstart.ui');
 122         },
 123
 124         disableSelection: function() {
 125                 return this
 126                         .attr('unselectable', 'on')
 127                         .css('MozUserSelect', 'none')
 128                         .bind('selectstart.ui', function() { return false; });
 129         },
 130
 131         scrollParent: function() {
 132                 var scrollParent;
 133                 if(($.browser.msie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {
 134                         scrollParent = this.parents().filter(function() {
 135                                 return (/(relative|absolute|fixed)/).test($.curCSS(this,'position',1)) && (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
 136                         }).eq(0);
 137                 } else {
 138                         scrollParent = this.parents().filter(function() {
 139                                 return (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
 140                         }).eq(0);
 141                 }
 142
 143                 return (/fixed/).test(this.css('position')) || !scrollParent.length ? $(document) : scrollParent;
 144         },
 145
 146         zIndex: function(zIndex) {
 147                 if (zIndex !== undefined) {
 148                         return this.css('zIndex', zIndex);
 149                 }
 150
 151                 if (this.length) {
 152                         var elem = $(this[0]), position, value;
 153                         while (elem.length && elem[0] !== document) {
 154                                 // Ignore z-index if position is set to a value where z-index is ignored by the browser
 155                                 // This makes behavior of this function consistent across browsers
 156                                 // WebKit always returns auto if the element is positioned
 157                                 position = elem.css('position');
 158                                 if (position == 'absolute' || position == 'relative' || position == 'fixed')
 159                                 {
 160                                         // IE returns 0 when zIndex is not specified
 161                                         // other browsers return a string
 162                                         // we ignore the case of nested elements with an explicit value of 0
 163                                         // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
 164                                         value = parseInt(elem.css('zIndex'));
 165                                         if (!isNaN(value) && value != 0) {
 166                                                 return value;
 167                                         }
 168                                 }
 169                                 elem = elem.parent();
 170                         }
 171                 }
 172
 173                 return 0;
 174         }
 175 });
 176
 177
 178 //Additional selectors
 179 $.extend($.expr[':'], {
 180         data: function(elem, i, match) {
 181                 return !!$.data(elem, match[3]);
 182         },
 183
 184         focusable: function(element) {
 185                 var nodeName = element.nodeName.toLowerCase(),
 186                         tabIndex = $.attr(element, 'tabindex');
 187                 return (/input|select|textarea|button|object/.test(nodeName)
 188                         ? !element.disabled
 189                         : 'a' == nodeName || 'area' == nodeName
 190                                 ? element.href || !isNaN(tabIndex)
 191                                 : !isNaN(tabIndex))
 192                         // the element and all of its ancestors must be visible
 193                         // the browser may report that the area is hidden
 194                         && !$(element)['area' == nodeName ? 'parents' : 'closest'](':hidden').length;
 195         },
 196
 197         tabbable: function(element) {
 198                 var tabIndex = $.attr(element, 'tabindex');
 199                 return (isNaN(tabIndex) || tabIndex >= 0) && $(element).is(':focusable');
 200         }
 201 });
 202
 203 })(jQuery);
 204 /*!
 205  * jQuery UI Widget 1.8
 206  *
 207  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
 208  * Dual licensed under the MIT (MIT-LICENSE.txt)
 209  * and GPL (GPL-LICENSE.txt) licenses.
 210  *
 211  * http://docs.jquery.com/UI/Widget
 212  */
 213 (function( $ ) {
 214
 215 var _remove = $.fn.remove;
 216
 217 $.fn.remove = function( selector, keepData ) {
 218         return this.each(function() {
 219                 if ( !keepData ) {
 220                         if ( !selector || $.filter( selector, [ this ] ).length ) {
 221                                 $( "*", this ).add( this ).each(function() {
 222                                         $( this ).triggerHandler( "remove" );
 223                                 });
 224                         }
 225                 }
 226                 return _remove.call( $(this), selector, keepData );
 227         });
 228 };
 229
 230 $.widget = function( name, base, prototype ) {
 231         var namespace = name.split( "." )[ 0 ],
 232                 fullName;
 233         name = name.split( "." )[ 1 ];
 234         fullName = namespace + "-" + name;
 235
 236         if ( !prototype ) {
 237                 prototype = base;
 238                 base = $.Widget;
 239         }
 240
 241         // create selector for plugin
 242         $.expr[ ":" ][ fullName ] = function( elem ) {
 243                 return !!$.data( elem, name );
 244         };
 245
 246         $[ namespace ] = $[ namespace ] || {};
 247         $[ namespace ][ name ] = function( options, element ) {
 248                 // allow instantiation without initializing for simple inheritance
 249                 if ( arguments.length ) {
 250                         this._createWidget( options, element );
 251                 }
 252         };
 253
 254         var basePrototype = new base();
 255         // we need to make the options hash a property directly on the new instance
 256         // otherwise we'll modify the options hash on the prototype that we're
 257         // inheriting from
 258 //      $.each( basePrototype, function( key, val ) {
 259 //              if ( $.isPlainObject(val) ) {
 260 //                      basePrototype[ key ] = $.extend( {}, val );
 261 //              }
 262 //      });
 263         basePrototype.options = $.extend( {}, basePrototype.options );
 264         $[ namespace ][ name ].prototype = $.extend( true, basePrototype, {
 265                 namespace: namespace,
 266                 widgetName: name,
 267                 widgetEventPrefix: $[ namespace ][ name ].prototype.widgetEventPrefix || name,
 268                 widgetBaseClass: fullName
 269         }, prototype );
 270
 271         $.widget.bridge( name, $[ namespace ][ name ] );
 272 };
 273
 274 $.widget.bridge = function( name, object ) {
 275         $.fn[ name ] = function( options ) {
 276                 var isMethodCall = typeof options === "string",
 277                         args = Array.prototype.slice.call( arguments, 1 ),
 278                         returnValue = this;
 279
 280                 // allow multiple hashes to be passed on init
 281                 options = !isMethodCall && args.length ?
 282                         $.extend.apply( null, [ true, options ].concat(args) ) :
 283                         options;
 284
 285                 // prevent calls to internal methods
 286                 if ( isMethodCall && options.substring( 0, 1 ) === "_" ) {
 287                         return returnValue;
 288                 }
 289
 290                 if ( isMethodCall ) {
 291                         this.each(function() {
 292                                 var instance = $.data( this, name ),
 293                                         methodValue = instance && $.isFunction( instance[options] ) ?
 294                                                 instance[ options ].apply( instance, args ) :
 295                                                 instance;
 296                                 if ( methodValue !== instance && methodValue !== undefined ) {
 297                                         returnValue = methodValue;
 298                                         return false;
 299                                 }
 300                         });
 301                 } else {
 302                         this.each(function() {
 303                                 var instance = $.data( this, name );
 304                                 if ( instance ) {
 305                                         if ( options ) {
 306                                                 instance.option( options );
 307                                         }
 308                                         instance._init();
 309                                 } else {
 310                                         $.data( this, name, new object( options, this ) );
 311                                 }
 312                         });
 313                 }
 314
 315                 return returnValue;
 316         };
 317 };
 318
 319 $.Widget = function( options, element ) {
 320         // allow instantiation without initializing for simple inheritance
 321         if ( arguments.length ) {
 322                 this._createWidget( options, element );
 323         }
 324 };
 325
 326 $.Widget.prototype = {
 327         widgetName: "widget",
 328         widgetEventPrefix: "",
 329         options: {
 330                 disabled: false
 331         },
 332         _createWidget: function( options, element ) {
 333                 // $.widget.bridge stores the plugin instance, but we do it anyway
 334                 // so that it's stored even before the _create function runs
 335                 this.element = $( element ).data( this.widgetName, this );
 336                 this.options = $.extend( true, {},
 337                         this.options,
 338                         $.metadata && $.metadata.get( element )[ this.widgetName ],
 339                         options );
 340
 341                 var self = this;
 342                 this.element.bind( "remove." + this.widgetName, function() {
 343                         self.destroy();
 344                 });
 345
 346                 this._create();
 347                 this._init();
 348         },
 349         _create: function() {},
 350         _init: function() {},
 351
 352         destroy: function() {
 353                 this.element
 354                         .unbind( "." + this.widgetName )
 355                         .removeData( this.widgetName );
 356                 this.widget()
 357                         .unbind( "." + this.widgetName )
 358                         .removeAttr( "aria-disabled" )
 359                         .removeClass(
 360                                 this.widgetBaseClass + "-disabled " +
 361                                 this.namespace + "-state-disabled" );
 362         },
 363
 364         widget: function() {
 365                 return this.element;
 366         },
 367
 368         option: function( key, value ) {
 369                 var options = key,
 370                         self = this;
 371
 372                 if ( arguments.length === 0 ) {
 373                         // don't return a reference to the internal hash
 374                         return $.extend( {}, self.options );
 375                 }
 376
 377                 if  (typeof key === "string" ) {
 378                         if ( value === undefined ) {
 379                                 return this.options[ key ];
 380                         }
 381                         options = {};
 382                         options[ key ] = value;
 383                 }
 384
 385                 $.each( options, function( key, value ) {
 386                         self._setOption( key, value );
 387                 });
 388
 389                 return self;
 390         },
 391         _setOption: function( key, value ) {
 392                 this.options[ key ] = value;
 393
 394                 if ( key === "disabled" ) {
 395                         this.widget()
 396                                 [ value ? "addClass" : "removeClass"](
 397                                         this.widgetBaseClass + "-disabled" + " " +
 398                                         this.namespace + "-state-disabled" )
 399                                 .attr( "aria-disabled", value );
 400                 }
 401
 402                 return this;
 403         },
 404
 405         enable: function() {
 406                 return this._setOption( "disabled", false );
 407         },
 408         disable: function() {
 409                 return this._setOption( "disabled", true );
 410         },
 411
 412         _trigger: function( type, event, data ) {
 413                 var callback = this.options[ type ];
 414
 415                 event = $.Event( event );
 416                 event.type = ( type === this.widgetEventPrefix ?
 417                         type :
 418                         this.widgetEventPrefix + type ).toLowerCase();
 419                 data = data || {};
 420
 421                 // copy original event properties over to the new event
 422                 // this would happen if we could call $.event.fix instead of $.Event
 423                 // but we don't have a way to force an event to be fixed multiple times
 424                 if ( event.originalEvent ) {
 425                         for ( var i = $.event.props.length, prop; i; ) {
 426                                 prop = $.event.props[ --i ];
 427                                 event[ prop ] = event.originalEvent[ prop ];
 428                         }
 429                 }
 430
 431                 this.element.trigger( event, data );
 432
 433                 return !( $.isFunction(callback) &&
 434                         callback.call( this.element[0], event, data ) === false ||
 435                         event.isDefaultPrevented() );
 436         }
 437 };
 438
 439 })( jQuery );
 440 /*!
 441  * jQuery UI Mouse 1.8
 442  *
 443  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
 444  * Dual licensed under the MIT (MIT-LICENSE.txt)
 445  * and GPL (GPL-LICENSE.txt) licenses.
 446  *
 447  * http://docs.jquery.com/UI/Mouse
 448  *
 449  * Depends:
 450  *      jquery.ui.widget.js
 451  */
 452 (function($) {
 453
 454 $.widget("ui.mouse", {
 455         options: {
 456                 cancel: ':input,option',
 457                 distance: 1,
 458                 delay: 0
 459         },
 460         _mouseInit: function() {
 461                 var self = this;
 462
 463                 this.element
 464                         .bind('mousedown.'+this.widgetName, function(event) {
 465                                 return self._mouseDown(event);
 466                         })
 467                         .bind('click.'+this.widgetName, function(event) {
 468                                 if(self._preventClickEvent) {
 469                                         self._preventClickEvent = false;
 470                                         event.stopImmediatePropagation();
 471                                         return false;
 472                                 }
 473                         });
 474
 475                 this.started = false;
 476         },
 477
 478         // TODO: make sure destroying one instance of mouse doesn't mess with
 479         // other instances of mouse
 480         _mouseDestroy: function() {
 481                 this.element.unbind('.'+this.widgetName);
 482         },
 483
 484         _mouseDown: function(event) {
 485                 // don't let more than one widget handle mouseStart
 486                 // TODO: figure out why we have to use originalEvent
 487                 event.originalEvent = event.originalEvent || {};
 488                 if (event.originalEvent.mouseHandled) { return; }
 489
 490                 // we may have missed mouseup (out of window)
 491                 (this._mouseStarted && this._mouseUp(event));
 492
 493                 this._mouseDownEvent = event;
 494
 495                 var self = this,
 496                         btnIsLeft = (event.which == 1),
 497                         elIsCancel = (typeof this.options.cancel == "string" ? $(event.target).parents().add(event.target).filter(this.options.cancel).length : false);
 498                 if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
 499                         return true;
 500                 }
 501
 502                 this.mouseDelayMet = !this.options.delay;
 503                 if (!this.mouseDelayMet) {
 504                         this._mouseDelayTimer = setTimeout(function() {
 505                                 self.mouseDelayMet = true;
 506                         }, this.options.delay);
 507                 }
 508
 509                 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
 510                         this._mouseStarted = (this._mouseStart(event) !== false);
 511                         if (!this._mouseStarted) {
 512                                 event.preventDefault();
 513                                 return true;
 514                         }
 515                 }
 516
 517                 // these delegates are required to keep context
 518                 this._mouseMoveDelegate = function(event) {
 519                         return self._mouseMove(event);
 520                 };
 521                 this._mouseUpDelegate = function(event) {
 522                         return self._mouseUp(event);
 523                 };
 524                 $(document)
 525                         .bind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
 526                         .bind('mouseup.'+this.widgetName, this._mouseUpDelegate);
 527
 528                 // preventDefault() is used to prevent the selection of text here -
 529                 // however, in Safari, this causes select boxes not to be selectable
 530                 // anymore, so this fix is needed
 531                 ($.browser.safari || event.preventDefault());
 532
 533                 event.originalEvent.mouseHandled = true;
 534                 return true;
 535         },
 536
 537         _mouseMove: function(event) {
 538                 // IE mouseup check - mouseup happened when mouse was out of window
 539                 if ($.browser.msie && !event.button) {
 540                         return this._mouseUp(event);
 541                 }
 542
 543                 if (this._mouseStarted) {
 544                         this._mouseDrag(event);
 545                         return event.preventDefault();
 546                 }
 547
 548                 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
 549                         this._mouseStarted =
 550                                 (this._mouseStart(this._mouseDownEvent, event) !== false);
 551                         (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
 552                 }
 553
 554                 return !this._mouseStarted;
 555         },
 556
 557         _mouseUp: function(event) {
 558                 $(document)
 559                         .unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
 560                         .unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);
 561
 562                 if (this._mouseStarted) {
 563                         this._mouseStarted = false;
 564                         this._preventClickEvent = (event.target == this._mouseDownEvent.target);
 565                         this._mouseStop(event);
 566                 }
 567
 568                 return false;
 569         },
 570
 571         _mouseDistanceMet: function(event) {
 572                 return (Math.max(
 573                                 Math.abs(this._mouseDownEvent.pageX - event.pageX),
 574                                 Math.abs(this._mouseDownEvent.pageY - event.pageY)
 575                         ) >= this.options.distance
 576                 );
 577         },
 578
 579         _mouseDelayMet: function(event) {
 580                 return this.mouseDelayMet;
 581         },
 582
 583         // These are placeholder methods, to be overriden by extending plugin
 584         _mouseStart: function(event) {},
 585         _mouseDrag: function(event) {},
 586         _mouseStop: function(event) {},
 587         _mouseCapture: function(event) { return true; }
 588 });
 589
 590 })(jQuery);
 591 /*
 592  * jQuery UI Position 1.8
 593  *
 594  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
 595  * Dual licensed under the MIT (MIT-LICENSE.txt)
 596  * and GPL (GPL-LICENSE.txt) licenses.
 597  *
 598  * http://docs.jquery.com/UI/Position
 599  */
 600 (function( $ ) {
 601
 602 $.ui = $.ui || {};
 603
 604 var horizontalPositions = /left|center|right/,
 605         horizontalDefault = "center",
 606         verticalPositions = /top|center|bottom/,
 607         verticalDefault = "center",
 608         _position = $.fn.position,
 609         _offset = $.fn.offset;
 610
 611 $.fn.position = function( options ) {
 612         if ( !options || !options.of ) {
 613                 return _position.apply( this, arguments );
 614         }
 615
 616         // make a copy, we don't want to modify arguments
 617         options = $.extend( {}, options );
 618
 619         var target = $( options.of ),
 620                 collision = ( options.collision || "flip" ).split( " " ),
 621                 offset = options.offset ? options.offset.split( " " ) : [ 0, 0 ],
 622                 targetWidth,
 623                 targetHeight,
 624                 basePosition;
 625
 626         if ( options.of.nodeType === 9 ) {
 627                 targetWidth = target.width();
 628                 targetHeight = target.height();
 629                 basePosition = { top: 0, left: 0 };
 630         } else if ( options.of.scrollTo && options.of.document ) {
 631                 targetWidth = target.width();
 632                 targetHeight = target.height();
 633                 basePosition = { top: target.scrollTop(), left: target.scrollLeft() };
 634         } else if ( options.of.preventDefault ) {
 635                 // force left top to allow flipping
 636                 options.at = "left top";
 637                 targetWidth = targetHeight = 0;
 638                 basePosition = { top: options.of.pageY, left: options.of.pageX };
 639         } else {
 640                 targetWidth = target.outerWidth();
 641                 targetHeight = target.outerHeight();
 642                 basePosition = target.offset();
 643         }
 644
 645         // force my and at to have valid horizontal and veritcal positions
 646         // if a value is missing or invalid, it will be converted to center
 647         $.each( [ "my", "at" ], function() {
 648                 var pos = ( options[this] || "" ).split( " " );
 649                 if ( pos.length === 1) {
 650                         pos = horizontalPositions.test( pos[0] ) ?
 651                                 pos.concat( [verticalDefault] ) :
 652                                 verticalPositions.test( pos[0] ) ?
 653                                         [ horizontalDefault ].concat( pos ) :
 654                                         [ horizontalDefault, verticalDefault ];
 655                 }
 656                 pos[ 0 ] = horizontalPositions.test( pos[0] ) ? pos[ 0 ] : horizontalDefault;
 657                 pos[ 1 ] = verticalPositions.test( pos[1] ) ? pos[ 1 ] : verticalDefault;
 658                 options[ this ] = pos;
 659         });
 660
 661         // normalize collision option
 662         if ( collision.length === 1 ) {
 663                 collision[ 1 ] = collision[ 0 ];
 664         }
 665
 666         // normalize offset option
 667         offset[ 0 ] = parseInt( offset[0], 10 ) || 0;
 668         if ( offset.length === 1 ) {
 669                 offset[ 1 ] = offset[ 0 ];
 670         }
 671         offset[ 1 ] = parseInt( offset[1], 10 ) || 0;
 672
 673         if ( options.at[0] === "right" ) {
 674                 basePosition.left += targetWidth;
 675         } else if (options.at[0] === horizontalDefault ) {
 676                 basePosition.left += targetWidth / 2;
 677         }
 678
 679         if ( options.at[1] === "bottom" ) {
 680                 basePosition.top += targetHeight;
 681         } else if ( options.at[1] === verticalDefault ) {
 682                 basePosition.top += targetHeight / 2;
 683         }
 684
 685         basePosition.left += offset[ 0 ];
 686         basePosition.top += offset[ 1 ];
 687
 688         return this.each(function() {
 689                 var elem = $( this ),
 690                         elemWidth = elem.outerWidth(),
 691                         elemHeight = elem.outerHeight(),
 692                         position = $.extend( {}, basePosition );
 693
 694                 if ( options.my[0] === "right" ) {
 695                         position.left -= elemWidth;
 696                 } else if ( options.my[0] === horizontalDefault ) {
 697                         position.left -= elemWidth / 2;
 698                 }
 699
 700                 if ( options.my[1] === "bottom" ) {
 701                         position.top -= elemHeight;
 702                 } else if ( options.my[1] === verticalDefault ) {
 703                         position.top -= elemHeight / 2;
 704                 }
 705
 706                 $.each( [ "left", "top" ], function( i, dir ) {
 707                         if ( $.ui.position[ collision[i] ] ) {
 708                                 $.ui.position[ collision[i] ][ dir ]( position, {
 709                                         targetWidth: targetWidth,
 710                                         targetHeight: targetHeight,
 711                                         elemWidth: elemWidth,
 712                                         elemHeight: elemHeight,
 713                                         offset: offset,
 714                                         my: options.my,
 715                                         at: options.at
 716                                 });
 717                         }
 718                 });
 719
 720                 if ( $.fn.bgiframe ) {
 721                         elem.bgiframe();
 722                 }
 723                 elem.offset( $.extend( position, { using: options.using } ) );
 724         });
 725 };
 726
 727 $.ui.position = {
 728         fit: {
 729                 left: function( position, data ) {
 730                         var win = $( window ),
 731                                 over = position.left + data.elemWidth - win.width() - win.scrollLeft();
 732                         position.left = over > 0 ? position.left - over : Math.max( 0, position.left );
 733                 },
 734                 top: function( position, data ) {
 735                         var win = $( window ),
 736                                 over = position.top + data.elemHeight - win.height() - win.scrollTop();
 737                         position.top = over > 0 ? position.top - over : Math.max( 0, position.top );
 738                 }
 739         },
 740
 741         flip: {
 742                 left: function( position, data ) {
 743                         if ( data.at[0] === "center" ) {
 744                                 return;
 745                         }
 746                         var win = $( window ),
 747                                 over = position.left + data.elemWidth - win.width() - win.scrollLeft(),
 748                                 myOffset = data.my[ 0 ] === "left" ?
 749                                         -data.elemWidth :
 750                                         data.my[ 0 ] === "right" ?
 751                                                 data.elemWidth :
 752                                                 0,
 753                                 offset = -2 * data.offset[ 0 ];
 754                         position.left += position.left < 0 ?
 755                                 myOffset + data.targetWidth + offset :
 756                                 over > 0 ?
 757                                         myOffset - data.targetWidth + offset :
 758                                         0;
 759                 },
 760                 top: function( position, data ) {
 761                         if ( data.at[1] === "center" ) {
 762                                 return;
 763                         }
 764                         var win = $( window ),
 765                                 over = position.top + data.elemHeight - win.height() - win.scrollTop(),
 766                                 myOffset = data.my[ 1 ] === "top" ?
 767                                         -data.elemHeight :
 768                                         data.my[ 1 ] === "bottom" ?
 769                                                 data.elemHeight :
 770                                                 0,
 771                                 atOffset = data.at[ 1 ] === "top" ?
 772                                         data.targetHeight :
 773                                         -data.targetHeight,
 774                                 offset = -2 * data.offset[ 1 ];
 775                         position.top += position.top < 0 ?
 776                                 myOffset + data.targetHeight + offset :
 777                                 over > 0 ?
 778                                         myOffset + atOffset + offset :
 779                                         0;
 780                 }
 781         }
 782 };
 783
 784 // offset setter from jQuery 1.4
 785 if ( !$.offset.setOffset ) {
 786         $.offset.setOffset = function( elem, options ) {
 787                 // set position first, in-case top/left are set even on static elem
 788                 if ( /static/.test( $.curCSS( elem, "position" ) ) ) {
 789                         elem.style.position = "relative";
 790                 }
 791                 var curElem   = $( elem ),
 792                         curOffset = curElem.offset(),
 793                         curTop    = parseInt( $.curCSS( elem, "top",  true ), 10 ) || 0,
 794                         curLeft   = parseInt( $.curCSS( elem, "left", true ), 10)  || 0,
 795                         props     = {
 796                                 top:  (options.top  - curOffset.top)  + curTop,
 797                                 left: (options.left - curOffset.left) + curLeft
 798                         };
 799
 800                 if ( 'using' in options ) {
 801                         options.using.call( elem, props );
 802                 } else {
 803                         curElem.css( props );
 804                 }
 805         };
 806
 807         $.fn.offset = function( options ) {
 808                 var elem = this[ 0 ];
 809                 if ( !elem || !elem.ownerDocument ) { return null; }
 810                 if ( options ) {
 811                         return this.each(function() {
 812                                 $.offset.setOffset( this, options );
 813                         });
 814                 }
 815                 return _offset.call( this );
 816         };
 817 }
 818
 819 }( jQuery ));
 820 /*
 821  * jQuery UI Draggable 1.8
 822  *
 823  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
 824  * Dual licensed under the MIT (MIT-LICENSE.txt)
 825  * and GPL (GPL-LICENSE.txt) licenses.
 826  *
 827  * http://docs.jquery.com/UI/Draggables
 828  *
 829  * Depends:
 830  *      jquery.ui.core.js
 831  *      jquery.ui.mouse.js
 832  *      jquery.ui.widget.js
 833  */
 834 (function($) {
 835
 836 $.widget("ui.draggable", $.ui.mouse, {
 837         widgetEventPrefix: "drag",
 838         options: {
 839                 addClasses: true,
 840                 appendTo: "parent",
 841                 axis: false,
 842                 connectToSortable: false,
 843                 containment: false,
 844                 cursor: "auto",
 845                 cursorAt: false,
 846                 grid: false,
 847                 handle: false,
 848                 helper: "original",
 849                 iframeFix: false,
 850                 opacity: false,
 851                 refreshPositions: false,
 852                 revert: false,
 853                 revertDuration: 500,
 854                 scope: "default",
 855                 scroll: true,
 856                 scrollSensitivity: 20,
 857                 scrollSpeed: 20,
 858                 snap: false,
 859                 snapMode: "both",
 860                 snapTolerance: 20,
 861                 stack: false,
 862                 zIndex: false
 863         },
 864         _create: function() {
 865
 866                 if (this.options.helper == 'original' && !(/^(?:r|a|f)/).test(this.element.css("position")))
 867                         this.element[0].style.position = 'relative';
 868
 869                 (this.options.addClasses && this.element.addClass("ui-draggable"));
 870                 (this.options.disabled && this.element.addClass("ui-draggable-disabled"));
 871
 872                 this._mouseInit();
 873
 874         },
 875
 876         destroy: function() {
 877                 if(!this.element.data('draggable')) return;
 878                 this.element
 879                         .removeData("draggable")
 880                         .unbind(".draggable")
 881                         .removeClass("ui-draggable"
 882                                 + " ui-draggable-dragging"
 883                                 + " ui-draggable-disabled");
 884                 this._mouseDestroy();
 885
 886                 return this;
 887         },
 888
 889         _mouseCapture: function(event) {
 890
 891                 var o = this.options;
 892
 893                 // among others, prevent a drag on a resizable-handle
 894                 if (this.helper || o.disabled || $(event.target).is('.ui-resizable-handle'))
 895                         return false;
 896
 897                 //Quit if we're not on a valid handle
 898                 this.handle = this._getHandle(event);
 899                 if (!this.handle)
 900                         return false;
 901
 902                 return true;
 903
 904         },
 905
 906         _mouseStart: function(event) {
 907
 908                 var o = this.options;
 909
 910                 //Create and append the visible helper
 911                 this.helper = this._createHelper(event);
 912
 913                 //Cache the helper size
 914                 this._cacheHelperProportions();
 915
 916                 //If ddmanager is used for droppables, set the global draggable
 917                 if($.ui.ddmanager)
 918                         $.ui.ddmanager.current = this;
 919
 920                 /*
 921                  * - Position generation -
 922                  * This block generates everything position related - it's the core of draggables.
 923                  */
 924
 925                 //Cache the margins of the original element
 926                 this._cacheMargins();
 927
 928                 //Store the helper's css position
 929                 this.cssPosition = this.helper.css("position");
 930                 this.scrollParent = this.helper.scrollParent();
 931
 932                 //The element's absolute position on the page minus margins
 933                 this.offset = this.positionAbs = this.element.offset();
 934                 this.offset = {
 935                         top: this.offset.top - this.margins.top,
 936                         left: this.offset.left - this.margins.left
 937                 };
 938
 939                 $.extend(this.offset, {
 940                         click: { //Where the click happened, relative to the element
 941                                 left: event.pageX - this.offset.left,
 942                                 top: event.pageY - this.offset.top
 943                         },
 944                         parent: this._getParentOffset(),
 945                         relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
 946                 });
 947
 948                 //Generate the original position
 949                 this.originalPosition = this.position = this._generatePosition(event);
 950                 this.originalPageX = event.pageX;
 951                 this.originalPageY = event.pageY;
 952
 953                 //Adjust the mouse offset relative to the helper if 'cursorAt' is supplied
 954                 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
 955
 956                 //Set a containment if given in the options
 957                 if(o.containment)
 958                         this._setContainment();
 959
 960                 //Trigger event + callbacks
 961                 if(this._trigger("start", event) === false) {
 962                         this._clear();
 963                         return false;
 964                 }
 965
 966                 //Recache the helper size
 967                 this._cacheHelperProportions();
 968
 969                 //Prepare the droppable offsets
 970                 if ($.ui.ddmanager && !o.dropBehaviour)
 971                         $.ui.ddmanager.prepareOffsets(this, event);
 972
 973                 this.helper.addClass("ui-draggable-dragging");
 974                 this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
 975                 return true;
 976         },
 977
 978         _mouseDrag: function(event, noPropagation) {
 979
 980                 //Compute the helpers position
 981                 this.position = this._generatePosition(event);
 982                 this.positionAbs = this._convertPositionTo("absolute");
 983
 984                 //Call plugins and callbacks and use the resulting position if something is returned
 985                 if (!noPropagation) {
 986                         var ui = this._uiHash();
 987                         if(this._trigger('drag', event, ui) === false) {
 988                                 this._mouseUp({});
 989                                 return false;
 990                         }
 991                         this.position = ui.position;
 992                 }
 993
 994                 if(!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left+'px';
 995                 if(!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top+'px';
 996                 if($.ui.ddmanager) $.ui.ddmanager.drag(this, event);
 997
 998                 return false;
 999         },
1000
1001         _mouseStop: function(event) {
1002
1003                 //If we are using droppables, inform the manager about the drop
1004                 var dropped = false;
1005                 if ($.ui.ddmanager && !this.options.dropBehaviour)
1006                         dropped = $.ui.ddmanager.drop(this, event);
1007
1008                 //if a drop comes from outside (a sortable)
1009                 if(this.dropped) {
1010                         dropped = this.dropped;
1011                         this.dropped = false;
1012                 }
1013
1014                 //if the original element is removed, don't bother to continue
1015                 if(!this.element[0] || !this.element[0].parentNode)
1016                         return false;
1017
1018                 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))) {
1019                         var self = this;
1020                         $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
1021                                 if(self._trigger("stop", event) !== false) {
1022                                         self._clear();
1023                                 }
1024                         });
1025                 } else {
1026                         if(this._trigger("stop", event) !== false) {
1027                                 this._clear();
1028                         }
1029                 }
1030
1031                 return false;
1032         },
1033
1034         cancel: function() {
1035
1036                 if(this.helper.is(".ui-draggable-dragging")) {
1037                         this._mouseUp({});
1038                 } else {
1039                         this._clear();
1040                 }
1041
1042                 return this;
1043
1044         },
1045
1046         _getHandle: function(event) {
1047
1048                 var handle = !this.options.handle || !$(this.options.handle, this.element).length ? true : false;
1049                 $(this.options.handle, this.element)
1050                         .find("*")
1051                         .andSelf()
1052                         .each(function() {
1053                                 if(this == event.target) handle = true;
1054                         });
1055
1056                 return handle;
1057
1058         },
1059
1060         _createHelper: function(event) {
1061
1062                 var o = this.options;
1063                 var helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper == 'clone' ? this.element.clone() : this.element);
1064
1065                 if(!helper.parents('body').length)
1066                         helper.appendTo((o.appendTo == 'parent' ? this.element[0].parentNode : o.appendTo));
1067
1068                 if(helper[0] != this.element[0] && !(/(fixed|absolute)/).test(helper.css("position")))
1069                         helper.css("position", "absolute");
1070
1071                 return helper;
1072
1073         },
1074
1075         _adjustOffsetFromHelper: function(obj) {
1076                 if (typeof obj == 'string') {
1077                         obj = obj.split(' ');
1078                 }
1079                 if ($.isArray(obj)) {
1080                         obj = {left: +obj[0], top: +obj[1] || 0};
1081                 }
1082                 if ('left' in obj) {
1083                         this.offset.click.left = obj.left + this.margins.left;
1084                 }
1085                 if ('right' in obj) {
1086                         this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
1087                 }
1088                 if ('top' in obj) {
1089                         this.offset.click.top = obj.top + this.margins.top;
1090                 }
1091                 if ('bottom' in obj) {
1092                         this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
1093                 }
1094         },
1095
1096         _getParentOffset: function() {
1097
1098                 //Get the offsetParent and cache its position
1099                 this.offsetParent = this.helper.offsetParent();
1100                 var po = this.offsetParent.offset();
1101
1102                 // This is a special case where we need to modify a offset calculated on start, since the following happened:
1103                 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
1104                 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
1105                 //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
1106                 if(this.cssPosition == 'absolute' && this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) {
1107                         po.left += this.scrollParent.scrollLeft();
1108                         po.top += this.scrollParent.scrollTop();
1109                 }
1110
1111                 if((this.offsetParent[0] == document.body) //This needs to be actually done for all browsers, since pageX/pageY includes this information
1112                 || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.browser.msie)) //Ugly IE fix
1113                         po = { top: 0, left: 0 };
1114
1115                 return {
1116                         top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
1117                         left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
1118                 };
1119
1120         },
1121
1122         _getRelativeOffset: function() {
1123
1124                 if(this.cssPosition == "relative") {
1125                         var p = this.element.position();
1126                         return {
1127                                 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
1128                                 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
1129                         };
1130                 } else {
1131                         return { top: 0, left: 0 };
1132                 }
1133
1134         },
1135
1136         _cacheMargins: function() {
1137                 this.margins = {
1138                         left: (parseInt(this.element.css("marginLeft"),10) || 0),
1139                         top: (parseInt(this.element.css("marginTop"),10) || 0)
1140                 };
1141         },
1142
1143         _cacheHelperProportions: function() {
1144                 this.helperProportions = {
1145                         width: this.helper.outerWidth(),
1146                         height: this.helper.outerHeight()
1147                 };
1148         },
1149
1150         _setContainment: function() {
1151
1152                 var o = this.options;
1153                 if(o.containment == 'parent') o.containment = this.helper[0].parentNode;
1154                 if(o.containment == 'document' || o.containment == 'window') this.containment = [
1155                         0 - this.offset.relative.left - this.offset.parent.left,
1156                         0 - this.offset.relative.top - this.offset.parent.top,
1157                         $(o.containment == 'document' ? document : window).width() - this.helperProportions.width - this.margins.left,
1158                         ($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
1159                 ];
1160
1161                 if(!(/^(document|window|parent)$/).test(o.containment) && o.containment.constructor != Array) {
1162                         var ce = $(o.containment)[0]; if(!ce) return;
1163                         var co = $(o.containment).offset();
1164                         var over = ($(ce).css("overflow") != 'hidden');
1165
1166                         this.containment = [
1167                                 co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
1168                                 co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
1169                                 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,
1170                                 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
1171                         ];
1172                 } else if(o.containment.constructor == Array) {
1173                         this.containment = o.containment;
1174                 }
1175
1176         },
1177
1178         _convertPositionTo: function(d, pos) {
1179
1180                 if(!pos) pos = this.position;
1181                 var mod = d == "absolute" ? 1 : -1;
1182                 var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
1183
1184                 return {
1185                         top: (
1186                                 pos.top                                                                                                                                 // The absolute mouse position
1187                                 + this.offset.relative.top * mod                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
1188                                 + this.offset.parent.top * mod                                                                                  // The offsetParent's offset without borders (offset + border)
1189                                 - ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
1190                         ),
1191                         left: (
1192                                 pos.left                                                                                                                                // The absolute mouse position
1193                                 + this.offset.relative.left * mod                                                                               // Only for relative positioned nodes: Relative offset from element to offset parent
1194                                 + this.offset.parent.left * mod                                                                                 // The offsetParent's offset without borders (offset + border)
1195                                 - ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
1196                         )
1197                 };
1198
1199         },
1200
1201         _generatePosition: function(event) {
1202
1203                 var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
1204                 var pageX = event.pageX;
1205                 var pageY = event.pageY;
1206
1207                 /*
1208                  * - Position constraining -
1209                  * Constrain the position to a mix of grid, containment.
1210                  */
1211
1212                 if(this.originalPosition) { //If we are not dragging yet, we won't check for options
1213
1214                         if(this.containment) {
1215                                 if(event.pageX - this.offset.click.left < this.containment[0]) pageX = this.containment[0] + this.offset.click.left;
1216                                 if(event.pageY - this.offset.click.top < this.containment[1]) pageY = this.containment[1] + this.offset.click.top;
1217                                 if(event.pageX - this.offset.click.left > this.containment[2]) pageX = this.containment[2] + this.offset.click.left;
1218                                 if(event.pageY - this.offset.click.top > this.containment[3]) pageY = this.containment[3] + this.offset.click.top;
1219                         }
1220
1221                         if(o.grid) {
1222                                 var top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
1223                                 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;
1224
1225                                 var left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
1226                                 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;
1227                         }
1228
1229                 }
1230
1231                 return {
1232                         top: (
1233                                 pageY                                                                                                                           // The absolute mouse position
1234                                 - this.offset.click.top                                                                                                 // Click offset (relative to the element)
1235                                 - this.offset.relative.top                                                                                              // Only for relative positioned nodes: Relative offset from element to offset parent
1236                                 - this.offset.parent.top                                                                                                // The offsetParent's offset without borders (offset + border)
1237                                 + ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
1238                         ),
1239                         left: (
1240                                 pageX                                                                                                                           // The absolute mouse position
1241                                 - this.offset.click.left                                                                                                // Click offset (relative to the element)
1242                                 - this.offset.relative.left                                                                                             // Only for relative positioned nodes: Relative offset from element to offset parent
1243                                 - this.offset.parent.left                                                                                               // The offsetParent's offset without borders (offset + border)
1244                                 + ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
1245                         )
1246                 };
1247
1248         },
1249
1250         _clear: function() {
1251                 this.helper.removeClass("ui-draggable-dragging");
1252                 if(this.helper[0] != this.element[0] && !this.cancelHelperRemoval) this.helper.remove();
1253                 //if($.ui.ddmanager) $.ui.ddmanager.current = null;
1254                 this.helper = null;
1255                 this.cancelHelperRemoval = false;
1256         },
1257
1258         // From now on bulk stuff - mainly helpers
1259
1260         _trigger: function(type, event, ui) {
1261                 ui = ui || this._uiHash();
1262                 $.ui.plugin.call(this, type, [event, ui]);
1263                 if(type == "drag") this.positionAbs = this._convertPositionTo("absolute"); //The absolute position has to be recalculated after plugins
1264                 return $.Widget.prototype._trigger.call(this, type, event, ui);
1265         },
1266
1267         plugins: {},
1268
1269         _uiHash: function(event) {
1270                 return {
1271                         helper: this.helper,
1272                         position: this.position,
1273                         originalPosition: this.originalPosition,
1274                         offset: this.positionAbs
1275                 };
1276         }
1277
1278 });
1279
1280 $.extend($.ui.draggable, {
1281         version: "1.8"
1282 });
1283
1284 $.ui.plugin.add("draggable", "connectToSortable", {
1285         start: function(event, ui) {
1286
1287                 var inst = $(this).data("draggable"), o = inst.options,
1288                         uiSortable = $.extend({}, ui, { item: inst.element });
1289                 inst.sortables = [];
1290                 $(o.connectToSortable).each(function() {
1291                         var sortable = $.data(this, 'sortable');
1292                         if (sortable && !sortable.options.disabled) {
1293                                 inst.sortables.push({
1294                                         instance: sortable,
1295                                         shouldRevert: sortable.options.revert
1296                                 });
1297                                 sortable._refreshItems();       //Do a one-time refresh at start to refresh the containerCache
1298                                 sortable._trigger("activate", event, uiSortable);
1299                         }
1300                 });
1301
1302         },
1303         stop: function(event, ui) {
1304
1305                 //If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
1306                 var inst = $(this).data("draggable"),
1307                         uiSortable = $.extend({}, ui, { item: inst.element });
1308
1309                 $.each(inst.sortables, function() {
1310                         if(this.instance.isOver) {
1311
1312                                 this.instance.isOver = 0;
1313
1314                                 inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
1315                                 this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
1316
1317                                 //The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: 'valid/invalid'
1318                                 if(this.shouldRevert) this.instance.options.revert = true;
1319
1320                                 //Trigger the stop of the sortable
1321                                 this.instance._mouseStop(event);
1322
1323                                 this.instance.options.helper = this.instance.options._helper;
1324
1325                                 //If the helper has been the original item, restore properties in the sortable
1326                                 if(inst.options.helper == 'original')
1327                                         this.instance.currentItem.css({ top: 'auto', left: 'auto' });
1328
1329                         } else {
1330                                 this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
1331                                 this.instance._trigger("deactivate", event, uiSortable);
1332                         }
1333
1334                 });
1335
1336         },
1337         drag: function(event, ui) {
1338
1339                 var inst = $(this).data("draggable"), self = this;
1340
1341                 var checkPos = function(o) {
1342                         var dyClick = this.offset.click.top, dxClick = this.offset.click.left;
1343                         var helperTop = this.positionAbs.top, helperLeft = this.positionAbs.left;
1344                         var itemHeight = o.height, itemWidth = o.width;
1345                         var itemTop = o.top, itemLeft = o.left;
1346
1347                         return $.ui.isOver(helperTop + dyClick, helperLeft + dxClick, itemTop, itemLeft, itemHeight, itemWidth);
1348                 };
1349
1350                 $.each(inst.sortables, function(i) {
1351
1352                         //Copy over some variables to allow calling the sortable's native _intersectsWith
1353                         this.instance.positionAbs = inst.positionAbs;
1354                         this.instance.helperProportions = inst.helperProportions;
1355                         this.instance.offset.click = inst.offset.click;
1356
1357                         if(this.instance._intersectsWith(this.instance.containerCache)) {
1358
1359                                 //If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
1360                                 if(!this.instance.isOver) {
1361
1362                                         this.instance.isOver = 1;
1363                                         //Now we fake the start of dragging for the sortable instance,
1364                                         //by cloning the list group item, appending it to the sortable and using it as inst.currentItem
1365                                         //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)
1366                                         this.instance.currentItem = $(self).clone().appendTo(this.instance.element).data("sortable-item", true);
1367                                         this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
1368                                         this.instance.options.helper = function() { return ui.helper[0]; };
1369
1370                                         event.target = this.instance.currentItem[0];
1371                                         this.instance._mouseCapture(event, true);
1372                                         this.instance._mouseStart(event, true, true);
1373
1374                                         //Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
1375                                         this.instance.offset.click.top = inst.offset.click.top;
1376                                         this.instance.offset.click.left = inst.offset.click.left;
1377                                         this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
1378                                         this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
1379
1380                                         inst._trigger("toSortable", event);
1381                                         inst.dropped = this.instance.element; //draggable revert needs that
1382                                         //hack so receive/update callbacks work (mostly)
1383                                         inst.currentItem = inst.element;
1384                                         this.instance.fromOutside = inst;
1385
1386                                 }
1387
1388                                 //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
1389                                 if(this.instance.currentItem) this.instance._mouseDrag(event);
1390
1391                         } else {
1392
1393                                 //If it doesn't intersect with the sortable, and it intersected before,
1394                                 //we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
1395                                 if(this.instance.isOver) {
1396
1397                                         this.instance.isOver = 0;
1398                                         this.instance.cancelHelperRemoval = true;
1399
1400                                         //Prevent reverting on this forced stop
1401                                         this.instance.options.revert = false;
1402
1403                                         // The out event needs to be triggered independently
1404                                         this.instance._trigger('out', event, this.instance._uiHash(this.instance));
1405
1406                                         this.instance._mouseStop(event, true);
1407                                         this.instance.options.helper = this.instance.options._helper;
1408
1409                                         //Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
1410                                         this.instance.currentItem.remove();
1411                                         if(this.instance.placeholder) this.instance.placeholder.remove();
1412
1413                                         inst._trigger("fromSortable", event);
1414                                         inst.dropped = false; //draggable revert needs that
1415                                 }
1416
1417                         };
1418
1419                 });
1420
1421         }
1422 });
1423
1424 $.ui.plugin.add("draggable", "cursor", {
1425         start: function(event, ui) {
1426                 var t = $('body'), o = $(this).data('draggable').options;
1427                 if (t.css("cursor")) o._cursor = t.css("cursor");
1428                 t.css("cursor", o.cursor);
1429         },
1430         stop: function(event, ui) {
1431                 var o = $(this).data('draggable').options;
1432                 if (o._cursor) $('body').css("cursor", o._cursor);
1433         }
1434 });
1435
1436 $.ui.plugin.add("draggable", "iframeFix", {
1437         start: function(event, ui) {
1438                 var o = $(this).data('draggable').options;
1439                 $(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {
1440                         $('<div class="ui-draggable-iframeFix" style="background: #fff;"></div>')
1441                         .css({
1442                                 width: this.offsetWidth+"px", height: this.offsetHeight+"px",
1443                                 position: "absolute", opacity: "0.001", zIndex: 1000
1444                         })
1445                         .css($(this).offset())
1446                         .appendTo("body");
1447                 });
1448         },
1449         stop: function(event, ui) {
1450                 $("div.ui-draggable-iframeFix").each(function() { this.parentNode.removeChild(this); }); //Remove frame helpers
1451         }
1452 });
1453
1454 $.ui.plugin.add("draggable", "opacity", {
1455         start: function(event, ui) {
1456                 var t = $(ui.helper), o = $(this).data('draggable').options;
1457                 if(t.css("opacity")) o._opacity = t.css("opacity");
1458                 t.css('opacity', o.opacity);
1459         },
1460         stop: function(event, ui) {
1461                 var o = $(this).data('draggable').options;
1462                 if(o._opacity) $(ui.helper).css('opacity', o._opacity);
1463         }
1464 });
1465
1466 $.ui.plugin.add("draggable", "scroll", {
1467         start: function(event, ui) {
1468                 var i = $(this).data("draggable");
1469                 if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') i.overflowOffset = i.scrollParent.offset();
1470         },
1471         drag: function(event, ui) {
1472
1473                 var i = $(this).data("draggable"), o = i.options, scrolled = false;
1474
1475                 if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') {
1476
1477                         if(!o.axis || o.axis != 'x') {
1478                                 if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity)
1479                                         i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
1480                                 else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity)
1481                                         i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
1482                         }
1483
1484                         if(!o.axis || o.axis != 'y') {
1485                                 if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity)
1486                                         i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
1487                                 else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity)
1488                                         i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
1489                         }
1490
1491                 } else {
1492
1493                         if(!o.axis || o.axis != 'x') {
1494                                 if(event.pageY - $(document).scrollTop() < o.scrollSensitivity)
1495                                         scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
1496                                 else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity)
1497                                         scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
1498                         }
1499
1500                         if(!o.axis || o.axis != 'y') {
1501                                 if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity)
1502                                         scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
1503                                 else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
1504                                         scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
1505                         }
1506
1507                 }
1508
1509                 if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour)
1510                         $.ui.ddmanager.prepareOffsets(i, event);
1511
1512         }
1513 });
1514
1515 $.ui.plugin.add("draggable", "snap", {
1516         start: function(event, ui) {
1517
1518                 var i = $(this).data("draggable"), o = i.options;
1519                 i.snapElements = [];
1520
1521                 $(o.snap.constructor != String ? ( o.snap.items || ':data(draggable)' ) : o.snap).each(function() {
1522                         var $t = $(this); var $o = $t.offset();
1523                         if(this != i.element[0]) i.snapElements.push({
1524                                 item: this,
1525                                 width: $t.outerWidth(), height: $t.outerHeight(),
1526                                 top: $o.top, left: $o.left
1527                         });
1528                 });
1529
1530         },
1531         drag: function(event, ui) {
1532
1533                 var inst = $(this).data("draggable"), o = inst.options;
1534                 var d = o.snapTolerance;
1535
1536                 var x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
1537                         y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
1538
1539                 for (var i = inst.snapElements.length - 1; i >= 0; i--){
1540
1541                         var l = inst.snapElements[i].left, r = l + inst.snapElements[i].width,
1542                                 t = inst.snapElements[i].top, b = t + inst.snapElements[i].height;
1543
1544                         //Yes, I know, this is insane ;)
1545                         if(!((l-d < x1 && x1 < r+d && t-d < y1 && y1 < b+d) || (l-d < x1 && x1 < r+d && t-d < y2 && y2 < b+d) || (l-d < x2 && x2 < r+d && t-d < y1 && y1 < b+d) || (l-d < x2 && x2 < r+d && t-d < y2 && y2 < b+d))) {
1546                                 if(inst.snapElements[i].snapping) (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1547                                 inst.snapElements[i].snapping = false;
1548                                 continue;
1549                         }
1550
1551                         if(o.snapMode != 'inner') {
1552                                 var ts = Math.abs(t - y2) <= d;
1553                                 var bs = Math.abs(b - y1) <= d;
1554                                 var ls = Math.abs(l - x2) <= d;
1555                                 var rs = Math.abs(r - x1) <= d;
1556                                 if(ts) ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1557                                 if(bs) ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
1558                                 if(ls) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
1559                                 if(rs) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
1560                         }
1561
1562                         var first = (ts || bs || ls || rs);
1563
1564                         if(o.snapMode != 'outer') {
1565                                 var ts = Math.abs(t - y1) <= d;
1566                                 var bs = Math.abs(b - y2) <= d;
1567                                 var ls = Math.abs(l - x1) <= d;
1568                                 var rs = Math.abs(r - x2) <= d;
1569                                 if(ts) ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
1570                                 if(bs) ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1571                                 if(ls) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
1572                                 if(rs) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
1573                         }
1574
1575                         if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first))
1576                                 (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1577                         inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
1578
1579                 };
1580
1581         }
1582 });
1583
1584 $.ui.plugin.add("draggable", "stack", {
1585         start: function(event, ui) {
1586
1587                 var o = $(this).data("draggable").options;
1588
1589                 var group = $.makeArray($(o.stack)).sort(function(a,b) {
1590                         return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
1591                 });
1592                 if (!group.length) { return; }
1593
1594                 var min = parseInt(group[0].style.zIndex) || 0;
1595                 $(group).each(function(i) {
1596                         this.style.zIndex = min + i;
1597                 });
1598
1599                 this[0].style.zIndex = min + group.length;
1600
1601         }
1602 });
1603
1604 $.ui.plugin.add("draggable", "zIndex", {
1605         start: function(event, ui) {
1606                 var t = $(ui.helper), o = $(this).data("draggable").options;
1607                 if(t.css("zIndex")) o._zIndex = t.css("zIndex");
1608                 t.css('zIndex', o.zIndex);
1609         },
1610         stop: function(event, ui) {
1611                 var o = $(this).data("draggable").options;
1612                 if(o._zIndex) $(ui.helper).css('zIndex', o._zIndex);
1613         }
1614 });
1615
1616 })(jQuery);
1617 /*
1618  * jQuery UI Droppable 1.8
1619  *
1620  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
1621  * Dual licensed under the MIT (MIT-LICENSE.txt)
1622  * and GPL (GPL-LICENSE.txt) licenses.
1623  *
1624  * http://docs.jquery.com/UI/Droppables
1625  *
1626  * Depends:
1627  *      jquery.ui.core.js
1628  *      jquery.ui.widget.js
1629  *      jquery.ui.mouse.js
1630  *      jquery.ui.draggable.js
1631  */
1632 (function($) {
1633
1634 $.widget("ui.droppable", {
1635         widgetEventPrefix: "drop",
1636         options: {
1637                 accept: '*',
1638                 activeClass: false,
1639                 addClasses: true,
1640                 greedy: false,
1641                 hoverClass: false,
1642                 scope: 'default',
1643                 tolerance: 'intersect'
1644         },
1645         _create: function() {
1646
1647                 var o = this.options, accept = o.accept;
1648                 this.isover = 0; this.isout = 1;
1649
1650                 this.accept = $.isFunction(accept) ? accept : function(d) {
1651                         return d.is(accept);
1652                 };
1653
1654                 //Store the droppable's proportions
1655                 this.proportions = { width: this.element[0].offsetWidth, height: this.element[0].offsetHeight };
1656
1657                 // Add the reference and positions to the manager
1658                 $.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
1659                 $.ui.ddmanager.droppables[o.scope].push(this);
1660
1661                 (o.addClasses && this.element.addClass("ui-droppable"));
1662
1663         },
1664
1665         destroy: function() {
1666                 var drop = $.ui.ddmanager.droppables[this.options.scope];
1667                 for ( var i = 0; i < drop.length; i++ )
1668                         if ( drop[i] == this )
1669                                 drop.splice(i, 1);
1670
1671                 this.element
1672                         .removeClass("ui-droppable ui-droppable-disabled")
1673                         .removeData("droppable")
1674                         .unbind(".droppable");
1675
1676                 return this;
1677         },
1678
1679         _setOption: function(key, value) {
1680
1681                 if(key == 'accept') {
1682                         this.accept = $.isFunction(value) ? value : function(d) {
1683                                 return d.is(value);
1684                         };
1685                 }
1686                 $.Widget.prototype._setOption.apply(this, arguments);
1687         },
1688
1689         _activate: function(event) {
1690                 var draggable = $.ui.ddmanager.current;
1691                 if(this.options.activeClass) this.element.addClass(this.options.activeClass);
1692                 (draggable && this._trigger('activate', event, this.ui(draggable)));
1693         },
1694
1695         _deactivate: function(event) {
1696                 var draggable = $.ui.ddmanager.current;
1697                 if(this.options.activeClass) this.element.removeClass(this.options.activeClass);
1698                 (draggable && this._trigger('deactivate', event, this.ui(draggable)));
1699         },
1700
1701         _over: function(event) {
1702
1703                 var draggable = $.ui.ddmanager.current;
1704                 if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element
1705
1706                 if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
1707                         if(this.options.hoverClass) this.element.addClass(this.options.hoverClass);
1708                         this._trigger('over', event, this.ui(draggable));
1709                 }
1710
1711         },
1712
1713         _out: function(event) {
1714
1715                 var draggable = $.ui.ddmanager.current;
1716                 if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element
1717
1718                 if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
1719                         if(this.options.hoverClass) this.element.removeClass(this.options.hoverClass);
1720                         this._trigger('out', event, this.ui(draggable));
1721                 }
1722
1723         },
1724
1725         _drop: function(event,custom) {
1726
1727                 var draggable = custom || $.ui.ddmanager.current;
1728                 if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return false; // Bail if draggable and droppable are same element
1729
1730                 var childrenIntersection = false;
1731                 this.element.find(":data(droppable)").not(".ui-draggable-dragging").each(function() {
1732                         var inst = $.data(this, 'droppable');
1733                         if(
1734                                 inst.options.greedy
1735                                 && !inst.options.disabled
1736                                 && inst.options.scope == draggable.options.scope
1737                                 && inst.accept.call(inst.element[0], (draggable.currentItem || draggable.element))
1738                                 && $.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
1739                         ) { childrenIntersection = true; return false; }
1740                 });
1741                 if(childrenIntersection) return false;
1742
1743                 if(this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
1744                         if(this.options.activeClass) this.element.removeClass(this.options.activeClass);
1745                         if(this.options.hoverClass) this.element.removeClass(this.options.hoverClass);
1746                         this._trigger('drop', event, this.ui(draggable));
1747                         return this.element;
1748                 }
1749
1750                 return false;
1751
1752         },
1753
1754         ui: function(c) {
1755                 return {
1756                         draggable: (c.currentItem || c.element),
1757                         helper: c.helper,
1758                         position: c.position,
1759                         offset: c.positionAbs
1760                 };
1761         }
1762
1763 });
1764
1765 $.extend($.ui.droppable, {
1766         version: "1.8"
1767 });
1768
1769 $.ui.intersect = function(draggable, droppable, toleranceMode) {
1770
1771         if (!droppable.offset) return false;
1772
1773         var x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
1774                 y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height;
1775         var l = droppable.offset.left, r = l + droppable.proportions.width,
1776                 t = droppable.offset.top, b = t + droppable.proportions.height;
1777
1778         switch (toleranceMode) {
1779                 case 'fit':
1780                         return (l < x1 && x2 < r
1781                                 && t < y1 && y2 < b);
1782                         break;
1783                 case 'intersect':
1784                         return (l < x1 + (draggable.helperProportions.width / 2) // Right Half
1785                                 && x2 - (draggable.helperProportions.width / 2) < r // Left Half
1786                                 && t < y1 + (draggable.helperProportions.height / 2) // Bottom Half
1787                                 && y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
1788                         break;
1789                 case 'pointer':
1790                         var draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left),
1791                                 draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top),
1792                                 isOver = $.ui.isOver(draggableTop, draggableLeft, t, l, droppable.proportions.height, droppable.proportions.width);
1793                         return isOver;
1794                         break;
1795                 case 'touch':
1796                         return (
1797                                         (y1 >= t && y1 <= b) || // Top edge touching
1798                                         (y2 >= t && y2 <= b) || // Bottom edge touching
1799                                         (y1 < t && y2 > b)              // Surrounded vertically
1800                                 ) && (
1801                                         (x1 >= l && x1 <= r) || // Left edge touching
1802                                         (x2 >= l && x2 <= r) || // Right edge touching
1803                                         (x1 < l && x2 > r)              // Surrounded horizontally
1804                                 );
1805                         break;
1806                 default:
1807                         return false;
1808                         break;
1809                 }
1810
1811 };
1812
1813 /*
1814         This manager tracks offsets of draggables and droppables
1815 */
1816 $.ui.ddmanager = {
1817         current: null,
1818         droppables: { 'default': [] },
1819         prepareOffsets: function(t, event) {
1820
1821                 var m = $.ui.ddmanager.droppables[t.options.scope] || [];
1822                 var type = event ? event.type : null; // workaround for #2317
1823                 var list = (t.currentItem || t.element).find(":data(droppable)").andSelf();
1824
1825                 droppablesLoop: for (var i = 0; i < m.length; i++) {
1826
1827                         if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) continue;   //No disabled and non-accepted
1828                         for (var j=0; j < list.length; j++) { if(list[j] == m[i].element[0]) { m[i].proportions.height = 0; continue droppablesLoop; } }; //Filter out elements in the current dragged item
1829                         m[i].visible = m[i].element.css("display") != "none"; if(!m[i].visible) continue;                                                                       //If the element is not visible, continue
1830
1831                         m[i].offset = m[i].element.offset();
1832                         m[i].proportions = { width: m[i].element[0].offsetWidth, height: m[i].element[0].offsetHeight };
1833
1834                         if(type == "mousedown") m[i]._activate.call(m[i], event); //Activate the droppable if used directly from draggables
1835
1836                 }
1837
1838         },
1839         drop: function(draggable, event) {
1840
1841                 var dropped = false;
1842                 $.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
1843
1844                         if(!this.options) return;
1845                         if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance))
1846                                 dropped = dropped || this._drop.call(this, event);
1847
1848                         if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
1849                                 this.isout = 1; this.isover = 0;
1850                                 this._deactivate.call(this, event);
1851                         }
1852
1853                 });
1854                 return dropped;
1855
1856         },
1857         drag: function(draggable, event) {
1858
1859                 //If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
1860                 if(draggable.options.refreshPositions) $.ui.ddmanager.prepareOffsets(draggable, event);
1861
1862                 //Run through all droppables and check their positions based on specific tolerance options
1863                 $.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
1864
1865                         if(this.options.disabled || this.greedyChild || !this.visible) return;
1866                         var intersects = $.ui.intersect(draggable, this, this.options.tolerance);
1867
1868                         var c = !intersects && this.isover == 1 ? 'isout' : (intersects && this.isover == 0 ? 'isover' : null);
1869                         if(!c) return;
1870
1871                         var parentInstance;
1872                         if (this.options.greedy) {
1873                                 var parent = this.element.parents(':data(droppable):eq(0)');
1874                                 if (parent.length) {
1875                                         parentInstance = $.data(parent[0], 'droppable');
1876                                         parentInstance.greedyChild = (c == 'isover' ? 1 : 0);
1877                                 }
1878                         }
1879
1880                         // we just moved into a greedy child
1881                         if (parentInstance && c == 'isover') {
1882                                 parentInstance['isover'] = 0;
1883                                 parentInstance['isout'] = 1;
1884                                 parentInstance._out.call(parentInstance, event);
1885                         }
1886
1887                         this[c] = 1; this[c == 'isout' ? 'isover' : 'isout'] = 0;
1888                         this[c == "isover" ? "_over" : "_out"].call(this, event);
1889
1890                         // we just moved out of a greedy child
1891                         if (parentInstance && c == 'isout') {
1892                                 parentInstance['isout'] = 0;
1893                                 parentInstance['isover'] = 1;
1894                                 parentInstance._over.call(parentInstance, event);
1895                         }
1896                 });
1897
1898         }
1899 };
1900
1901 })(jQuery);
1902 /*
1903  * jQuery UI Resizable 1.8
1904  *
1905  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
1906  * Dual licensed under the MIT (MIT-LICENSE.txt)
1907  * and GPL (GPL-LICENSE.txt) licenses.
1908  *
1909  * http://docs.jquery.com/UI/Resizables
1910  *
1911  * Depends:
1912  *      jquery.ui.core.js
1913  *      jquery.ui.mouse.js
1914  *      jquery.ui.widget.js
1915  */
1916 (function($) {
1917
1918 $.widget("ui.resizable", $.ui.mouse, {
1919         widgetEventPrefix: "resize",
1920         options: {
1921                 alsoResize: false,
1922                 animate: false,
1923                 animateDuration: "slow",
1924                 animateEasing: "swing",
1925                 aspectRatio: false,
1926                 autoHide: false,
1927                 containment: false,
1928                 ghost: false,
1929                 grid: false,
1930                 handles: "e,s,se",
1931                 helper: false,
1932                 maxHeight: null,
1933                 maxWidth: null,
1934                 minHeight: 10,
1935                 minWidth: 10,
1936                 zIndex: 1000
1937         },
1938         _create: function() {
1939
1940                 var self = this, o = this.options;
1941                 this.element.addClass("ui-resizable");
1942
1943                 $.extend(this, {
1944                         _aspectRatio: !!(o.aspectRatio),
1945                         aspectRatio: o.aspectRatio,
1946                         originalElement: this.element,
1947                         _proportionallyResizeElements: [],
1948                         _helper: o.helper || o.ghost || o.animate ? o.helper || 'ui-resizable-helper' : null
1949                 });
1950
1951                 //Wrap the element if it cannot hold child nodes
1952                 if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {
1953
1954                         //Opera fix for relative positioning
1955                         if (/relative/.test(this.element.css('position')) && $.browser.opera)
1956                                 this.element.css({ position: 'relative', top: 'auto', left: 'auto' });
1957
1958                         //Create a wrapper element and set the wrapper to the new current internal element
1959                         this.element.wrap(
1960                                 $('<div class="ui-wrapper" style="overflow: hidden;"></div>').css({
1961                                         position: this.element.css('position'),
1962                                         width: this.element.outerWidth(),
1963                                         height: this.element.outerHeight(),
1964                                         top: this.element.css('top'),
1965                                         left: this.element.css('left')
1966                                 })
1967                         );
1968
1969                         //Overwrite the original this.element
1970                         this.element = this.element.parent().data(
1971                                 "resizable", this.element.data('resizable')
1972                         );
1973
1974                         this.elementIsWrapper = true;
1975
1976                         //Move margins to the wrapper
1977                         this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
1978                         this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
1979
1980                         //Prevent Safari textarea resize
1981                         this.originalResizeStyle = this.originalElement.css('resize');
1982                         this.originalElement.css('resize', 'none');
1983
1984                         //Push the actual element to our proportionallyResize internal array
1985                         this._proportionallyResizeElements.push(this.originalElement.css({ position: 'static', zoom: 1, display: 'block' }));
1986
1987                         // avoid IE jump (hard set the margin)
1988                         this.originalElement.css({ margin: this.originalElement.css('margin') });
1989
1990                         // fix handlers offset
1991                         this._proportionallyResize();
1992
1993                 }
1994
1995                 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' });
1996                 if(this.handles.constructor == String) {
1997
1998                         if(this.handles == 'all') this.handles = 'n,e,s,w,se,sw,ne,nw';
1999                         var n = this.handles.split(","); this.handles = {};
2000
2001                         for(var i = 0; i < n.length; i++) {
2002
2003                                 var handle = $.trim(n[i]), hname = 'ui-resizable-'+handle;
2004                                 var axis = $('<div class="ui-resizable-handle ' + hname + '"></div>');
2005
2006                                 // increase zIndex of sw, se, ne, nw axis
2007                                 //TODO : this modifies original option
2008                                 if(/sw|se|ne|nw/.test(handle)) axis.css({ zIndex: ++o.zIndex });
2009
2010                                 //TODO : What's going on here?
2011                                 if ('se' == handle) {
2012                                         axis.addClass('ui-icon ui-icon-gripsmall-diagonal-se');
2013                                 };
2014
2015                                 //Insert into internal handles object and append to element
2016                                 this.handles[handle] = '.ui-resizable-'+handle;
2017                                 this.element.append(axis);
2018                         }
2019
2020                 }
2021
2022                 this._renderAxis = function(target) {
2023
2024                         target = target || this.element;
2025
2026                         for(var i in this.handles) {
2027
2028                                 if(this.handles[i].constructor == String)
2029                                         this.handles[i] = $(this.handles[i], this.element).show();
2030
2031                                 //Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
2032                                 if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {
2033
2034                                         var axis = $(this.handles[i], this.element), padWrapper = 0;
2035
2036                                         //Checking the correct pad and border
2037                                         padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
2038
2039                                         //The padding type i have to apply...
2040                                         var padPos = [ 'padding',
2041                                                 /ne|nw|n/.test(i) ? 'Top' :
2042                                                 /se|sw|s/.test(i) ? 'Bottom' :
2043                                                 /^e$/.test(i) ? 'Right' : 'Left' ].join("");
2044
2045                                         target.css(padPos, padWrapper);
2046
2047                                         this._proportionallyResize();
2048
2049                                 }
2050
2051                                 //TODO: What's that good for? There's not anything to be executed left
2052                                 if(!$(this.handles[i]).length)
2053                                         continue;
2054
2055                         }
2056                 };
2057
2058                 //TODO: make renderAxis a prototype function
2059                 this._renderAxis(this.element);
2060
2061                 this._handles = $('.ui-resizable-handle', this.element)
2062                         .disableSelection();
2063
2064                 //Matching axis name
2065                 this._handles.mouseover(function() {
2066                         if (!self.resizing) {
2067                                 if (this.className)
2068                                         var axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
2069                                 //Axis, default = se
2070                                 self.axis = axis && axis[1] ? axis[1] : 'se';
2071                         }
2072                 });
2073
2074                 //If we want to auto hide the elements
2075                 if (o.autoHide) {
2076                         this._handles.hide();
2077                         $(this.element)
2078                                 .addClass("ui-resizable-autohide")
2079                                 .hover(function() {
2080                                         $(this).removeClass("ui-resizable-autohide");
2081                                         self._handles.show();
2082                                 },
2083                                 function(){
2084                                         if (!self.resizing) {
2085                                                 $(this).addClass("ui-resizable-autohide");
2086                                                 self._handles.hide();
2087                                         }
2088                                 });
2089                 }
2090
2091                 //Initialize the mouse interaction
2092                 this._mouseInit();
2093
2094         },
2095
2096         destroy: function() {
2097
2098                 this._mouseDestroy();
2099
2100                 var _destroy = function(exp) {
2101                         $(exp).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
2102                                 .removeData("resizable").unbind(".resizable").find('.ui-resizable-handle').remove();
2103                 };
2104
2105                 //TODO: Unwrap at same DOM position
2106                 if (this.elementIsWrapper) {
2107                         _destroy(this.element);
2108                         var wrapper = this.element;
2109                         wrapper.after(
2110                                 this.originalElement.css({
2111                                         position: wrapper.css('position'),
2112                                         width: wrapper.outerWidth(),
2113                                         height: wrapper.outerHeight(),
2114                                         top: wrapper.css('top'),
2115                                         left: wrapper.css('left')
2116                                 })
2117                         ).remove();
2118                 }
2119
2120                 this.originalElement.css('resize', this.originalResizeStyle);
2121                 _destroy(this.originalElement);
2122
2123                 return this;
2124         },
2125
2126         _mouseCapture: function(event) {
2127                 var handle = false;
2128                 for (var i in this.handles) {
2129                         if ($(this.handles[i])[0] == event.target) {
2130                                 handle = true;
2131                         }
2132                 }
2133
2134                 return !this.options.disabled && handle;
2135         },
2136
2137         _mouseStart: function(event) {
2138
2139                 var o = this.options, iniPos = this.element.position(), el = this.element;
2140
2141                 this.resizing = true;
2142                 this.documentScroll = { top: $(document).scrollTop(), left: $(document).scrollLeft() };
2143
2144                 // bugfix for http://dev.jquery.com/ticket/1749
2145                 if (el.is('.ui-draggable') || (/absolute/).test(el.css('position'))) {
2146                         el.css({ position: 'absolute', top: iniPos.top, left: iniPos.left });
2147                 }
2148
2149                 //Opera fixing relative position
2150                 if ($.browser.opera && (/relative/).test(el.css('position')))
2151                         el.css({ position: 'relative', top: 'auto', left: 'auto' });
2152
2153                 this._renderProxy();
2154
2155                 var curleft = num(this.helper.css('left')), curtop = num(this.helper.css('top'));
2156
2157                 if (o.containment) {
2158                         curleft += $(o.containment).scrollLeft() || 0;
2159                         curtop += $(o.containment).scrollTop() || 0;
2160                 }
2161
2162                 //Store needed variables
2163                 this.offset = this.helper.offset();
2164                 this.position = { left: curleft, top: curtop };
2165                 this.size = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2166                 this.originalSize = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2167                 this.originalPosition = { left: curleft, top: curtop };
2168                 this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
2169                 this.originalMousePosition = { left: event.pageX, top: event.pageY };
2170
2171                 //Aspect Ratio
2172                 this.aspectRatio = (typeof o.aspectRatio == 'number') ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);
2173
2174             var cursor = $('.ui-resizable-' + this.axis).css('cursor');
2175             $('body').css('cursor', cursor == 'auto' ? this.axis + '-resize' : cursor);
2176
2177                 el.addClass("ui-resizable-resizing");
2178                 this._propagate("start", event);
2179                 return true;
2180         },
2181
2182         _mouseDrag: function(event) {
2183
2184                 //Increase performance, avoid regex
2185                 var el = this.helper, o = this.options, props = {},
2186                         self = this, smp = this.originalMousePosition, a = this.axis;
2187
2188                 var dx = (event.pageX-smp.left)||0, dy = (event.pageY-smp.top)||0;
2189                 var trigger = this._change[a];
2190                 if (!trigger) return false;
2191
2192                 // Calculate the attrs that will be change
2193                 var data = trigger.apply(this, [event, dx, dy]), ie6 = $.browser.msie && $.browser.version < 7, csdif = this.sizeDiff;
2194
2195                 if (this._aspectRatio || event.shiftKey)
2196                         data = this._updateRatio(data, event);
2197
2198                 data = this._respectSize(data, event);
2199
2200                 // plugins callbacks need to be called first
2201                 this._propagate("resize", event);
2202
2203                 el.css({
2204                         top: this.position.top + "px", left: this.position.left + "px",
2205                         width: this.size.width + "px", height: this.size.height + "px"
2206                 });
2207
2208                 if (!this._helper && this._proportionallyResizeElements.length)
2209                         this._proportionallyResize();
2210
2211                 this._updateCache(data);
2212
2213                 // calling the user callback at the end
2214                 this._trigger('resize', event, this.ui());
2215
2216                 return false;
2217         },
2218
2219         _mouseStop: function(event) {
2220
2221                 this.resizing = false;
2222                 var o = this.options, self = this;
2223
2224                 if(this._helper) {
2225                         var pr = this._proportionallyResizeElements, ista = pr.length && (/textarea/i).test(pr[0].nodeName),
2226                                                 soffseth = ista && $.ui.hasScroll(pr[0], 'left') /* TODO - jump height */ ? 0 : self.sizeDiff.height,
2227                                                         soffsetw = ista ? 0 : self.sizeDiff.width;
2228
2229                         var s = { width: (self.size.width - soffsetw), height: (self.size.height - soffseth) },
2230                                 left = (parseInt(self.element.css('left'), 10) + (self.position.left - self.originalPosition.left)) || null,
2231                                 top = (parseInt(self.element.css('top'), 10) + (self.position.top - self.originalPosition.top)) || null;
2232
2233                         if (!o.animate)
2234                                 this.element.css($.extend(s, { top: top, left: left }));
2235
2236                         self.helper.height(self.size.height);
2237                         self.helper.width(self.size.width);
2238
2239                         if (this._helper && !o.animate) this._proportionallyResize();
2240                 }
2241
2242                 $('body').css('cursor', 'auto');
2243
2244                 this.element.removeClass("ui-resizable-resizing");
2245
2246                 this._propagate("stop", event);
2247
2248                 if (this._helper) this.helper.remove();
2249                 return false;
2250
2251         },
2252
2253         _updateCache: function(data) {
2254                 var o = this.options;
2255                 this.offset = this.helper.offset();
2256                 if (isNumber(data.left)) this.position.left = data.left;
2257                 if (isNumber(data.top)) this.position.top = data.top;
2258                 if (isNumber(data.height)) this.size.height = data.height;
2259                 if (isNumber(data.width)) this.size.width = data.width;
2260         },
2261
2262         _updateRatio: function(data, event) {
2263
2264                 var o = this.options, cpos = this.position, csize = this.size, a = this.axis;
2265
2266                 if (data.height) data.width = (csize.height * this.aspectRatio);
2267                 else if (data.width) data.height = (csize.width / this.aspectRatio);
2268
2269                 if (a == 'sw') {
2270                         data.left = cpos.left + (csize.width - data.width);
2271                         data.top = null;
2272                 }
2273                 if (a == 'nw') {
2274                         data.top = cpos.top + (csize.height - data.height);
2275                         data.left = cpos.left + (csize.width - data.width);
2276                 }
2277
2278                 return data;
2279         },
2280
2281         _respectSize: function(data, event) {
2282
2283                 var el = this.helper, o = this.options, pRatio = this._aspectRatio || event.shiftKey, a = this.axis,
2284                                 ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
2285                                         isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(data.height) && o.minHeight && (o.minHeight > data.height);
2286
2287                 if (isminw) data.width = o.minWidth;
2288                 if (isminh) data.height = o.minHeight;
2289                 if (ismaxw) data.width = o.maxWidth;
2290                 if (ismaxh) data.height = o.maxHeight;
2291
2292                 var dw = this.originalPosition.left + this.originalSize.width, dh = this.position.top + this.size.height;
2293                 var cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
2294
2295                 if (isminw && cw) data.left = dw - o.minWidth;
2296                 if (ismaxw && cw) data.left = dw - o.maxWidth;
2297                 if (isminh && ch)       data.top = dh - o.minHeight;
2298                 if (ismaxh && ch)       data.top = dh - o.maxHeight;
2299
2300                 // fixing jump error on top/left - bug #2330
2301                 var isNotwh = !data.width && !data.height;
2302                 if (isNotwh && !data.left && data.top) data.top = null;
2303                 else if (isNotwh && !data.top && data.left) data.left = null;
2304
2305                 return data;
2306         },
2307
2308         _proportionallyResize: function() {
2309
2310                 var o = this.options;
2311                 if (!this._proportionallyResizeElements.length) return;
2312                 var element = this.helper || this.element;
2313
2314                 for (var i=0; i < this._proportionallyResizeElements.length; i++) {
2315
2316                         var prel = this._proportionallyResizeElements[i];
2317
2318                         if (!this.borderDif) {
2319                                 var b = [prel.css('borderTopWidth'), prel.css('borderRightWidth'), prel.css('borderBottomWidth'), prel.css('borderLeftWidth')],
2320                                         p = [prel.css('paddingTop'), prel.css('paddingRight'), prel.css('paddingBottom'), prel.css('paddingLeft')];
2321
2322                                 this.borderDif = $.map(b, function(v, i) {
2323                                         var border = parseInt(v,10)||0, padding = parseInt(p[i],10)||0;
2324                                         return border + padding;
2325                                 });
2326                         }
2327
2328                         if ($.browser.msie && !(!($(element).is(':hidden') || $(element).parents(':hidden').length)))
2329                                 continue;
2330
2331                         prel.css({
2332                                 height: (element.height() - this.borderDif[0] - this.borderDif[2]) || 0,
2333                                 width: (element.width() - this.borderDif[1] - this.borderDif[3]) || 0
2334                         });
2335
2336                 };
2337
2338         },
2339
2340         _renderProxy: function() {
2341
2342                 var el = this.element, o = this.options;
2343                 this.elementOffset = el.offset();
2344
2345                 if(this._helper) {
2346
2347                         this.helper = this.helper || $('<div style="overflow:hidden;"></div>');
2348
2349                         // fix ie6 offset TODO: This seems broken
2350                         var ie6 = $.browser.msie && $.browser.version < 7, ie6offset = (ie6 ? 1 : 0),
2351                         pxyoffset = ( ie6 ? 2 : -1 );
2352
2353                         this.helper.addClass(this._helper).css({
2354                                 width: this.element.outerWidth() + pxyoffset,
2355                                 height: this.element.outerHeight() + pxyoffset,
2356                                 position: 'absolute',
2357                                 left: this.elementOffset.left - ie6offset +'px',
2358                                 top: this.elementOffset.top - ie6offset +'px',
2359                                 zIndex: ++o.zIndex //TODO: Don't modify option
2360                         });
2361
2362                         this.helper
2363                                 .appendTo("body")
2364                                 .disableSelection();
2365
2366                 } else {
2367                         this.helper = this.element;
2368                 }
2369
2370         },
2371
2372         _change: {
2373                 e: function(event, dx, dy) {
2374                         return { width: this.originalSize.width + dx };
2375                 },
2376                 w: function(event, dx, dy) {
2377                         var o = this.options, cs = this.originalSize, sp = this.originalPosition;
2378                         return { left: sp.left + dx, width: cs.width - dx };
2379                 },
2380                 n: function(event, dx, dy) {
2381                         var o = this.options, cs = this.originalSize, sp = this.originalPosition;
2382                         return { top: sp.top + dy, height: cs.height - dy };
2383                 },
2384                 s: function(event, dx, dy) {
2385                         return { height: this.originalSize.height + dy };
2386                 },
2387                 se: function(event, dx, dy) {
2388                         return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2389                 },
2390                 sw: function(event, dx, dy) {
2391                         return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2392                 },
2393                 ne: function(event, dx, dy) {
2394                         return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2395                 },
2396                 nw: function(event, dx, dy) {
2397                         return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2398                 }
2399         },
2400
2401         _propagate: function(n, event) {
2402                 $.ui.plugin.call(this, n, [event, this.ui()]);
2403                 (n != "resize" && this._trigger(n, event, this.ui()));
2404         },
2405
2406         plugins: {},
2407
2408         ui: function() {
2409                 return {
2410                         originalElement: this.originalElement,
2411                         element: this.element,
2412                         helper: this.helper,
2413                         position: this.position,
2414                         size: this.size,
2415                         originalSize: this.originalSize,
2416                         originalPosition: this.originalPosition
2417                 };
2418         }
2419
2420 });
2421
2422 $.extend($.ui.resizable, {
2423         version: "1.8"
2424 });
2425
2426 /*
2427  * Resizable Extensions
2428  */
2429
2430 $.ui.plugin.add("resizable", "alsoResize", {
2431
2432         start: function(event, ui) {
2433
2434                 var self = $(this).data("resizable"), o = self.options;
2435
2436                 var _store = function(exp) {
2437                         $(exp).each(function() {
2438                                 $(this).data("resizable-alsoresize", {
2439                                         width: parseInt($(this).width(), 10), height: parseInt($(this).height(), 10),
2440                                         left: parseInt($(this).css('left'), 10), top: parseInt($(this).css('top'), 10)
2441                                 });
2442                         });
2443                 };
2444
2445                 if (typeof(o.alsoResize) == 'object' && !o.alsoResize.parentNode) {
2446                         if (o.alsoResize.length) { o.alsoResize = o.alsoResize[0];      _store(o.alsoResize); }
2447                         else { $.each(o.alsoResize, function(exp, c) { _store(exp); }); }
2448                 }else{
2449                         _store(o.alsoResize);
2450                 }
2451         },
2452
2453         resize: function(event, ui){
2454                 var self = $(this).data("resizable"), o = self.options, os = self.originalSize, op = self.originalPosition;
2455
2456                 var delta = {
2457                         height: (self.size.height - os.height) || 0, width: (self.size.width - os.width) || 0,
2458                         top: (self.position.top - op.top) || 0, left: (self.position.left - op.left) || 0
2459                 },
2460
2461                 _alsoResize = function(exp, c) {
2462                         $(exp).each(function() {
2463                                 var el = $(this), start = $(this).data("resizable-alsoresize"), style = {}, css = c && c.length ? c : ['width', 'height', 'top', 'left'];
2464
2465                                 $.each(css || ['width', 'height', 'top', 'left'], function(i, prop) {
2466                                         var sum = (start[prop]||0) + (delta[prop]||0);
2467                                         if (sum && sum >= 0)
2468                                                 style[prop] = sum || null;
2469                                 });
2470
2471                                 //Opera fixing relative position
2472                                 if (/relative/.test(el.css('position')) && $.browser.opera) {
2473                                         self._revertToRelativePosition = true;
2474                                         el.css({ position: 'absolute', top: 'auto', left: 'auto' });
2475                                 }
2476
2477                                 el.css(style);
2478                         });
2479                 };
2480
2481                 if (typeof(o.alsoResize) == 'object' && !o.alsoResize.nodeType) {
2482                         $.each(o.alsoResize, function(exp, c) { _alsoResize(exp, c); });
2483                 }else{
2484                         _alsoResize(o.alsoResize);
2485                 }
2486         },
2487
2488         stop: function(event, ui){
2489                 var self = $(this).data("resizable");
2490
2491                 //Opera fixing relative position
2492                 if (self._revertToRelativePosition && $.browser.opera) {
2493                         self._revertToRelativePosition = false;
2494                         el.css({ position: 'relative' });
2495                 }
2496
2497                 $(this).removeData("resizable-alsoresize-start");
2498         }
2499 });
2500
2501 $.ui.plugin.add("resizable", "animate", {
2502
2503         stop: function(event, ui) {
2504                 var self = $(this).data("resizable"), o = self.options;
2505
2506                 var pr = self._proportionallyResizeElements, ista = pr.length && (/textarea/i).test(pr[0].nodeName),
2507                                         soffseth = ista && $.ui.hasScroll(pr[0], 'left') /* TODO - jump height */ ? 0 : self.sizeDiff.height,
2508                                                 soffsetw = ista ? 0 : self.sizeDiff.width;
2509
2510                 var style = { width: (self.size.width - soffsetw), height: (self.size.height - soffseth) },
2511                                         left = (parseInt(self.element.css('left'), 10) + (self.position.left - self.originalPosition.left)) || null,
2512                                                 top = (parseInt(self.element.css('top'), 10) + (self.position.top - self.originalPosition.top)) || null;
2513
2514                 self.element.animate(
2515                         $.extend(style, top && left ? { top: top, left: left } : {}), {
2516                                 duration: o.animateDuration,
2517                                 easing: o.animateEasing,
2518                                 step: function() {
2519
2520                                         var data = {
2521                                                 width: parseInt(self.element.css('width'), 10),
2522                                                 height: parseInt(self.element.css('height'), 10),
2523                                                 top: parseInt(self.element.css('top'), 10),
2524                                                 left: parseInt(self.element.css('left'), 10)
2525                                         };
2526
2527                                         if (pr && pr.length) $(pr[0]).css({ width: data.width, height: data.height });
2528
2529                                         // propagating resize, and updating values for each animation step
2530                                         self._updateCache(data);
2531                                         self._propagate("resize", event);
2532
2533                                 }
2534                         }
2535                 );
2536         }
2537
2538 });
2539
2540 $.ui.plugin.add("resizable", "containment", {
2541
2542         start: function(event, ui) {
2543                 var self = $(this).data("resizable"), o = self.options, el = self.element;
2544                 var oc = o.containment, ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
2545                 if (!ce) return;
2546
2547                 self.containerElement = $(ce);
2548
2549                 if (/document/.test(oc) || oc == document) {
2550                         self.containerOffset = { left: 0, top: 0 };
2551                         self.containerPosition = { left: 0, top: 0 };
2552
2553                         self.parentData = {
2554                                 element: $(document), left: 0, top: 0,
2555                                 width: $(document).width(), height: $(document).height() || document.body.parentNode.scrollHeight
2556                         };
2557                 }
2558
2559                 // i'm a node, so compute top, left, right, bottom
2560                 else {
2561                         var element = $(ce), p = [];
2562                         $([ "Top", "Right", "Left", "Bottom" ]).each(function(i, name) { p[i] = num(element.css("padding" + name)); });
2563
2564                         self.containerOffset = element.offset();
2565                         self.containerPosition = element.position();
2566                         self.containerSize = { height: (element.innerHeight() - p[3]), width: (element.innerWidth() - p[1]) };
2567
2568                         var co = self.containerOffset, ch = self.containerSize.height,  cw = self.containerSize.width,
2569                                                 width = ($.ui.hasScroll(ce, "left") ? ce.scrollWidth : cw ), height = ($.ui.hasScroll(ce) ? ce.scrollHeight : ch);
2570
2571                         self.parentData = {
2572                                 element: ce, left: co.left, top: co.top, width: width, height: height
2573                         };
2574                 }
2575         },
2576
2577         resize: function(event, ui) {
2578                 var self = $(this).data("resizable"), o = self.options,
2579                                 ps = self.containerSize, co = self.containerOffset, cs = self.size, cp = self.position,
2580                                 pRatio = self._aspectRatio || event.shiftKey, cop = { top:0, left:0 }, ce = self.containerElement;
2581
2582                 if (ce[0] != document && (/static/).test(ce.css('position'))) cop = co;
2583
2584                 if (cp.left < (self._helper ? co.left : 0)) {
2585                         self.size.width = self.size.width + (self._helper ? (self.position.left - co.left) : (self.position.left - cop.left));
2586                         if (pRatio) self.size.height = self.size.width / o.aspectRatio;
2587                         self.position.left = o.helper ? co.left : 0;
2588                 }
2589
2590                 if (cp.top < (self._helper ? co.top : 0)) {
2591                         self.size.height = self.size.height + (self._helper ? (self.position.top - co.top) : self.position.top);
2592                         if (pRatio) self.size.width = self.size.height * o.aspectRatio;
2593                         self.position.top = self._helper ? co.top : 0;
2594                 }
2595
2596                 self.offset.left = self.parentData.left+self.position.left;
2597                 self.offset.top = self.parentData.top+self.position.top;
2598
2599                 var woset = Math.abs( (self._helper ? self.offset.left - cop.left : (self.offset.left - cop.left)) + self.sizeDiff.width ),
2600                                         hoset = Math.abs( (self._helper ? self.offset.top - cop.top : (self.offset.top - co.top)) + self.sizeDiff.height );
2601
2602                 var isParent = self.containerElement.get(0) == self.element.parent().get(0),
2603                     isOffsetRelative = /relative|absolute/.test(self.containerElement.css('position'));
2604
2605                 if(isParent && isOffsetRelative) woset -= self.parentData.left;
2606
2607                 if (woset + self.size.width >= self.parentData.width) {
2608                         self.size.width = self.parentData.width - woset;
2609                         if (pRatio) self.size.height = self.size.width / self.aspectRatio;
2610                 }
2611
2612                 if (hoset + self.size.height >= self.parentData.height) {
2613                         self.size.height = self.parentData.height - hoset;
2614                         if (pRatio) self.size.width = self.size.height * self.aspectRatio;
2615                 }
2616         },
2617
2618         stop: function(event, ui){
2619                 var self = $(this).data("resizable"), o = self.options, cp = self.position,
2620                                 co = self.containerOffset, cop = self.containerPosition, ce = self.containerElement;
2621
2622                 var helper = $(self.helper), ho = helper.offset(), w = helper.outerWidth() - self.sizeDiff.width, h = helper.outerHeight() - self.sizeDiff.height;
2623
2624                 if (self._helper && !o.animate && (/relative/).test(ce.css('position')))
2625                         $(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
2626
2627                 if (self._helper && !o.animate && (/static/).test(ce.css('position')))
2628                         $(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
2629
2630         }
2631 });
2632
2633 $.ui.plugin.add("resizable", "ghost", {
2634
2635         start: function(event, ui) {
2636
2637                 var self = $(this).data("resizable"), o = self.options, cs = self.size;
2638
2639                 self.ghost = self.originalElement.clone();
2640                 self.ghost
2641                         .css({ opacity: .25, display: 'block', position: 'relative', height: cs.height, width: cs.width, margin: 0, left: 0, top: 0 })
2642                         .addClass('ui-resizable-ghost')
2643                         .addClass(typeof o.ghost == 'string' ? o.ghost : '');
2644
2645                 self.ghost.appendTo(self.helper);
2646
2647         },
2648
2649         resize: function(event, ui){
2650                 var self = $(this).data("resizable"), o = self.options;
2651                 if (self.ghost) self.ghost.css({ position: 'relative', height: self.size.height, width: self.size.width });
2652         },
2653
2654         stop: function(event, ui){
2655                 var self = $(this).data("resizable"), o = self.options;
2656                 if (self.ghost && self.helper) self.helper.get(0).removeChild(self.ghost.get(0));
2657         }
2658
2659 });
2660
2661 $.ui.plugin.add("resizable", "grid", {
2662
2663         resize: function(event, ui) {
2664                 var self = $(this).data("resizable"), o = self.options, cs = self.size, os = self.originalSize, op = self.originalPosition, a = self.axis, ratio = o._aspectRatio || event.shiftKey;
2665                 o.grid = typeof o.grid == "number" ? [o.grid, o.grid] : o.grid;
2666                 var ox = Math.round((cs.width - os.width) / (o.grid[0]||1)) * (o.grid[0]||1), oy = Math.round((cs.height - os.height) / (o.grid[1]||1)) * (o.grid[1]||1);
2667
2668                 if (/^(se|s|e)$/.test(a)) {
2669                         self.size.width = os.width + ox;
2670                         self.size.height = os.height + oy;
2671                 }
2672                 else if (/^(ne)$/.test(a)) {
2673                         self.size.width = os.width + ox;
2674                         self.size.height = os.height + oy;
2675                         self.position.top = op.top - oy;
2676                 }
2677                 else if (/^(sw)$/.test(a)) {
2678                         self.size.width = os.width + ox;
2679                         self.size.height = os.height + oy;
2680                         self.position.left = op.left - ox;
2681                 }
2682                 else {
2683                         self.size.width = os.width + ox;
2684                         self.size.height = os.height + oy;
2685                         self.position.top = op.top - oy;
2686                         self.position.left = op.left - ox;
2687                 }
2688         }
2689
2690 });
2691
2692 var num = function(v) {
2693         return parseInt(v, 10) || 0;
2694 };
2695
2696 var isNumber = function(value) {
2697         return !isNaN(parseInt(value, 10));
2698 };
2699
2700 })(jQuery);
2701 /*
2702  * jQuery UI Selectable 1.8
2703  *
2704  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
2705  * Dual licensed under the MIT (MIT-LICENSE.txt)
2706  * and GPL (GPL-LICENSE.txt) licenses.
2707  *
2708  * http://docs.jquery.com/UI/Selectables
2709  *
2710  * Depends:
2711  *      jquery.ui.core.js
2712  *      jquery.ui.mouse.js
2713  *      jquery.ui.widget.js
2714  */
2715 (function($) {
2716
2717 $.widget("ui.selectable", $.ui.mouse, {
2718         options: {
2719                 appendTo: 'body',
2720                 autoRefresh: true,
2721                 distance: 0,
2722                 filter: '*',
2723                 tolerance: 'touch'
2724         },
2725         _create: function() {
2726                 var self = this;
2727
2728                 this.element.addClass("ui-selectable");
2729
2730                 this.dragged = false;
2731
2732                 // cache selectee children based on filter
2733                 var selectees;
2734                 this.refresh = function() {
2735                         selectees = $(self.options.filter, self.element[0]);
2736                         selectees.each(function() {
2737                                 var $this = $(this);
2738                                 var pos = $this.offset();
2739                                 $.data(this, "selectable-item", {
2740                                         element: this,
2741                                         $element: $this,
2742                                         left: pos.left,
2743                                         top: pos.top,
2744                                         right: pos.left + $this.outerWidth(),
2745                                         bottom: pos.top + $this.outerHeight(),
2746                                         startselected: false,
2747                                         selected: $this.hasClass('ui-selected'),
2748                                         selecting: $this.hasClass('ui-selecting'),
2749                                         unselecting: $this.hasClass('ui-unselecting')
2750                                 });
2751                         });
2752                 };
2753                 this.refresh();
2754
2755                 this.selectees = selectees.addClass("ui-selectee");
2756
2757                 this._mouseInit();
2758
2759                 this.helper = $(document.createElement('div'))
2760                         .css({border:'1px dotted black'})
2761                         .addClass("ui-selectable-helper");
2762         },
2763
2764         destroy: function() {
2765                 this.selectees
2766                         .removeClass("ui-selectee")
2767                         .removeData("selectable-item");
2768                 this.element
2769                         .removeClass("ui-selectable ui-selectable-disabled")
2770                         .removeData("selectable")
2771                         .unbind(".selectable");
2772                 this._mouseDestroy();
2773
2774                 return this;
2775         },
2776
2777         _mouseStart: function(event) {
2778                 var self = this;
2779
2780                 this.opos = [event.pageX, event.pageY];
2781
2782                 if (this.options.disabled)
2783                         return;
2784
2785                 var options = this.options;
2786
2787                 this.selectees = $(options.filter, this.element[0]);
2788
2789                 this._trigger("start", event);
2790
2791                 $(options.appendTo).append(this.helper);
2792                 // position helper (lasso)
2793                 this.helper.css({
2794                         "z-index": 100,
2795                         "position": "absolute",
2796                         "left": event.clientX,
2797                         "top": event.clientY,
2798                         "width": 0,
2799                         "height": 0
2800                 });
2801
2802                 if (options.autoRefresh) {
2803                         this.refresh();
2804                 }
2805
2806                 this.selectees.filter('.ui-selected').each(function() {
2807                         var selectee = $.data(this, "selectable-item");
2808                         selectee.startselected = true;
2809                         if (!event.metaKey) {
2810                                 selectee.$element.removeClass('ui-selected');
2811                                 selectee.selected = false;
2812                                 selectee.$element.addClass('ui-unselecting');
2813                                 selectee.unselecting = true;
2814                                 // selectable UNSELECTING callback
2815                                 self._trigger("unselecting", event, {
2816                                         unselecting: selectee.element
2817                                 });
2818                         }
2819                 });
2820
2821                 $(event.target).parents().andSelf().each(function() {
2822                         var selectee = $.data(this, "selectable-item");
2823                         if (selectee) {
2824                                 selectee.$element.removeClass("ui-unselecting").addClass('ui-selecting');
2825                                 selectee.unselecting = false;
2826                                 selectee.selecting = true;
2827                                 selectee.selected = true;
2828                                 // selectable SELECTING callback
2829                                 self._trigger("selecting", event, {
2830                                         selecting: selectee.element
2831                                 });
2832                                 return false;
2833                         }
2834                 });
2835
2836         },
2837
2838         _mouseDrag: function(event) {
2839                 var self = this;
2840                 this.dragged = true;
2841
2842                 if (this.options.disabled)
2843                         return;
2844
2845                 var options = this.options;
2846
2847                 var x1 = this.opos[0], y1 = this.opos[1], x2 = event.pageX, y2 = event.pageY;
2848                 if (x1 > x2) { var tmp = x2; x2 = x1; x1 = tmp; }
2849                 if (y1 > y2) { var tmp = y2; y2 = y1; y1 = tmp; }
2850                 this.helper.css({left: x1, top: y1, width: x2-x1, height: y2-y1});
2851
2852                 this.selectees.each(function() {
2853                         var selectee = $.data(this, "selectable-item");
2854                         //prevent helper from being selected if appendTo: selectable
2855                         if (!selectee || selectee.element == self.element[0])
2856                                 return;
2857                         var hit = false;
2858                         if (options.tolerance == 'touch') {
2859                                 hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
2860                         } else if (options.tolerance == 'fit') {
2861                                 hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
2862                         }
2863
2864                         if (hit) {
2865                                 // SELECT
2866                                 if (selectee.selected) {
2867                                         selectee.$element.removeClass('ui-selected');
2868                                         selectee.selected = false;
2869                                 }
2870                                 if (selectee.unselecting) {
2871                                         selectee.$element.removeClass('ui-unselecting');
2872                                         selectee.unselecting = false;
2873                                 }
2874                                 if (!selectee.selecting) {
2875                                         selectee.$element.addClass('ui-selecting');
2876                                         selectee.selecting = true;
2877                                         // selectable SELECTING callback
2878                                         self._trigger("selecting", event, {
2879                                                 selecting: selectee.element
2880                                         });
2881                                 }
2882                         } else {
2883                                 // UNSELECT
2884                                 if (selectee.selecting) {
2885                                         if (event.metaKey && selectee.startselected) {
2886                                                 selectee.$element.removeClass('ui-selecting');
2887                                                 selectee.selecting = false;
2888                                                 selectee.$element.addClass('ui-selected');
2889                                                 selectee.selected = true;
2890                                         } else {
2891                                                 selectee.$element.removeClass('ui-selecting');
2892                                                 selectee.selecting = false;
2893                                                 if (selectee.startselected) {
2894                                                         selectee.$element.addClass('ui-unselecting');
2895                                                         selectee.unselecting = true;
2896                                                 }
2897                                                 // selectable UNSELECTING callback
2898                                                 self._trigger("unselecting", event, {
2899                                                         unselecting: selectee.element
2900                                                 });
2901                                         }
2902                                 }
2903                                 if (selectee.selected) {
2904                                         if (!event.metaKey && !selectee.startselected) {
2905                                                 selectee.$element.removeClass('ui-selected');
2906                                                 selectee.selected = false;
2907
2908                                                 selectee.$element.addClass('ui-unselecting');
2909                                                 selectee.unselecting = true;
2910                                                 // selectable UNSELECTING callback
2911                                                 self._trigger("unselecting", event, {
2912                                                         unselecting: selectee.element
2913                                                 });
2914                                         }
2915                                 }
2916                         }
2917                 });
2918
2919                 return false;
2920         },
2921
2922         _mouseStop: function(event) {
2923                 var self = this;
2924
2925                 this.dragged = false;
2926
2927                 var options = this.options;
2928
2929                 $('.ui-unselecting', this.element[0]).each(function() {
2930                         var selectee = $.data(this, "selectable-item");
2931                         selectee.$element.removeClass('ui-unselecting');
2932                         selectee.unselecting = false;
2933                         selectee.startselected = false;
2934                         self._trigger("unselected", event, {
2935                                 unselected: selectee.element
2936                         });
2937                 });
2938                 $('.ui-selecting', this.element[0]).each(function() {
2939                         var selectee = $.data(this, "selectable-item");
2940                         selectee.$element.removeClass('ui-selecting').addClass('ui-selected');
2941                         selectee.selecting = false;
2942                         selectee.selected = true;
2943                         selectee.startselected = true;
2944                         self._trigger("selected", event, {
2945                                 selected: selectee.element
2946                         });
2947                 });
2948                 this._trigger("stop", event);
2949
2950                 this.helper.remove();
2951
2952                 return false;
2953         }
2954
2955 });
2956
2957 $.extend($.ui.selectable, {
2958         version: "1.8"
2959 });
2960
2961 })(jQuery);
2962 /*
2963  * jQuery UI Sortable 1.8
2964  *
2965  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
2966  * Dual licensed under the MIT (MIT-LICENSE.txt)
2967  * and GPL (GPL-LICENSE.txt) licenses.
2968  *
2969  * http://docs.jquery.com/UI/Sortables
2970  *
2971  * Depends:
2972  *      jquery.ui.core.js
2973  *      jquery.ui.mouse.js
2974  *      jquery.ui.widget.js
2975  */
2976 (function($) {
2977
2978 $.widget("ui.sortable", $.ui.mouse, {
2979         widgetEventPrefix: "sort",
2980         options: {
2981                 appendTo: "parent",
2982                 axis: false,
2983                 connectWith: false,
2984                 containment: false,
2985                 cursor: 'auto',
2986                 cursorAt: false,
2987                 dropOnEmpty: true,
2988                 forcePlaceholderSize: false,
2989                 forceHelperSize: false,
2990                 grid: false,
2991                 handle: false,
2992                 helper: "original",
2993                 items: '> *',
2994                 opacity: false,
2995                 placeholder: false,
2996                 revert: false,
2997                 scroll: true,
2998                 scrollSensitivity: 20,
2999                 scrollSpeed: 20,
3000                 scope: "default",
3001                 tolerance: "intersect",
3002                 zIndex: 1000
3003         },
3004         _create: function() {
3005
3006                 var o = this.options;
3007                 this.containerCache = {};
3008                 this.element.addClass("ui-sortable");
3009
3010                 //Get the items
3011                 this.refresh();
3012
3013                 //Let's determine if the items are floating
3014                 this.floating = this.items.length ? (/left|right/).test(this.items[0].item.css('float')) : false;
3015
3016                 //Let's determine the parent's offset
3017                 this.offset = this.element.offset();
3018
3019                 //Initialize mouse events for interaction
3020                 this._mouseInit();
3021
3022         },
3023
3024         destroy: function() {
3025                 this.element
3026                         .removeClass("ui-sortable ui-sortable-disabled")
3027                         .removeData("sortable")
3028                         .unbind(".sortable");
3029                 this._mouseDestroy();
3030
3031                 for ( var i = this.items.length - 1; i >= 0; i-- )
3032                         this.items[i].item.removeData("sortable-item");
3033
3034                 return this;
3035         },
3036
3037         _mouseCapture: function(event, overrideHandle) {
3038
3039                 if (this.reverting) {
3040                         return false;
3041                 }
3042
3043                 if(this.options.disabled || this.options.type == 'static') return false;
3044
3045                 //We have to refresh the items data once first
3046                 this._refreshItems(event);
3047
3048                 //Find out if the clicked node (or one of its parents) is a actual item in this.items
3049                 var currentItem = null, self = this, nodes = $(event.target).parents().each(function() {
3050                         if($.data(this, 'sortable-item') == self) {
3051                                 currentItem = $(this);
3052                                 return false;
3053                         }
3054                 });
3055                 if($.data(event.target, 'sortable-item') == self) currentItem = $(event.target);
3056
3057                 if(!currentItem) return false;
3058                 if(this.options.handle && !overrideHandle) {
3059                         var validHandle = false;
3060
3061                         $(this.options.handle, currentItem).find("*").andSelf().each(function() { if(this == event.target) validHandle = true; });
3062                         if(!validHandle) return false;
3063                 }
3064
3065                 this.currentItem = currentItem;
3066                 this._removeCurrentsFromItems();
3067                 return true;
3068
3069         },
3070
3071         _mouseStart: function(event, overrideHandle, noActivation) {
3072
3073                 var o = this.options, self = this;
3074                 this.currentContainer = this;
3075
3076                 //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
3077                 this.refreshPositions();
3078
3079                 //Create and append the visible helper
3080                 this.helper = this._createHelper(event);
3081
3082                 //Cache the helper size
3083                 this._cacheHelperProportions();
3084
3085                 /*
3086                  * - Position generation -
3087                  * This block generates everything position related - it's the core of draggables.
3088                  */
3089
3090                 //Cache the margins of the original element
3091                 this._cacheMargins();
3092
3093                 //Get the next scrolling parent
3094                 this.scrollParent = this.helper.scrollParent();
3095
3096                 //The element's absolute position on the page minus margins
3097                 this.offset = this.currentItem.offset();
3098                 this.offset = {
3099                         top: this.offset.top - this.margins.top,
3100                         left: this.offset.left - this.margins.left
3101                 };
3102
3103                 // Only after we got the offset, we can change the helper's position to absolute
3104                 // TODO: Still need to figure out a way to make relative sorting possible
3105                 this.helper.css("position", "absolute");
3106                 this.cssPosition = this.helper.css("position");
3107
3108                 $.extend(this.offset, {
3109                         click: { //Where the click happened, relative to the element
3110                                 left: event.pageX - this.offset.left,
3111                                 top: event.pageY - this.offset.top
3112                         },
3113                         parent: this._getParentOffset(),
3114                         relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
3115                 });
3116
3117                 //Generate the original position
3118                 this.originalPosition = this._generatePosition(event);
3119                 this.originalPageX = event.pageX;
3120                 this.originalPageY = event.pageY;
3121
3122                 //Adjust the mouse offset relative to the helper if 'cursorAt' is supplied
3123                 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
3124
3125                 //Cache the former DOM position
3126                 this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
3127
3128                 //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
3129                 if(this.helper[0] != this.currentItem[0]) {
3130                         this.currentItem.hide();
3131                 }
3132
3133                 //Create the placeholder
3134                 this._createPlaceholder();
3135
3136                 //Set a containment if given in the options
3137                 if(o.containment)
3138                         this._setContainment();
3139
3140                 if(o.cursor) { // cursor option
3141                         if ($('body').css("cursor")) this._storedCursor = $('body').css("cursor");
3142                         $('body').css("cursor", o.cursor);
3143                 }
3144
3145                 if(o.opacity) { // opacity option
3146                         if (this.helper.css("opacity")) this._storedOpacity = this.helper.css("opacity");
3147                         this.helper.css("opacity", o.opacity);
3148                 }
3149
3150                 if(o.zIndex) { // zIndex option
3151                         if (this.helper.css("zIndex")) this._storedZIndex = this.helper.css("zIndex");
3152                         this.helper.css("zIndex", o.zIndex);
3153                 }
3154
3155                 //Prepare scrolling
3156                 if(this.scrollParent[0] != document && this.scrollParent[0].tagName != 'HTML')
3157                         this.overflowOffset = this.scrollParent.offset();
3158
3159                 //Call callbacks
3160                 this._trigger("start", event, this._uiHash());
3161
3162                 //Recache the helper size
3163                 if(!this._preserveHelperProportions)
3164                         this._cacheHelperProportions();
3165
3166
3167                 //Post 'activate' events to possible containers
3168                 if(!noActivation) {
3169                          for (var i = this.containers.length - 1; i >= 0; i--) { this.containers[i]._trigger("activate", event, self._uiHash(this)); }
3170                 }
3171
3172                 //Prepare possible droppables
3173                 if($.ui.ddmanager)
3174                         $.ui.ddmanager.current = this;
3175
3176                 if ($.ui.ddmanager && !o.dropBehaviour)
3177                         $.ui.ddmanager.prepareOffsets(this, event);
3178
3179                 this.dragging = true;
3180
3181                 this.helper.addClass("ui-sortable-helper");
3182                 this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
3183                 return true;
3184
3185         },
3186
3187         _mouseDrag: function(event) {
3188
3189                 //Compute the helpers position
3190                 this.position = this._generatePosition(event);
3191                 this.positionAbs = this._convertPositionTo("absolute");
3192
3193                 if (!this.lastPositionAbs) {
3194                         this.lastPositionAbs = this.positionAbs;
3195                 }
3196
3197                 //Do scrolling
3198                 if(this.options.scroll) {
3199                         var o = this.options, scrolled = false;
3200                         if(this.scrollParent[0] != document && this.scrollParent[0].tagName != 'HTML') {
3201
3202                                 if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity)
3203                                         this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
3204                                 else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity)
3205                                         this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
3206
3207                                 if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity)
3208                                         this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
3209                                 else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity)
3210                                         this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
3211
3212                         } else {
3213
3214                                 if(event.pageY - $(document).scrollTop() < o.scrollSensitivity)
3215                                         scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
3216                                 else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity)
3217                                         scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
3218
3219                                 if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity)
3220                                         scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
3221                                 else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
3222                                         scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
3223
3224                         }
3225
3226                         if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour)
3227                                 $.ui.ddmanager.prepareOffsets(this, event);
3228                 }
3229
3230                 //Regenerate the absolute position used for position checks
3231                 this.positionAbs = this._convertPositionTo("absolute");
3232
3233                 //Set the helper position
3234                 if(!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left+'px';
3235                 if(!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top+'px';
3236
3237                 //Rearrange
3238                 for (var i = this.items.length - 1; i >= 0; i--) {
3239
3240                         //Cache variables and intersection, continue if no intersection
3241                         var item = this.items[i], itemElement = item.item[0], intersection = this._intersectsWithPointer(item);
3242                         if (!intersection) continue;
3243
3244                         if(itemElement != this.currentItem[0] //cannot intersect with itself
3245                                 &&      this.placeholder[intersection == 1 ? "next" : "prev"]()[0] != itemElement //no useless actions that have been done before
3246                                 &&      !$.ui.contains(this.placeholder[0], itemElement) //no action if the item moved is the parent of the item checked
3247                                 && (this.options.type == 'semi-dynamic' ? !$.ui.contains(this.element[0], itemElement) : true)
3248                                 //&& itemElement.parentNode == this.placeholder[0].parentNode // only rearrange items within the same container
3249                         ) {
3250
3251                                 this.direction = intersection == 1 ? "down" : "up";
3252
3253                                 if (this.options.tolerance == "pointer" || this._intersectsWithSides(item)) {
3254                                         this._rearrange(event, item);
3255                                 } else {
3256                                         break;
3257                                 }
3258
3259                                 this._trigger("change", event, this._uiHash());
3260                                 break;
3261                         }
3262                 }
3263
3264                 //Post events to containers
3265                 this._contactContainers(event);
3266
3267                 //Interconnect with droppables
3268                 if($.ui.ddmanager) $.ui.ddmanager.drag(this, event);
3269
3270                 //Call callbacks
3271                 this._trigger('sort', event, this._uiHash());
3272
3273                 this.lastPositionAbs = this.positionAbs;
3274                 return false;
3275
3276         },
3277
3278         _mouseStop: function(event, noPropagation) {
3279
3280                 if(!event) return;
3281
3282                 //If we are using droppables, inform the manager about the drop
3283                 if ($.ui.ddmanager && !this.options.dropBehaviour)
3284                         $.ui.ddmanager.drop(this, event);
3285
3286                 if(this.options.revert) {
3287                         var self = this;
3288                         var cur = self.placeholder.offset();
3289
3290                         self.reverting = true;
3291
3292                         $(this.helper).animate({
3293                                 left: cur.left - this.offset.parent.left - self.margins.left + (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollLeft),
3294                                 top: cur.top - this.offset.parent.top - self.margins.top + (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollTop)
3295                         }, parseInt(this.options.revert, 10) || 500, function() {
3296                                 self._clear(event);
3297                         });
3298                 } else {
3299                         this._clear(event, noPropagation);
3300                 }
3301
3302                 return false;
3303
3304         },
3305
3306         cancel: function() {
3307
3308                 var self = this;
3309
3310                 if(this.dragging) {
3311
3312                         this._mouseUp();
3313
3314                         if(this.options.helper == "original")
3315                                 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
3316                         else
3317                                 this.currentItem.show();
3318
3319                         //Post deactivating events to containers
3320                         for (var i = this.containers.length - 1; i >= 0; i--){
3321                                 this.containers[i]._trigger("deactivate", null, self._uiHash(this));
3322                                 if(this.containers[i].containerCache.over) {
3323                                         this.containers[i]._trigger("out", null, self._uiHash(this));
3324                                         this.containers[i].containerCache.over = 0;
3325                                 }
3326                         }
3327
3328                 }
3329
3330                 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
3331                 if(this.placeholder[0].parentNode) this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
3332                 if(this.options.helper != "original" && this.helper && this.helper[0].parentNode) this.helper.remove();
3333
3334                 $.extend(this, {
3335                         helper: null,
3336                         dragging: false,
3337                         reverting: false,
3338                         _noFinalSort: null
3339                 });
3340
3341                 if(this.domPosition.prev) {
3342                         $(this.domPosition.prev).after(this.currentItem);
3343                 } else {
3344                         $(this.domPosition.parent).prepend(this.currentItem);
3345                 }
3346
3347                 return this;
3348
3349         },
3350
3351         serialize: function(o) {
3352
3353                 var items = this._getItemsAsjQuery(o && o.connected);
3354                 var str = []; o = o || {};
3355
3356                 $(items).each(function() {
3357                         var res = ($(o.item || this).attr(o.attribute || 'id') || '').match(o.expression || (/(.+)[-=_](.+)/));
3358                         if(res) str.push((o.key || res[1]+'[]')+'='+(o.key && o.expression ? res[1] : res[2]));
3359                 });
3360
3361                 return str.join('&');
3362
3363         },
3364
3365         toArray: function(o) {
3366
3367                 var items = this._getItemsAsjQuery(o && o.connected);
3368                 var ret = []; o = o || {};
3369
3370                 items.each(function() { ret.push($(o.item || this).attr(o.attribute || 'id') || ''); });
3371                 return ret;
3372
3373         },
3374
3375         /* Be careful with the following core functions */
3376         _intersectsWith: function(item) {
3377
3378                 var x1 = this.positionAbs.left,
3379                         x2 = x1 + this.helperProportions.width,
3380                         y1 = this.positionAbs.top,
3381                         y2 = y1 + this.helperProportions.height;
3382
3383                 var l = item.left,
3384                         r = l + item.width,
3385                         t = item.top,
3386                         b = t + item.height;
3387
3388                 var dyClick = this.offset.click.top,
3389                         dxClick = this.offset.click.left;
3390
3391                 var isOverElement = (y1 + dyClick) > t && (y1 + dyClick) < b && (x1 + dxClick) > l && (x1 + dxClick) < r;
3392
3393                 if(        this.options.tolerance == "pointer"
3394                         || this.options.forcePointerForContainers
3395                         || (this.options.tolerance != "pointer" && this.helperProportions[this.floating ? 'width' : 'height'] > item[this.floating ? 'width' : 'height'])
3396                 ) {
3397                         return isOverElement;
3398                 } else {
3399
3400                         return (l < x1 + (this.helperProportions.width / 2) // Right Half
3401                                 && x2 - (this.helperProportions.width / 2) < r // Left Half
3402                                 && t < y1 + (this.helperProportions.height / 2) // Bottom Half
3403                                 && y2 - (this.helperProportions.height / 2) < b ); // Top Half
3404
3405                 }
3406         },
3407
3408         _intersectsWithPointer: function(item) {
3409
3410                 var isOverElementHeight = $.ui.isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
3411                         isOverElementWidth = $.ui.isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
3412                         isOverElement = isOverElementHeight && isOverElementWidth,
3413                         verticalDirection = this._getDragVerticalDirection(),
3414                         horizontalDirection = this._getDragHorizontalDirection();
3415
3416                 if (!isOverElement)
3417                         return false;
3418
3419                 return this.floating ?
3420                         ( ((horizontalDirection && horizontalDirection == "right") || verticalDirection == "down") ? 2 : 1 )
3421                         : ( verticalDirection && (verticalDirection == "down" ? 2 : 1) );
3422
3423         },
3424
3425         _intersectsWithSides: function(item) {
3426
3427                 var isOverBottomHalf = $.ui.isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
3428                         isOverRightHalf = $.ui.isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
3429                         verticalDirection = this._getDragVerticalDirection(),
3430                         horizontalDirection = this._getDragHorizontalDirection();
3431
3432                 if (this.floating && horizontalDirection) {
3433                         return ((horizontalDirection == "right" && isOverRightHalf) || (horizontalDirection == "left" && !isOverRightHalf));
3434                 } else {
3435                         return verticalDirection && ((verticalDirection == "down" && isOverBottomHalf) || (verticalDirection == "up" && !isOverBottomHalf));
3436                 }
3437
3438         },
3439
3440         _getDragVerticalDirection: function() {
3441                 var delta = this.positionAbs.top - this.lastPositionAbs.top;
3442                 return delta != 0 && (delta > 0 ? "down" : "up");
3443         },
3444
3445         _getDragHorizontalDirection: function() {
3446                 var delta = this.positionAbs.left - this.lastPositionAbs.left;
3447                 return delta != 0 && (delta > 0 ? "right" : "left");
3448         },
3449
3450         refresh: function(event) {
3451                 this._refreshItems(event);
3452                 this.refreshPositions();
3453                 return this;
3454         },
3455
3456         _connectWith: function() {
3457                 var options = this.options;
3458                 return options.connectWith.constructor == String
3459                         ? [options.connectWith]
3460                         : options.connectWith;
3461         },
3462
3463         _getItemsAsjQuery: function(connected) {
3464
3465                 var self = this;
3466                 var items = [];
3467                 var queries = [];
3468                 var connectWith = this._connectWith();
3469
3470                 if(connectWith && connected) {
3471                         for (var i = connectWith.length - 1; i >= 0; i--){
3472                                 var cur = $(connectWith[i]);
3473                                 for (var j = cur.length - 1; j >= 0; j--){
3474                                         var inst = $.data(cur[j], 'sortable');
3475                                         if(inst && inst != this && !inst.options.disabled) {
3476                                                 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]);
3477                                         }
3478                                 };
3479                         };
3480                 }
3481
3482                 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]);
3483
3484                 for (var i = queries.length - 1; i >= 0; i--){
3485                         queries[i][0].each(function() {
3486                                 items.push(this);
3487                         });
3488                 };
3489
3490                 return $(items);
3491
3492         },
3493
3494         _removeCurrentsFromItems: function() {
3495
3496                 var list = this.currentItem.find(":data(sortable-item)");
3497
3498                 for (var i=0; i < this.items.length; i++) {
3499
3500                         for (var j=0; j < list.length; j++) {
3501                                 if(list[j] == this.items[i].item[0])
3502                                         this.items.splice(i,1);
3503                         };
3504
3505                 };
3506
3507         },
3508
3509         _refreshItems: function(event) {
3510
3511                 this.items = [];
3512                 this.containers = [this];
3513                 var items = this.items;
3514                 var self = this;
3515                 var queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]];
3516                 var connectWith = this._connectWith();
3517
3518                 if(connectWith) {
3519                         for (var i = connectWith.length - 1; i >= 0; i--){
3520                                 var cur = $(connectWith[i]);
3521                                 for (var j = cur.length - 1; j >= 0; j--){
3522                                         var inst = $.data(cur[j], 'sortable');
3523                                         if(inst && inst != this && !inst.options.disabled) {
3524                                                 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
3525                                                 this.containers.push(inst);
3526                                         }
3527                                 };
3528                         };
3529                 }
3530
3531                 for (var i = queries.length - 1; i >= 0; i--) {
3532                         var targetData = queries[i][1];
3533                         var _queries = queries[i][0];
3534
3535                         for (var j=0, queriesLength = _queries.length; j < queriesLength; j++) {
3536                                 var item = $(_queries[j]);
3537
3538                                 item.data('sortable-item', targetData); // Data for target checking (mouse manager)
3539
3540                                 items.push({
3541                                         item: item,
3542                                         instance: targetData,
3543                                         width: 0, height: 0,
3544                                         left: 0, top: 0
3545                                 });
3546                         };
3547                 };
3548
3549         },
3550
3551         refreshPositions: function(fast) {
3552
3553                 //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
3554                 if(this.offsetParent && this.helper) {
3555                         this.offset.parent = this._getParentOffset();
3556                 }
3557
3558                 for (var i = this.items.length - 1; i >= 0; i--){
3559                         var item = this.items[i];
3560
3561                         var t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
3562
3563                         if (!fast) {
3564                                 item.width = t.outerWidth();
3565                                 item.height = t.outerHeight();
3566                         }
3567
3568                         var p = t.offset();
3569                         item.left = p.left;
3570                         item.top = p.top;
3571                 };
3572
3573                 if(this.options.custom && this.options.custom.refreshContainers) {
3574                         this.options.custom.refreshContainers.call(this);
3575                 } else {
3576                         for (var i = this.containers.length - 1; i >= 0; i--){
3577                                 var p = this.containers[i].element.offset();
3578                                 this.containers[i].containerCache.left = p.left;
3579                                 this.containers[i].containerCache.top = p.top;
3580                                 this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
3581                                 this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
3582                         };
3583                 }
3584
3585                 return this;
3586         },
3587
3588         _createPlaceholder: function(that) {
3589
3590                 var self = that || this, o = self.options;
3591
3592                 if(!o.placeholder || o.placeholder.constructor == String) {
3593                         var className = o.placeholder;
3594                         o.placeholder = {
3595                                 element: function() {
3596
3597                                         var el = $(document.createElement(self.currentItem[0].nodeName))
3598                                                 .addClass(className || self.currentItem[0].className+" ui-sortable-placeholder")
3599                                                 .removeClass("ui-sortable-helper")[0];
3600
3601                                         if(!className)
3602                                                 el.style.visibility = "hidden";
3603
3604                                         return el;
3605                                 },
3606                                 update: function(container, p) {
3607
3608                                         // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
3609                                         // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
3610                                         if(className && !o.forcePlaceholderSize) return;
3611
3612                                         //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
3613                                         if(!p.height()) { p.height(self.currentItem.innerHeight() - parseInt(self.currentItem.css('paddingTop')||0, 10) - parseInt(self.currentItem.css('paddingBottom')||0, 10)); };
3614                                         if(!p.width()) { p.width(self.currentItem.innerWidth() - parseInt(self.currentItem.css('paddingLeft')||0, 10) - parseInt(self.currentItem.css('paddingRight')||0, 10)); };
3615                                 }
3616                         };
3617                 }
3618
3619                 //Create the placeholder
3620                 self.placeholder = $(o.placeholder.element.call(self.element, self.currentItem));
3621
3622                 //Append it after the actual current item
3623                 self.currentItem.after(self.placeholder);
3624
3625                 //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
3626                 o.placeholder.update(self, self.placeholder);
3627
3628         },
3629
3630         _contactContainers: function(event) {
3631
3632                 // get innermost container that intersects with item
3633                 var innermostContainer = null, innermostIndex = null;
3634
3635
3636                 for (var i = this.containers.length - 1; i >= 0; i--){
3637
3638                         // never consider a container that's located within the item itself
3639                         if($.ui.contains(this.currentItem[0], this.containers[i].element[0]))
3640                                 continue;
3641
3642                         if(this._intersectsWith(this.containers[i].containerCache)) {
3643
3644                                 // if we've already found a container and it's more "inner" than this, then continue
3645                                 if(innermostContainer && $.ui.contains(this.containers[i].element[0], innermostContainer.element[0]))
3646                                         continue;
3647
3648                                 innermostContainer = this.containers[i];
3649                                 innermostIndex = i;
3650
3651                         } else {
3652                                 // container doesn't intersect. trigger "out" event if necessary
3653                                 if(this.containers[i].containerCache.over) {
3654                                         this.containers[i]._trigger("out", event, this._uiHash(this));
3655                                         this.containers[i].containerCache.over = 0;
3656                                 }
3657                         }
3658
3659                 }
3660
3661                 // if no intersecting containers found, return
3662                 if(!innermostContainer) return;
3663
3664                 // move the item into the container if it's not there already
3665                 if(this.containers.length === 1) {
3666                         this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
3667                         this.containers[innermostIndex].containerCache.over = 1;
3668                 } else if(this.currentContainer != this.containers[innermostIndex]) {
3669
3670                         //When entering a new container, we will find the item with the least distance and append our item near it
3671                         var dist = 10000; var itemWithLeastDistance = null; var base = this.positionAbs[this.containers[innermostIndex].floating ? 'left' : 'top'];
3672                         for (var j = this.items.length - 1; j >= 0; j--) {
3673                                 if(!$.ui.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) continue;
3674                                 var cur = this.items[j][this.containers[innermostIndex].floating ? 'left' : 'top'];
3675                                 if(Math.abs(cur - base) < dist) {
3676                                         dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
3677                                 }
3678                         }
3679
3680                         if(!itemWithLeastDistance && !this.options.dropOnEmpty) //Check if dropOnEmpty is enabled
3681                                 return;
3682
3683                         this.currentContainer = this.containers[innermostIndex];
3684                         itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
3685                         this._trigger("change", event, this._uiHash());
3686                         this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
3687
3688                         //Update the placeholder
3689                         this.options.placeholder.update(this.currentContainer, this.placeholder);
3690
3691                         this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
3692                         this.containers[innermostIndex].containerCache.over = 1;
3693                 }
3694
3695
3696         },
3697
3698         _createHelper: function(event) {
3699
3700                 var o = this.options;
3701                 var helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper == 'clone' ? this.currentItem.clone() : this.currentItem);
3702
3703                 if(!helper.parents('body').length) //Add the helper to the DOM if that didn't happen already
3704                         $(o.appendTo != 'parent' ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
3705
3706                 if(helper[0] == this.currentItem[0])
3707                         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") };
3708
3709                 if(helper[0].style.width == '' || o.forceHelperSize) helper.width(this.currentItem.width());
3710                 if(helper[0].style.height == '' || o.forceHelperSize) helper.height(this.currentItem.height());
3711
3712                 return helper;
3713
3714         },
3715
3716         _adjustOffsetFromHelper: function(obj) {
3717                 if (typeof obj == 'string') {
3718                         obj = obj.split(' ');
3719                 }
3720                 if ($.isArray(obj)) {
3721                         obj = {left: +obj[0], top: +obj[1] || 0};
3722                 }
3723                 if ('left' in obj) {
3724                         this.offset.click.left = obj.left + this.margins.left;
3725                 }
3726                 if ('right' in obj) {
3727                         this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
3728                 }
3729                 if ('top' in obj) {
3730                         this.offset.click.top = obj.top + this.margins.top;
3731                 }
3732                 if ('bottom' in obj) {
3733                         this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
3734                 }
3735         },
3736
3737         _getParentOffset: function() {
3738
3739
3740                 //Get the offsetParent and cache its position
3741                 this.offsetParent = this.helper.offsetParent();
3742                 var po = this.offsetParent.offset();
3743
3744                 // This is a special case where we need to modify a offset calculated on start, since the following happened:
3745                 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
3746                 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
3747                 //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
3748                 if(this.cssPosition == 'absolute' && this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) {
3749                         po.left += this.scrollParent.scrollLeft();
3750                         po.top += this.scrollParent.scrollTop();
3751                 }
3752
3753                 if((this.offsetParent[0] == document.body) //This needs to be actually done for all browsers, since pageX/pageY includes this information
3754                 || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.browser.msie)) //Ugly IE fix
3755                         po = { top: 0, left: 0 };
3756
3757                 return {
3758                         top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
3759                         left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
3760                 };
3761
3762         },
3763
3764         _getRelativeOffset: function() {
3765
3766                 if(this.cssPosition == "relative") {
3767                         var p = this.currentItem.position();
3768                         return {
3769                                 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
3770                                 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
3771                         };
3772                 } else {
3773                         return { top: 0, left: 0 };
3774                 }
3775
3776         },
3777
3778         _cacheMargins: function() {
3779                 this.margins = {
3780                         left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
3781                         top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
3782                 };
3783         },
3784
3785         _cacheHelperProportions: function() {
3786                 this.helperProportions = {
3787                         width: this.helper.outerWidth(),
3788                         height: this.helper.outerHeight()
3789                 };
3790         },
3791
3792         _setContainment: function() {
3793
3794                 var o = this.options;
3795                 if(o.containment == 'parent') o.containment = this.helper[0].parentNode;
3796                 if(o.containment == 'document' || o.containment == 'window') this.containment = [
3797                         0 - this.offset.relative.left - this.offset.parent.left,
3798                         0 - this.offset.relative.top - this.offset.parent.top,
3799                         $(o.containment == 'document' ? document : window).width() - this.helperProportions.width - this.margins.left,
3800                         ($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
3801                 ];
3802
3803                 if(!(/^(document|window|parent)$/).test(o.containment)) {
3804                         var ce = $(o.containment)[0];
3805                         var co = $(o.containment).offset();
3806                         var over = ($(ce).css("overflow") != 'hidden');
3807
3808                         this.containment = [
3809                                 co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
3810                                 co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
3811                                 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,
3812                                 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
3813                         ];
3814                 }
3815
3816         },
3817
3818         _convertPositionTo: function(d, pos) {
3819
3820                 if(!pos) pos = this.position;
3821                 var mod = d == "absolute" ? 1 : -1;
3822                 var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
3823
3824                 return {
3825                         top: (
3826                                 pos.top                                                                                                                                 // The absolute mouse position
3827                                 + this.offset.relative.top * mod                                                                                // Only for relative positioned nodes: Relative offset from element to offset parent
3828                                 + this.offset.parent.top * mod                                                                                  // The offsetParent's offset without borders (offset + border)
3829                                 - ($.browser.safari && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
3830                         ),
3831                         left: (
3832                                 pos.left                                                                                                                                // The absolute mouse position
3833                                 + this.offset.relative.left * mod                                                                               // Only for relative positioned nodes: Relative offset from element to offset parent
3834                                 + this.offset.parent.left * mod                                                                                 // The offsetParent's offset without borders (offset + border)
3835                                 - ($.browser.safari && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
3836                         )
3837                 };
3838
3839         },
3840
3841         _generatePosition: function(event) {
3842
3843                 var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
3844
3845                 // This is another very weird special case that only happens for relative elements:
3846                 // 1. If the css position is relative
3847                 // 2. and the scroll parent is the document or similar to the offset parent
3848                 // we have to refresh the relative offset during the scroll so there are no jumps
3849                 if(this.cssPosition == 'relative' && !(this.scrollParent[0] != document && this.scrollParent[0] != this.offsetParent[0])) {
3850                         this.offset.relative = this._getRelativeOffset();
3851                 }
3852
3853                 var pageX = event.pageX;
3854                 var pageY = event.pageY;
3855
3856                 /*
3857                  * - Position constraining -
3858                  * Constrain the position to a mix of grid, containment.
3859                  */
3860
3861                 if(this.originalPosition) { //If we are not dragging yet, we won't check for options
3862
3863                         if(this.containment) {
3864                                 if(event.pageX - this.offset.click.left < this.containment[0]) pageX = this.containment[0] + this.offset.click.left;
3865                                 if(event.pageY - this.offset.click.top < this.containment[1]) pageY = this.containment[1] + this.offset.click.top;
3866                                 if(event.pageX - this.offset.click.left > this.containment[2]) pageX = this.containment[2] + this.offset.click.left;
3867                                 if(event.pageY - this.offset.click.top > this.containment[3]) pageY = this.containment[3] + this.offset.click.top;
3868                         }
3869
3870                         if(o.grid) {
3871                                 var top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
3872                                 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;
3873
3874                                 var left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
3875                                 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;
3876                         }
3877
3878                 }
3879
3880                 return {
3881                         top: (
3882                                 pageY                                                                                                                           // The absolute mouse position
3883                                 - this.offset.click.top                                                                                                 // Click offset (relative to the element)
3884                                 - this.offset.relative.top                                                                                              // Only for relative positioned nodes: Relative offset from element to offset parent
3885                                 - this.offset.parent.top                                                                                                // The offsetParent's offset without borders (offset + border)
3886                                 + ($.browser.safari && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
3887                         ),
3888                         left: (
3889                                 pageX                                                                                                                           // The absolute mouse position
3890                                 - this.offset.click.left                                                                                                // Click offset (relative to the element)
3891                                 - this.offset.relative.left                                                                                             // Only for relative positioned nodes: Relative offset from element to offset parent
3892                                 - this.offset.parent.left                                                                                               // The offsetParent's offset without borders (offset + border)
3893                                 + ($.browser.safari && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
3894                         )
3895                 };
3896
3897         },
3898
3899         _rearrange: function(event, i, a, hardRefresh) {
3900
3901                 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));
3902
3903                 //Various things done here to improve the performance:
3904                 // 1. we create a setTimeout, that calls refreshPositions
3905                 // 2. on the instance, we have a counter variable, that get's higher after every append
3906                 // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
3907                 // 4. this lets only the last addition to the timeout stack through
3908                 this.counter = this.counter ? ++this.counter : 1;
3909                 var self = this, counter = this.counter;
3910
3911                 window.setTimeout(function() {
3912                         if(counter == self.counter) self.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
3913                 },0);
3914
3915         },
3916
3917         _clear: function(event, noPropagation) {
3918
3919                 this.reverting = false;
3920                 // We delay all events that have to be triggered to after the point where the placeholder has been removed and
3921                 // everything else normalized again
3922                 var delayedTriggers = [], self = this;
3923
3924                 // We first have to update the dom position of the actual currentItem
3925                 // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
3926                 if(!this._noFinalSort && this.currentItem[0].parentNode) this.placeholder.before(this.currentItem);
3927                 this._noFinalSort = null;
3928
3929                 if(this.helper[0] == this.currentItem[0]) {
3930                         for(var i in this._storedCSS) {
3931                                 if(this._storedCSS[i] == 'auto' || this._storedCSS[i] == 'static') this._storedCSS[i] = '';
3932                         }
3933                         this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
3934                 } else {
3935                         this.currentItem.show();
3936                 }
3937
3938                 if(this.fromOutside && !noPropagation) delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
3939                 if((this.fromOutside || this.domPosition.prev != this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent != this.currentItem.parent()[0]) && !noPropagation) delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
3940                 if(!$.ui.contains(this.element[0], this.currentItem[0])) { //Node was moved out of the current element
3941                         if(!noPropagation) delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
3942                         for (var i = this.containers.length - 1; i >= 0; i--){
3943                                 if($.ui.contains(this.containers[i].element[0], this.currentItem[0]) && !noPropagation) {
3944                                         delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
3945                                         delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this));  }; }).call(this, this.containers[i]));
3946                                 }
3947                         };
3948                 };
3949
3950                 //Post events to containers
3951                 for (var i = this.containers.length - 1; i >= 0; i--){
3952                         if(!noPropagation) delayedTriggers.push((function(c) { return function(event) { c._trigger("deactivate", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
3953                         if(this.containers[i].containerCache.over) {
3954                                 delayedTriggers.push((function(c) { return function(event) { c._trigger("out", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
3955                                 this.containers[i].containerCache.over = 0;
3956                         }
3957                 }
3958
3959                 //Do what was originally in plugins
3960                 if(this._storedCursor) $('body').css("cursor", this._storedCursor); //Reset cursor
3961                 if(this._storedOpacity) this.helper.css("opacity", this._storedOpacity); //Reset opacity
3962                 if(this._storedZIndex) this.helper.css("zIndex", this._storedZIndex == 'auto' ? '' : this._storedZIndex); //Reset z-index
3963
3964                 this.dragging = false;
3965                 if(this.cancelHelperRemoval) {
3966                         if(!noPropagation) {
3967                                 this._trigger("beforeStop", event, this._uiHash());
3968                                 for (var i=0; i < delayedTriggers.length; i++) { delayedTriggers[i].call(this, event); }; //Trigger all delayed events
3969                                 this._trigger("stop", event, this._uiHash());
3970                         }
3971                         return false;
3972                 }
3973
3974                 if(!noPropagation) this._trigger("beforeStop", event, this._uiHash());
3975
3976                 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
3977                 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
3978
3979                 if(this.helper[0] != this.currentItem[0]) this.helper.remove(); this.helper = null;
3980
3981                 if(!noPropagation) {
3982                         for (var i=0; i < delayedTriggers.length; i++) { delayedTriggers[i].call(this, event); }; //Trigger all delayed events
3983                         this._trigger("stop", event, this._uiHash());
3984                 }
3985
3986                 this.fromOutside = false;
3987                 return true;
3988
3989         },
3990
3991         _trigger: function() {
3992                 if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
3993                         this.cancel();
3994                 }
3995         },
3996
3997         _uiHash: function(inst) {
3998                 var self = inst || this;
3999                 return {
4000                         helper: self.helper,
4001                         placeholder: self.placeholder || $([]),
4002                         position: self.position,
4003                         originalPosition: self.originalPosition,
4004                         offset: self.positionAbs,
4005                         item: self.currentItem,
4006                         sender: inst ? inst.element : null
4007                 };
4008         }
4009
4010 });
4011
4012 $.extend($.ui.sortable, {
4013         version: "1.8"
4014 });
4015
4016 })(jQuery);
4017 /*
4018  * jQuery UI Accordion 1.8
4019  *
4020  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
4021  * Dual licensed under the MIT (MIT-LICENSE.txt)
4022  * and GPL (GPL-LICENSE.txt) licenses.
4023  *
4024  * http://docs.jquery.com/UI/Accordion
4025  *
4026  * Depends:
4027  *      jquery.ui.core.js
4028  *      jquery.ui.widget.js
4029  */
4030 (function($) {
4031
4032 $.widget("ui.accordion", {
4033         options: {
4034                 active: 0,
4035                 animated: 'slide',
4036                 autoHeight: true,
4037                 clearStyle: false,
4038                 collapsible: false,
4039                 event: "click",
4040                 fillSpace: false,
4041                 header: "> li > :first-child,> :not(li):even",
4042                 icons: {
4043                         header: "ui-icon-triangle-1-e",
4044                         headerSelected: "ui-icon-triangle-1-s"
4045                 },
4046                 navigation: false,
4047                 navigationFilter: function() {
4048                         return this.href.toLowerCase() == location.href.toLowerCase();
4049                 }
4050         },
4051         _create: function() {
4052
4053                 var o = this.options, self = this;
4054                 this.running = 0;
4055
4056                 this.element.addClass("ui-accordion ui-widget ui-helper-reset");
4057
4058                 // in lack of child-selectors in CSS we need to mark top-LIs in a UL-accordion for some IE-fix
4059                 if (this.element[0].nodeName == "UL") {
4060                         this.element.children("li").addClass("ui-accordion-li-fix");
4061                 }
4062
4063                 this.headers = this.element.find(o.header).addClass("ui-accordion-header ui-helper-reset ui-state-default ui-corner-all")
4064                         .bind("mouseenter.accordion", function(){ $(this).addClass('ui-state-hover'); })
4065                         .bind("mouseleave.accordion", function(){ $(this).removeClass('ui-state-hover'); })
4066                         .bind("focus.accordion", function(){ $(this).addClass('ui-state-focus'); })
4067                         .bind("blur.accordion", function(){ $(this).removeClass('ui-state-focus'); });
4068
4069                 this.headers
4070                         .next()
4071                                 .addClass("ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom");
4072
4073                 if ( o.navigation ) {
4074                         var current = this.element.find("a").filter(o.navigationFilter);
4075                         if ( current.length ) {
4076                                 var header = current.closest(".ui-accordion-header");
4077                                 if ( header.length ) {
4078                                         // anchor within header
4079                                         this.active = header;
4080                                 } else {
4081                                         // anchor within content
4082                                         this.active = current.closest(".ui-accordion-content").prev();
4083                                 }
4084                         }
4085                 }
4086
4087                 this.active = this._findActive(this.active || o.active).toggleClass("ui-state-default").toggleClass("ui-state-active").toggleClass("ui-corner-all").toggleClass("ui-corner-top");
4088                 this.active.next().addClass('ui-accordion-content-active');
4089
4090                 //Append icon elements
4091                 this._createIcons();
4092
4093                 // IE7-/Win - Extra vertical space in lists fixed
4094                 if ($.browser.msie) {
4095                         this.element.find('a').css('zoom', '1');
4096                 }
4097
4098                 this.resize();
4099
4100                 //ARIA
4101                 this.element.attr('role','tablist');
4102
4103                 this.headers
4104                         .attr('role','tab')
4105                         .bind('keydown', function(event) { return self._keydown(event); })
4106                         .next()
4107                         .attr('role','tabpanel');
4108
4109                 this.headers
4110                         .not(this.active || "")
4111                         .attr('aria-expanded','false')
4112                         .attr("tabIndex", "-1")
4113                         .next()
4114                         .hide();
4115
4116                 // make sure at least one header is in the tab order
4117                 if (!this.active.length) {
4118                         this.headers.eq(0).attr('tabIndex','0');
4119                 } else {
4120                         this.active
4121                                 .attr('aria-expanded','true')
4122                                 .attr('tabIndex', '0');
4123                 }
4124
4125                 // only need links in taborder for Safari
4126                 if (!$.browser.safari)
4127                         this.headers.find('a').attr('tabIndex','-1');
4128
4129                 if (o.event) {
4130                         this.headers.bind((o.event) + ".accordion", function(event) {
4131                                 self._clickHandler.call(self, event, this);
4132                                 event.preventDefault();
4133                         });
4134                 }
4135
4136         },
4137
4138         _createIcons: function() {
4139                 var o = this.options;
4140                 if (o.icons) {
4141                         $("<span/>").addClass("ui-icon " + o.icons.header).prependTo(this.headers);
4142                         this.active.find(".ui-icon").toggleClass(o.icons.header).toggleClass(o.icons.headerSelected);
4143                         this.element.addClass("ui-accordion-icons");
4144                 }
4145         },
4146
4147         _destroyIcons: function() {
4148                 this.headers.children(".ui-icon").remove();
4149                 this.element.removeClass("ui-accordion-icons");
4150         },
4151
4152         destroy: function() {
4153                 var o = this.options;
4154
4155                 this.element
4156                         .removeClass("ui-accordion ui-widget ui-helper-reset")
4157                         .removeAttr("role")
4158                         .unbind('.accordion')
4159                         .removeData('accordion');
4160
4161                 this.headers
4162                         .unbind(".accordion")
4163                         .removeClass("ui-accordion-header ui-helper-reset ui-state-default ui-corner-all ui-state-active ui-corner-top")
4164                         .removeAttr("role").removeAttr("aria-expanded").removeAttr("tabindex");
4165
4166                 this.headers.find("a").removeAttr("tabindex");
4167                 this._destroyIcons();
4168                 var contents = this.headers.next().css("display", "").removeAttr("role").removeClass("ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active");
4169                 if (o.autoHeight || o.fillHeight) {
4170                         contents.css("height", "");
4171                 }
4172
4173                 return this;
4174         },
4175
4176         _setOption: function(key, value) {
4177                 $.Widget.prototype._setOption.apply(this, arguments);
4178
4179                 if (key == "active") {
4180                         this.activate(value);
4181                 }
4182                 if (key == "icons") {
4183                         this._destroyIcons();
4184                         if (value) {
4185                                 this._createIcons();
4186                         }
4187                 }
4188
4189         },
4190
4191         _keydown: function(event) {
4192
4193                 var o = this.options, keyCode = $.ui.keyCode;
4194
4195                 if (o.disabled || event.altKey || event.ctrlKey)
4196                         return;
4197
4198                 var length = this.headers.length;
4199                 var currentIndex = this.headers.index(event.target);
4200                 var toFocus = false;
4201
4202                 switch(event.keyCode) {
4203                         case keyCode.RIGHT:
4204                         case keyCode.DOWN:
4205                                 toFocus = this.headers[(currentIndex + 1) % length];
4206                                 break;
4207                         case keyCode.LEFT:
4208                         case keyCode.UP:
4209                                 toFocus = this.headers[(currentIndex - 1 + length) % length];
4210                                 break;
4211                         case keyCode.SPACE:
4212                         case keyCode.ENTER:
4213                                 this._clickHandler({ target: event.target }, event.target);
4214                                 event.preventDefault();
4215                 }
4216
4217                 if (toFocus) {
4218                         $(event.target).attr('tabIndex','-1');
4219                         $(toFocus).attr('tabIndex','0');
4220                         toFocus.focus();
4221                         return false;
4222                 }
4223
4224                 return true;
4225
4226         },
4227
4228         resize: function() {
4229
4230                 var o = this.options, maxHeight;
4231
4232                 if (o.fillSpace) {
4233
4234                         if($.browser.msie) { var defOverflow = this.element.parent().css('overflow'); this.element.parent().css('overflow', 'hidden'); }
4235                         maxHeight = this.element.parent().height();
4236                         if($.browser.msie) { this.element.parent().css('overflow', defOverflow); }
4237
4238                         this.headers.each(function() {
4239                                 maxHeight -= $(this).outerHeight(true);
4240                         });
4241
4242                         this.headers.next().each(function() {
4243                    $(this).height(Math.max(0, maxHeight - $(this).innerHeight() + $(this).height()));
4244                         }).css('overflow', 'auto');
4245
4246                 } else if ( o.autoHeight ) {
4247                         maxHeight = 0;
4248                         this.headers.next().each(function() {
4249                                 maxHeight = Math.max(maxHeight, $(this).height());
4250                         }).height(maxHeight);
4251                 }
4252
4253                 return this;
4254         },
4255
4256         activate: function(index) {
4257                 // TODO this gets called on init, changing the option without an explicit call for that
4258                 this.options.active = index;
4259                 // call clickHandler with custom event
4260                 var active = this._findActive(index)[0];
4261                 this._clickHandler({ target: active }, active);
4262
4263                 return this;
4264         },
4265
4266         _findActive: function(selector) {
4267                 return selector
4268                         ? typeof selector == "number"
4269                                 ? this.headers.filter(":eq(" + selector + ")")
4270                                 : this.headers.not(this.headers.not(selector))
4271                         : selector === false
4272                                 ? $([])
4273                                 : this.headers.filter(":eq(0)");
4274         },
4275
4276         // TODO isn't event.target enough? why the seperate target argument?
4277         _clickHandler: function(event, target) {
4278
4279                 var o = this.options;
4280                 if (o.disabled)
4281                         return;
4282
4283                 // called only when using activate(false) to close all parts programmatically
4284                 if (!event.target) {
4285                         if (!o.collapsible)
4286                                 return;
4287                         this.active.removeClass("ui-state-active ui-corner-top").addClass("ui-state-default ui-corner-all")
4288                                 .find(".ui-icon").removeClass(o.icons.headerSelected).addClass(o.icons.header);
4289                         this.active.next().addClass('ui-accordion-content-active');
4290                         var toHide = this.active.next(),
4291                                 data = {
4292                                         options: o,
4293                                         newHeader: $([]),
4294                                         oldHeader: o.active,
4295                                         newContent: $([]),
4296                                         oldContent: toHide
4297                                 },
4298                                 toShow = (this.active = $([]));
4299                         this._toggle(toShow, toHide, data);
4300                         return;
4301                 }
4302
4303                 // get the click target
4304                 var clicked = $(event.currentTarget || target);
4305                 var clickedIsActive = clicked[0] == this.active[0];
4306
4307                 // TODO the option is changed, is that correct?
4308                 // TODO if it is correct, shouldn't that happen after determining that the click is valid?
4309                 o.active = o.collapsible && clickedIsActive ? false : $('.ui-accordion-header', this.element).index(clicked);
4310
4311                 // if animations are still active, or the active header is the target, ignore click
4312                 if (this.running || (!o.collapsible && clickedIsActive)) {
4313                         return;
4314                 }
4315
4316                 // switch classes
4317                 this.active.removeClass("ui-state-active ui-corner-top").addClass("ui-state-default ui-corner-all")
4318                         .find(".ui-icon").removeClass(o.icons.headerSelected).addClass(o.icons.header);
4319                 if (!clickedIsActive) {
4320                         clicked.removeClass("ui-state-default ui-corner-all").addClass("ui-state-active ui-corner-top")
4321                                 .find(".ui-icon").removeClass(o.icons.header).addClass(o.icons.headerSelected);
4322                         clicked.next().addClass('ui-accordion-content-active');
4323                 }
4324
4325                 // find elements to show and hide
4326                 var toShow = clicked.next(),
4327                         toHide = this.active.next(),
4328                         data = {
4329                                 options: o,
4330                                 newHeader: clickedIsActive && o.collapsible ? $([]) : clicked,
4331                                 oldHeader: this.active,
4332                                 newContent: clickedIsActive && o.collapsible ? $([]) : toShow,
4333                                 oldContent: toHide
4334                         },
4335                         down = this.headers.index( this.active[0] ) > this.headers.index( clicked[0] );
4336
4337                 this.active = clickedIsActive ? $([]) : clicked;
4338                 this._toggle(toShow, toHide, data, clickedIsActive, down);
4339
4340                 return;
4341
4342         },
4343
4344         _toggle: function(toShow, toHide, data, clickedIsActive, down) {
4345
4346                 var o = this.options, self = this;
4347
4348                 this.toShow = toShow;
4349                 this.toHide = toHide;
4350                 this.data = data;
4351
4352                 var complete = function() { if(!self) return; return self._completed.apply(self, arguments); };
4353
4354                 // trigger changestart event
4355                 this._trigger("changestart", null, this.data);
4356
4357                 // count elements to animate
4358                 this.running = toHide.size() === 0 ? toShow.size() : toHide.size();
4359
4360                 if (o.animated) {
4361
4362                         var animOptions = {};
4363
4364                         if ( o.collapsible && clickedIsActive ) {
4365                                 animOptions = {
4366                                         toShow: $([]),
4367                                         toHide: toHide,
4368                                         complete: complete,
4369                                         down: down,
4370                                         autoHeight: o.autoHeight || o.fillSpace
4371                                 };
4372                         } else {
4373                                 animOptions = {
4374                                         toShow: toShow,
4375                                         toHide: toHide,
4376                                         complete: complete,
4377                                         down: down,
4378                                         autoHeight: o.autoHeight || o.fillSpace
4379                                 };
4380                         }
4381
4382                         if (!o.proxied) {
4383                                 o.proxied = o.animated;
4384                         }
4385
4386                         if (!o.proxiedDuration) {
4387                                 o.proxiedDuration = o.duration;
4388                         }
4389
4390                         o.animated = $.isFunction(o.proxied) ?
4391                                 o.proxied(animOptions) : o.proxied;
4392
4393                         o.duration = $.isFunction(o.proxiedDuration) ?
4394                                 o.proxiedDuration(animOptions) : o.proxiedDuration;
4395
4396                         var animations = $.ui.accordion.animations,
4397                                 duration = o.duration,
4398                                 easing = o.animated;
4399
4400                         if (easing && !animations[easing] && !$.easing[easing]) {
4401                                 easing = 'slide';
4402                         }
4403                         if (!animations[easing]) {
4404                                 animations[easing] = function(options) {
4405                                         this.slide(options, {
4406                                                 easing: easing,
4407                                                 duration: duration || 700
4408                                         });
4409                                 };
4410                         }
4411
4412                         animations[easing](animOptions);
4413
4414                 } else {
4415
4416                         if (o.collapsible && clickedIsActive) {
4417                                 toShow.toggle();
4418                         } else {
4419                                 toHide.hide();
4420                                 toShow.show();
4421                         }
4422
4423                         complete(true);
4424
4425                 }
4426
4427                 // TODO assert that the blur and focus triggers are really necessary, remove otherwise
4428                 toHide.prev().attr('aria-expanded','false').attr("tabIndex", "-1").blur();
4429                 toShow.prev().attr('aria-expanded','true').attr("tabIndex", "0").focus();
4430
4431         },
4432
4433         _completed: function(cancel) {
4434
4435                 var o = this.options;
4436
4437                 this.running = cancel ? 0 : --this.running;
4438                 if (this.running) return;
4439
4440                 if (o.clearStyle) {
4441                         this.toShow.add(this.toHide).css({
4442                                 height: "",
4443                                 overflow: ""
4444                         });
4445                 }
4446
4447                 // other classes are removed before the animation; this one needs to stay until completed
4448                 this.toHide.removeClass("ui-accordion-content-active");
4449
4450                 this._trigger('change', null, this.data);
4451         }
4452
4453 });
4454
4455
4456 $.extend($.ui.accordion, {
4457         version: "1.8",
4458         animations: {
4459                 slide: function(options, additions) {
4460                         options = $.extend({
4461                                 easing: "swing",
4462                                 duration: 300
4463                         }, options, additions);
4464                         if ( !options.toHide.size() ) {
4465                                 options.toShow.animate({height: "show"}, options);
4466                                 return;
4467                         }
4468                         if ( !options.toShow.size() ) {
4469                                 options.toHide.animate({height: "hide"}, options);
4470                                 return;
4471                         }
4472                         var overflow = options.toShow.css('overflow'),
4473                                 percentDone = 0,
4474                                 showProps = {},
4475                                 hideProps = {},
4476                                 fxAttrs = [ "height", "paddingTop", "paddingBottom" ],
4477                                 originalWidth;
4478                         // fix width before calculating height of hidden element
4479                         var s = options.toShow;
4480                         originalWidth = s[0].style.width;
4481                         s.width( parseInt(s.parent().width(),10) - parseInt(s.css("paddingLeft"),10) - parseInt(s.css("paddingRight"),10) - (parseInt(s.css("borderLeftWidth"),10) || 0) - (parseInt(s.css("borderRightWidth"),10) || 0) );
4482
4483                         $.each(fxAttrs, function(i, prop) {
4484                                 hideProps[prop] = 'hide';
4485
4486                                 var parts = ('' + $.css(options.toShow[0], prop)).match(/^([\d+-.]+)(.*)$/);
4487                                 showProps[prop] = {
4488                                         value: parts[1],
4489                                         unit: parts[2] || 'px'
4490                                 };
4491                         });
4492                         options.toShow.css({ height: 0, overflow: 'hidden' }).show();
4493                         options.toHide.filter(":hidden").each(options.complete).end().filter(":visible").animate(hideProps,{
4494                                 step: function(now, settings) {
4495                                         // only calculate the percent when animating height
4496                                         // IE gets very inconsistent results when animating elements
4497                                         // with small values, which is common for padding
4498                                         if (settings.prop == 'height') {
4499                                                 percentDone = ( settings.end - settings.start === 0 ) ? 0 :
4500                                                         (settings.now - settings.start) / (settings.end - settings.start);
4501                                         }
4502
4503                                         options.toShow[0].style[settings.prop] =
4504                                                 (percentDone * showProps[settings.prop].value) + showProps[settings.prop].unit;
4505                                 },
4506                                 duration: options.duration,
4507                                 easing: options.easing,
4508                                 complete: function() {
4509                                         if ( !options.autoHeight ) {
4510                                                 options.toShow.css("height", "");
4511                                         }
4512                                         options.toShow.css("width", originalWidth);
4513                                         options.toShow.css({overflow: overflow});
4514                                         options.complete();
4515                                 }
4516                         });
4517                 },
4518                 bounceslide: function(options) {
4519                         this.slide(options, {
4520                                 easing: options.down ? "easeOutBounce" : "swing",
4521                                 duration: options.down ? 1000 : 200
4522                         });
4523                 }
4524         }
4525 });
4526
4527 })(jQuery);
4528 /*
4529  * jQuery UI Autocomplete 1.8
4530  *
4531  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
4532  * Dual licensed under the MIT (MIT-LICENSE.txt)
4533  * and GPL (GPL-LICENSE.txt) licenses.
4534  *
4535  * http://docs.jquery.com/UI/Autocomplete
4536  *
4537  * Depends:
4538  *      jquery.ui.core.js
4539  *      jquery.ui.widget.js
4540  *      jquery.ui.position.js
4541  */
4542 (function( $ ) {
4543
4544 $.widget( "ui.autocomplete", {
4545         options: {
4546                 minLength: 1,
4547                 delay: 300
4548         },
4549         _create: function() {
4550                 var self = this,
4551                         doc = this.element[ 0 ].ownerDocument;
4552                 this.element
4553                         .addClass( "ui-autocomplete-input" )
4554                         .attr( "autocomplete", "off" )
4555                         // TODO verify these actually work as intended
4556                         .attr({
4557                                 role: "textbox",
4558                                 "aria-autocomplete": "list",
4559                                 "aria-haspopup": "true"
4560                         })
4561                         .bind( "keydown.autocomplete", function( event ) {
4562                                 var keyCode = $.ui.keyCode;
4563                                 switch( event.keyCode ) {
4564                                 case keyCode.PAGE_UP:
4565                                         self._move( "previousPage", event );
4566                                         break;
4567                                 case keyCode.PAGE_DOWN:
4568                                         self._move( "nextPage", event );
4569                                         break;
4570                                 case keyCode.UP:
4571                                         self._move( "previous", event );
4572                                         // prevent moving cursor to beginning of text field in some browsers
4573                                         event.preventDefault();
4574                                         break;
4575                                 case keyCode.DOWN:
4576                                         self._move( "next", event );
4577                                         // prevent moving cursor to end of text field in some browsers
4578                                         event.preventDefault();
4579                                         break;
4580                                 case keyCode.ENTER:
4581                                         // when menu is open or has focus
4582                                         if ( self.menu.active ) {
4583                                                 event.preventDefault();
4584                                         }
4585                                         //passthrough - ENTER and TAB both select the current element
4586                                 case keyCode.TAB:
4587                                         if ( !self.menu.active ) {
4588                                                 return;
4589                                         }
4590                                         self.menu.select();
4591                                         break;
4592                                 case keyCode.ESCAPE:
4593                                         self.element.val( self.term );
4594                                         self.close( event );
4595                                         break;
4596                                 case keyCode.SHIFT:
4597                                 case keyCode.CONTROL:
4598                                 case 18:
4599                                         // ignore metakeys (shift, ctrl, alt)
4600                                         break;
4601                                 default:
4602                                         // keypress is triggered before the input value is changed
4603                                         clearTimeout( self.searching );
4604                                         self.searching = setTimeout(function() {
4605                                                 self.search( null, event );
4606                                         }, self.options.delay );
4607                                         break;
4608                                 }
4609                         })
4610                         .bind( "focus.autocomplete", function() {
4611                                 self.previous = self.element.val();
4612                         })
4613                         .bind( "blur.autocomplete", function( event ) {
4614                                 clearTimeout( self.searching );
4615                                 // clicks on the menu (or a button to trigger a search) will cause a blur event
4616                                 // TODO try to implement this without a timeout, see clearTimeout in search()
4617                                 self.closing = setTimeout(function() {
4618                                         self.close( event );
4619                                 }, 150 );
4620                         });
4621                 this._initSource();
4622                 this.response = function() {
4623                         return self._response.apply( self, arguments );
4624                 };
4625                 this.menu = $( "<ul></ul>" )
4626                         .addClass( "ui-autocomplete" )
4627                         .appendTo( "body", doc )
4628                         .menu({
4629                                 focus: function( event, ui ) {
4630                                         var item = ui.item.data( "item.autocomplete" );
4631                                         if ( false !== self._trigger( "focus", null, { item: item } ) ) {
4632                                                 // use value to match what will end up in the input
4633                                                 self.element.val( item.value );
4634                                         }
4635                                 },
4636                                 selected: function( event, ui ) {
4637                                         var item = ui.item.data( "item.autocomplete" );
4638                                         if ( false !== self._trigger( "select", event, { item: item } ) ) {
4639                                                 self.element.val( item.value );
4640                                         }
4641                                         self.close( event );
4642                                         self.previous = self.element.val();
4643                                         // only trigger when focus was lost (click on menu)
4644                                         if ( self.element[0] !== doc.activeElement ) {
4645                                                 self.element.focus();
4646                                         }
4647                                 },
4648                                 blur: function( event, ui ) {
4649                                         if ( self.menu.element.is(":visible") ) {
4650                                                 self.element.val( self.term );
4651                                         }
4652                                 }
4653                         })
4654                         .zIndex( this.element.zIndex() + 1 )
4655                         // workaround for jQuery bug #5781 http://dev.jquery.com/ticket/5781
4656                         .css({ top: 0, left: 0 })
4657                         .hide()
4658                         .data( "menu" );
4659                 if ( $.fn.bgiframe ) {
4660                          this.menu.element.bgiframe();
4661                 }
4662         },
4663
4664         destroy: function() {
4665                 this.element
4666                         .removeClass( "ui-autocomplete-input ui-widget ui-widget-content" )
4667                         .removeAttr( "autocomplete" )
4668                         .removeAttr( "role" )
4669                         .removeAttr( "aria-autocomplete" )
4670                         .removeAttr( "aria-haspopup" );
4671                 this.menu.element.remove();
4672                 $.Widget.prototype.destroy.call( this );
4673         },
4674
4675         _setOption: function( key ) {
4676                 $.Widget.prototype._setOption.apply( this, arguments );
4677                 if ( key === "source" ) {
4678                         this._initSource();
4679                 }
4680         },
4681
4682         _initSource: function() {
4683                 var array,
4684                         url;
4685                 if ( $.isArray(this.options.source) ) {
4686                         array = this.options.source;
4687                         this.source = function( request, response ) {
4688                                 // escape regex characters
4689                                 var matcher = new RegExp( $.ui.autocomplete.escapeRegex(request.term), "i" );
4690                                 response( $.grep( array, function(value) {
4691                                         return matcher.test( value.label || value.value || value );
4692                                 }) );
4693                         };
4694                 } else if ( typeof this.options.source === "string" ) {
4695                         url = this.options.source;
4696                         this.source = function( request, response ) {
4697                                 $.getJSON( url, request, response );
4698                         };
4699                 } else {
4700                         this.source = this.options.source;
4701                 }
4702         },
4703
4704         search: function( value, event ) {
4705                 value = value != null ? value : this.element.val();
4706                 if ( value.length < this.options.minLength ) {
4707                         return this.close( event );
4708                 }
4709
4710                 clearTimeout( this.closing );
4711                 if ( this._trigger("search") === false ) {
4712                         return;
4713                 }
4714
4715                 return this._search( value );
4716         },
4717
4718         _search: function( value ) {
4719                 this.term = this.element
4720                         .addClass( "ui-autocomplete-loading" )
4721                         // always save the actual value, not the one passed as an argument
4722                         .val();
4723
4724                 this.source( { term: value }, this.response );
4725         },
4726
4727         _response: function( content ) {
4728                 if ( content.length ) {
4729                         content = this._normalize( content );
4730                         this._suggest( content );
4731                         this._trigger( "open" );
4732                 } else {
4733                         this.close();
4734                 }
4735                 this.element.removeClass( "ui-autocomplete-loading" );
4736         },
4737
4738         close: function( event ) {
4739                 clearTimeout( this.closing );
4740                 if ( this.menu.element.is(":visible") ) {
4741                         this._trigger( "close", event );
4742                         this.menu.element.hide();
4743                         this.menu.deactivate();
4744                 }
4745                 if ( this.previous !== this.element.val() ) {
4746                         this._trigger( "change", event );
4747                 }
4748         },
4749
4750         _normalize: function( items ) {
4751                 // assume all items have the right format when the first item is complete
4752                 if ( items.length && items[0].label && items[0].value ) {
4753                         return items;
4754                 }
4755                 return $.map( items, function(item) {
4756                         if ( typeof item === "string" ) {
4757                                 return {
4758                                         label: item,
4759                                         value: item
4760                                 };
4761                         }
4762                         return $.extend({
4763                                 label: item.label || item.value,
4764                                 value: item.value || item.label
4765                         }, item );
4766                 });
4767         },
4768
4769         _suggest: function( items ) {
4770                 var ul = this.menu.element
4771                                 .empty()
4772                                 .zIndex( this.element.zIndex() + 1 ),
4773                         menuWidth,
4774                         textWidth;
4775                 this._renderMenu( ul, items );
4776                 // TODO refresh should check if the active item is still in the dom, removing the need for a manual deactivate
4777                 this.menu.deactivate();
4778                 this.menu.refresh();
4779                 this.menu.element.show().position({
4780                         my: "left top",
4781                         at: "left bottom",
4782                         of: this.element,
4783                         collision: "none"
4784                 });
4785
4786                 menuWidth = ul.width( "" ).width();
4787                 textWidth = this.element.width();
4788                 ul.width( Math.max( menuWidth, textWidth ) );
4789         },
4790
4791         _renderMenu: function( ul, items ) {
4792                 var self = this;
4793                 $.each( items, function( index, item ) {
4794                         self._renderItem( ul, item );
4795                 });
4796         },
4797
4798         _renderItem: function( ul, item) {
4799                 return $( "<li></li>" )
4800                         .data( "item.autocomplete", item )
4801                         .append( "<a>" + item.label + "</a>" )
4802                         .appendTo( ul );
4803         },
4804
4805         _move: function( direction, event ) {
4806                 if ( !this.menu.element.is(":visible") ) {
4807                         this.search( null, event );
4808                         return;
4809                 }
4810                 if ( this.menu.first() && /^previous/.test(direction) ||
4811                                 this.menu.last() && /^next/.test(direction) ) {
4812                         this.element.val( this.term );
4813                         this.menu.deactivate();
4814                         return;
4815                 }
4816                 this.menu[ direction ]();
4817         },
4818
4819         widget: function() {
4820                 return this.menu.element;
4821         }
4822 });
4823
4824 $.extend( $.ui.autocomplete, {
4825         escapeRegex: function( value ) {
4826                 return value.replace( /([\^\$\(\)\[\]\{\}\*\.\+\?\|\\])/gi, "\\$1" );
4827         }
4828 });
4829
4830 }( jQuery ));
4831
4832 /*
4833  * jQuery UI Menu (not officially released)
4834  *
4835  * This widget isn't yet finished and the API is subject to change. We plan to finish
4836  * it for the next release. You're welcome to give it a try anyway and give us feedback,
4837  * as long as you're okay with migrating your code later on. We can help with that, too.
4838  *
4839  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
4840  * Dual licensed under the MIT (MIT-LICENSE.txt)
4841  * and GPL (GPL-LICENSE.txt) licenses.
4842  *
4843  * http://docs.jquery.com/UI/Menu
4844  *
4845  * Depends:
4846  *      jquery.ui.core.js
4847  *  jquery.ui.widget.js
4848  */
4849 (function($) {
4850
4851 $.widget("ui.menu", {
4852         _create: function() {
4853                 var self = this;
4854                 this.element
4855                         .addClass("ui-menu ui-widget ui-widget-content ui-corner-all")
4856                         .attr({
4857                                 role: "listbox",
4858                                 "aria-activedescendant": "ui-active-menuitem"
4859                         })
4860                         .click(function(e) {
4861                                 // temporary
4862                                 e.preventDefault();
4863                                 self.select();
4864                         });
4865                 this.refresh();
4866         },
4867
4868         refresh: function() {
4869                 var self = this;
4870
4871                 // don't refresh list items that are already adapted
4872                 var items = this.element.children("li:not(.ui-menu-item):has(a)")
4873                         .addClass("ui-menu-item")
4874                         .attr("role", "menuitem");
4875
4876                 items.children("a")
4877                         .addClass("ui-corner-all")
4878                         .attr("tabindex", -1)
4879                         // mouseenter doesn't work with event delegation
4880                         .mouseenter(function() {
4881                                 self.activate($(this).parent());
4882                         })
4883                         .mouseleave(function() {
4884                                 self.deactivate();
4885                         });
4886         },
4887
4888         activate: function(item) {
4889                 this.deactivate();
4890                 if (this.hasScroll()) {
4891                         var offset = item.offset().top - this.element.offset().top,
4892                                 scroll = this.element.attr("scrollTop"),
4893                                 elementHeight = this.element.height();
4894                         if (offset < 0) {
4895                                 this.element.attr("scrollTop", scroll + offset);
4896                         } else if (offset > elementHeight) {
4897                                 this.element.attr("scrollTop", scroll + offset - elementHeight + item.height());
4898                         }
4899                 }
4900                 this.active = item.eq(0)
4901                         .children("a")
4902                                 .addClass("ui-state-hover")
4903                                 .attr("id", "ui-active-menuitem")
4904                         .end();
4905                 this._trigger("focus", null, { item: item });
4906         },
4907
4908         deactivate: function() {
4909                 if (!this.active) { return; }
4910
4911                 this.active.children("a")
4912                         .removeClass("ui-state-hover")
4913                         .removeAttr("id");
4914                 this._trigger("blur");
4915                 this.active = null;
4916         },
4917
4918         next: function() {
4919                 this.move("next", "li:first");
4920         },
4921
4922         previous: function() {
4923                 this.move("prev", "li:last");
4924         },
4925
4926         first: function() {
4927                 return this.active && !this.active.prev().length;
4928         },
4929
4930         last: function() {
4931                 return this.active && !this.active.next().length;
4932         },
4933
4934         move: function(direction, edge) {
4935                 if (!this.active) {
4936                         this.activate(this.element.children(edge));
4937                         return;
4938                 }
4939                 var next = this.active[direction]();
4940                 if (next.length) {
4941                         this.activate(next);
4942                 } else {
4943                         this.activate(this.element.children(edge));
4944                 }
4945         },
4946
4947         // TODO merge with previousPage
4948         nextPage: function() {
4949                 if (this.hasScroll()) {
4950                         // TODO merge with no-scroll-else
4951                         if (!this.active || this.last()) {
4952                                 this.activate(this.element.children(":first"));
4953                                 return;
4954                         }
4955                         var base = this.active.offset().top,
4956                                 height = this.element.height(),
4957                                 result = this.element.children("li").filter(function() {
4958                                         var close = $(this).offset().top - base - height + $(this).height();
4959                                         // TODO improve approximation
4960                                         return close < 10 && close > -10;
4961                                 });
4962
4963                         // TODO try to catch this earlier when scrollTop indicates the last page anyway
4964                         if (!result.length) {
4965                                 result = this.element.children(":last");
4966                         }
4967                         this.activate(result);
4968                 } else {
4969                         this.activate(this.element.children(!this.active || this.last() ? ":first" : ":last"));
4970                 }
4971         },
4972
4973         // TODO merge with nextPage
4974         previousPage: function() {
4975                 if (this.hasScroll()) {
4976                         // TODO merge with no-scroll-else
4977                         if (!this.active || this.first()) {
4978                                 this.activate(this.element.children(":last"));
4979                                 return;
4980                         }
4981
4982                         var base = this.active.offset().top,
4983                                 height = this.element.height();
4984                                 result = this.element.children("li").filter(function() {
4985                                         var close = $(this).offset().top - base + height - $(this).height();
4986                                         // TODO improve approximation
4987                                         return close < 10 && close > -10;
4988                                 });
4989
4990                         // TODO try to catch this earlier when scrollTop indicates the last page anyway
4991                         if (!result.length) {
4992                                 result = this.element.children(":first");
4993                         }
4994                         this.activate(result);
4995                 } else {
4996                         this.activate(this.element.children(!this.active || this.first() ? ":last" : ":first"));
4997                 }
4998         },
4999
5000         hasScroll: function() {
5001                 return this.element.height() < this.element.attr("scrollHeight");
5002         },
5003
5004         select: function() {
5005                 this._trigger("selected", null, { item: this.active });
5006         }
5007 });
5008
5009 }(jQuery));
5010 /*
5011  * jQuery UI Button 1.8
5012  *
5013  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
5014  * Dual licensed under the MIT (MIT-LICENSE.txt)
5015  * and GPL (GPL-LICENSE.txt) licenses.
5016  *
5017  * http://docs.jquery.com/UI/Button
5018  *
5019  * Depends:
5020  *      jquery.ui.core.js
5021  *      jquery.ui.widget.js
5022  */
5023 (function( $ ) {
5024
5025 var lastActive,
5026         baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
5027         otherClasses = "ui-state-hover ui-state-active " +
5028                 "ui-button-icons-only ui-button-icon-only ui-button-text-icons ui-button-text-icon ui-button-text-only",
5029         formResetHandler = function( event ) {
5030                 $( ":ui-button", event.target.form ).each(function() {
5031                         var inst = $( this ).data( "button" );
5032                         setTimeout(function() {
5033                                 inst.refresh();
5034                         }, 1 );
5035                 });
5036         },
5037         radioGroup = function( radio ) {
5038                 var name = radio.name,
5039                         form = radio.form,
5040                         radios = $( [] );
5041                 if ( name ) {
5042                         if ( form ) {
5043                                 radios = $( form ).find( "[name='" + name + "']" );
5044                         } else {
5045                                 radios = $( "[name='" + name + "']", radio.ownerDocument )
5046                                         .filter(function() {
5047                                                 return !this.form;
5048                                         });
5049                         }
5050                 }
5051                 return radios;
5052         };
5053
5054 $.widget( "ui.button", {
5055         options: {
5056                 text: true,
5057                 label: null,
5058                 icons: {
5059                         primary: null,
5060                         secondary: null
5061                 }
5062         },
5063         _create: function() {
5064                 this.element.closest( "form" )
5065                         .unbind( "reset.button" )
5066                         .bind( "reset.button", formResetHandler );
5067
5068                 this._determineButtonType();
5069                 this.hasTitle = !!this.buttonElement.attr( "title" );
5070
5071                 var self = this,
5072                         options = this.options,
5073                         toggleButton = this.type === "checkbox" || this.type === "radio",
5074                         hoverClass = "ui-state-hover" + ( !toggleButton ? " ui-state-active" : "" ),
5075                         focusClass = "ui-state-focus";
5076
5077                 if ( options.label === null ) {
5078                         options.label = this.buttonElement.html();
5079                 }
5080
5081                 if ( this.element.is( ":disabled" ) ) {
5082                         options.disabled = true;
5083                 }
5084
5085                 this.buttonElement
5086                         .addClass( baseClasses )
5087                         .attr( "role", "button" )
5088                         .bind( "mouseenter.button", function() {
5089                                 if ( options.disabled ) {
5090                                         return;
5091                                 }
5092                                 $( this ).addClass( "ui-state-hover" );
5093                                 if ( this === lastActive ) {
5094                                         $( this ).addClass( "ui-state-active" );
5095                                 }
5096                         })
5097                         .bind( "mouseleave.button", function() {
5098                                 if ( options.disabled ) {
5099                                         return;
5100                                 }
5101                                 $( this ).removeClass( hoverClass );
5102                         })
5103                         .bind( "focus.button", function() {
5104                                 // no need to check disabled, focus won't be triggered anyway
5105                                 $( this ).addClass( focusClass );
5106                         })
5107                         .bind( "blur.button", function() {
5108                                 $( this ).removeClass( focusClass );
5109                         });
5110
5111                 if ( toggleButton ) {
5112                         this.element.bind( "change.button", function() {
5113                                 self.refresh();
5114                         });
5115                 }
5116
5117                 if ( this.type === "checkbox" ) {
5118                         this.buttonElement.bind( "click.button", function() {
5119                                 if ( options.disabled ) {
5120                                         return false;
5121                                 }
5122                                 $( this ).toggleClass( "ui-state-active" );
5123                                 self.buttonElement.attr( "aria-pressed", self.element[0].checked );
5124                         });
5125                 } else if ( this.type === "radio" ) {
5126                         this.buttonElement.bind( "click.button", function() {
5127                                 if ( options.disabled ) {
5128                                         return false;
5129                                 }
5130                                 $( this ).addClass( "ui-state-active" );
5131                                 self.buttonElement.attr( "aria-pressed", true );
5132
5133                                 var radio = self.element[ 0 ];
5134                                 radioGroup( radio )
5135                                         .not( radio )
5136                                         .map(function() {
5137                                                 return $( this ).button( "widget" )[ 0 ];
5138                                         })
5139                                         .removeClass( "ui-state-active" )
5140                                         .attr( "aria-pressed", false );
5141                         });
5142                 } else {
5143                         this.buttonElement
5144                                 .bind( "mousedown.button", function() {
5145                                         if ( options.disabled ) {
5146                                                 return false;
5147                                         }
5148                                         $( this ).addClass( "ui-state-active" );
5149                                         lastActive = this;
5150                                         $( document ).one( "mouseup", function() {
5151                                                 lastActive = null;
5152                                         });
5153                                 })
5154                                 .bind( "mouseup.button", function() {
5155                                         if ( options.disabled ) {
5156                                                 return false;
5157                                         }
5158                                         $( this ).removeClass( "ui-state-active" );
5159                                 })
5160                                 .bind( "keydown.button", function(event) {
5161                                         if ( options.disabled ) {
5162                                                 return false;
5163                                         }
5164                                         if ( event.keyCode == $.ui.keyCode.SPACE || event.keyCode == $.ui.keyCode.ENTER ) {
5165                                                 $( this ).addClass( "ui-state-active" );
5166                                         }
5167                                 })
5168                                 .bind( "keyup.button", function() {
5169                                         $( this ).removeClass( "ui-state-active" );
5170                                 });
5171
5172                         if ( this.buttonElement.is("a") ) {
5173                                 this.buttonElement.keyup(function(event) {
5174                                         if ( event.keyCode === $.ui.keyCode.SPACE ) {
5175                                                 // TODO pass through original event correctly (just as 2nd argument doesn't work)
5176                                                 $( this ).click();
5177                                         }
5178                                 });
5179                         }
5180                 }
5181
5182                 // TODO: pull out $.Widget's handling for the disabled option into
5183                 // $.Widget.prototype._setOptionDisabled so it's easy to proxy and can
5184                 // be overridden by individual plugins
5185                 this._setOption( "disabled", options.disabled );
5186         },
5187
5188         _determineButtonType: function() {
5189
5190                 if ( this.element.is(":checkbox") ) {
5191                         this.type = "checkbox";
5192                 } else {
5193                         if ( this.element.is(":radio") ) {
5194                                 this.type = "radio";
5195                         } else {
5196                                 if ( this.element.is("input") ) {
5197                                         this.type = "input";
5198                                 } else {
5199                                         this.type = "button";
5200                                 }
5201                         }
5202                 }
5203
5204                 if ( this.type === "checkbox" || this.type === "radio" ) {
5205                         // we don't search against the document in case the element
5206                         // is disconnected from the DOM
5207                         this.buttonElement = this.element.parents().last()
5208                                 .find( "[for=" + this.element.attr("id") + "]" );
5209                         this.element.addClass( "ui-helper-hidden-accessible" );
5210
5211                         var checked = this.element.is( ":checked" );
5212                         if ( checked ) {
5213                                 this.buttonElement.addClass( "ui-state-active" );
5214                         }
5215                         this.buttonElement.attr( "aria-pressed", checked );
5216                 } else {
5217                         this.buttonElement = this.element;
5218                 }
5219         },
5220
5221         widget: function() {
5222                 return this.buttonElement;
5223         },
5224
5225         destroy: function() {
5226                 this.element
5227                         .removeClass( "ui-helper-hidden-accessible" );
5228                 this.buttonElement
5229                         .removeClass( baseClasses + " " + otherClasses )
5230                         .removeAttr( "role" )
5231                         .removeAttr( "aria-pressed" )
5232                         .html( this.buttonElement.find(".ui-button-text").html() );
5233
5234                 if ( !this.hasTitle ) {
5235                         this.buttonElement.removeAttr( "title" );
5236                 }
5237
5238                 $.Widget.prototype.destroy.call( this );
5239         },
5240
5241         _setOption: function( key, value ) {
5242                 $.Widget.prototype._setOption.apply( this, arguments );
5243                 if ( key === "disabled" ) {
5244                         if ( value ) {
5245                                 this.element.attr( "disabled", true );
5246                         } else {
5247                                 this.element.removeAttr( "disabled" );
5248                         }
5249                 }
5250                 this._resetButton();
5251         },
5252
5253         refresh: function() {
5254                 var isDisabled = this.element.is( ":disabled" );
5255                 if ( isDisabled !== this.options.disabled ) {
5256                         this._setOption( "disabled", isDisabled );
5257                 }
5258                 if ( this.type === "radio" ) {
5259                         radioGroup( this.element[0] ).each(function() {
5260                                 if ( $( this ).is( ":checked" ) ) {
5261                                         $( this ).button( "widget" )
5262                                                 .addClass( "ui-state-active" )
5263                                                 .attr( "aria-pressed", true );
5264                                 } else {
5265                                         $( this ).button( "widget" )
5266                                                 .removeClass( "ui-state-active" )
5267                                                 .attr( "aria-pressed", false );
5268                                 }
5269                         });
5270                 } else if ( this.type === "checkbox" ) {
5271                         if ( this.element.is( ":checked" ) ) {
5272                                 this.buttonElement
5273                                         .addClass( "ui-state-active" )
5274                                         .attr( "aria-pressed", true );
5275                         } else {
5276                                 this.buttonElement
5277                                         .removeClass( "ui-state-active" )
5278                                         .attr( "aria-pressed", false );
5279                         }
5280                 }
5281         },
5282
5283         _resetButton: function() {
5284                 if ( this.type === "input" ) {
5285                         if ( this.options.label ) {
5286                                 this.element.val( this.options.label );
5287                         }
5288                         return;
5289                 }
5290                 var buttonElement = this.buttonElement,
5291                         buttonText = $( "<span></span>" )
5292                                 .addClass( "ui-button-text" )
5293                                 .html( this.options.label )
5294                                 .appendTo( buttonElement.empty() )
5295                                 .text(),
5296                         icons = this.options.icons,
5297                         multipleIcons = icons.primary && icons.secondary;
5298                 if ( icons.primary || icons.secondary ) {
5299                         buttonElement.addClass( "ui-button-text-icon" +
5300                                 ( multipleIcons ? "s" : "" ) );
5301                         if ( icons.primary ) {
5302                                 buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
5303                         }
5304                         if ( icons.secondary ) {
5305                                 buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
5306                         }
5307                         if ( !this.options.text ) {
5308                                 buttonElement
5309                                         .addClass( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" )
5310                                         .removeClass( "ui-button-text-icons ui-button-text-icon" );
5311                                 if ( !this.hasTitle ) {
5312                                         buttonElement.attr( "title", buttonText );
5313                                 }
5314                         }
5315                 } else {
5316                         buttonElement.addClass( "ui-button-text-only" );
5317                 }
5318         }
5319 });
5320
5321 $.widget( "ui.buttonset", {
5322         _create: function() {
5323                 this.element.addClass( "ui-buttonset" );
5324                 this._init();
5325         },
5326
5327         _init: function() {
5328                 this.refresh();
5329         },
5330
5331         _setOption: function( key, value ) {
5332                 if ( key === "disabled" ) {
5333                         this.buttons.button( "option", key, value );
5334                 }
5335
5336                 $.Widget.prototype._setOption.apply( this, arguments );
5337         },
5338
5339         refresh: function() {
5340                 this.buttons = this.element.find( ":button, :submit, :reset, :checkbox, :radio, a, :data(button)" )
5341                         .filter( ":ui-button" )
5342                                 .button( "refresh" )
5343                         .end()
5344                         .not( ":ui-button" )
5345                                 .button()
5346                         .end()
5347                         .map(function() {
5348                                 return $( this ).button( "widget" )[ 0 ];
5349                         })
5350                                 .removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
5351                                 .filter( ":first" )
5352                                         .addClass( "ui-corner-left" )
5353                                 .end()
5354                                 .filter( ":last" )
5355                                         .addClass( "ui-corner-right" )
5356                                 .end()
5357                         .end();
5358         },
5359
5360         destroy: function() {
5361                 this.element.removeClass( "ui-buttonset" );
5362                 this.buttons
5363                         .map(function() {
5364                                 return $( this ).button( "widget" )[ 0 ];
5365                         })
5366                                 .removeClass( "ui-corner-left ui-corner-right" )
5367                         .end()
5368                         .button( "destroy" )
5369
5370                 $.Widget.prototype.destroy.call( this );
5371         }
5372 });
5373
5374 }( jQuery ) );
5375 /*
5376  * jQuery UI Dialog 1.8
5377  *
5378  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
5379  * Dual licensed under the MIT (MIT-LICENSE.txt)
5380  * and GPL (GPL-LICENSE.txt) licenses.
5381  *
5382  * http://docs.jquery.com/UI/Dialog
5383  *
5384  * Depends:
5385  *      jquery.ui.core.js
5386  *      jquery.ui.widget.js
5387  *  jquery.ui.button.js
5388  *      jquery.ui.draggable.js
5389  *      jquery.ui.mouse.js
5390  *      jquery.ui.position.js
5391  *      jquery.ui.resizable.js
5392  */
5393 (function($) {
5394
5395 var uiDialogClasses =
5396         'ui-dialog ' +
5397         'ui-widget ' +
5398         'ui-widget-content ' +
5399         'ui-corner-all ';
5400
5401 $.widget("ui.dialog", {
5402         options: {
5403                 autoOpen: true,
5404                 buttons: {},
5405                 closeOnEscape: true,
5406                 closeText: 'close',
5407                 dialogClass: '',
5408                 draggable: true,
5409                 hide: null,
5410                 height: 'auto',
5411                 maxHeight: false,
5412                 maxWidth: false,
5413                 minHeight: 150,
5414                 minWidth: 150,
5415                 modal: false,
5416                 position: 'center',
5417                 resizable: true,
5418                 show: null,
5419                 stack: true,
5420                 title: '',
5421                 width: 300,
5422                 zIndex: 1000
5423         },
5424         _create: function() {
5425                 this.originalTitle = this.element.attr('title');
5426
5427                 var self = this,
5428                         options = self.options,
5429
5430                         title = options.title || self.originalTitle || '&#160;',
5431                         titleId = $.ui.dialog.getTitleId(self.element),
5432
5433                         uiDialog = (self.uiDialog = $('<div></div>'))
5434                                 .appendTo(document.body)
5435                                 .hide()
5436                                 .addClass(uiDialogClasses + options.dialogClass)
5437                                 .css({
5438                                         zIndex: options.zIndex
5439                                 })
5440                                 // setting tabIndex makes the div focusable
5441                                 // setting outline to 0 prevents a border on focus in Mozilla
5442                                 .attr('tabIndex', -1).css('outline', 0).keydown(function(event) {
5443                                         if (options.closeOnEscape && event.keyCode &&
5444                                                 event.keyCode === $.ui.keyCode.ESCAPE) {
5445
5446                                                 self.close(event);
5447                                                 event.preventDefault();
5448                                         }
5449                                 })
5450                                 .attr({
5451                                         role: 'dialog',
5452                                         'aria-labelledby': titleId
5453                                 })
5454                                 .mousedown(function(event) {
5455                                         self.moveToTop(false, event);
5456                                 }),
5457
5458                         uiDialogContent = self.element
5459                                 .show()
5460                                 .removeAttr('title')
5461                                 .addClass(
5462                                         'ui-dialog-content ' +
5463                                         'ui-widget-content')
5464                                 .appendTo(uiDialog),
5465
5466                         uiDialogTitlebar = (self.uiDialogTitlebar = $('<div></div>'))
5467                                 .addClass(
5468                                         'ui-dialog-titlebar ' +
5469                                         'ui-widget-header ' +
5470                                         'ui-corner-all ' +
5471                                         'ui-helper-clearfix'
5472                                 )
5473                                 .prependTo(uiDialog),
5474
5475                         uiDialogTitlebarClose = $('<a href="#"></a>')
5476                                 .addClass(
5477                                         'ui-dialog-titlebar-close ' +
5478                                         'ui-corner-all'
5479                                 )
5480                                 .attr('role', 'button')
5481                                 .hover(
5482                                         function() {
5483                                                 uiDialogTitlebarClose.addClass('ui-state-hover');
5484                                         },
5485                                         function() {
5486                                                 uiDialogTitlebarClose.removeClass('ui-state-hover');
5487                                         }
5488                                 )
5489                                 .focus(function() {
5490                                         uiDialogTitlebarClose.addClass('ui-state-focus');
5491                                 })
5492                                 .blur(function() {
5493                                         uiDialogTitlebarClose.removeClass('ui-state-focus');
5494                                 })
5495                                 .click(function(event) {
5496                                         self.close(event);
5497                                         return false;
5498                                 })
5499                                 .appendTo(uiDialogTitlebar),
5500
5501                         uiDialogTitlebarCloseText = (self.uiDialogTitlebarCloseText = $('<span></span>'))
5502                                 .addClass(
5503                                         'ui-icon ' +
5504                                         'ui-icon-closethick'
5505                                 )
5506                                 .text(options.closeText)
5507                                 .appendTo(uiDialogTitlebarClose),
5508
5509                         uiDialogTitle = $('<span></span>')
5510                                 .addClass('ui-dialog-title')
5511                                 .attr('id', titleId)
5512                                 .html(title)
5513                                 .prependTo(uiDialogTitlebar);
5514
5515                 //handling of deprecated beforeclose (vs beforeClose) option
5516                 //Ticket #4669 http://dev.jqueryui.com/ticket/4669
5517                 //TODO: remove in 1.9pre
5518                 if ($.isFunction(options.beforeclose) && !$.isFunction(options.beforeClose)) {
5519                         options.beforeClose = options.beforeclose;
5520                 }
5521
5522                 uiDialogTitlebar.find("*").add(uiDialogTitlebar).disableSelection();
5523
5524                 if (options.draggable && $.fn.draggable) {
5525                         self._makeDraggable();
5526                 }
5527                 if (options.resizable && $.fn.resizable) {
5528                         self._makeResizable();
5529                 }
5530
5531                 self._createButtons(options.buttons);
5532                 self._isOpen = false;
5533
5534                 if ($.fn.bgiframe) {
5535                         uiDialog.bgiframe();
5536                 }
5537         },
5538         _init: function() {
5539                 if ( this.options.autoOpen ) {
5540                         this.open();
5541                 }
5542         },
5543
5544         destroy: function() {
5545                 var self = this;
5546
5547                 if (self.overlay) {
5548                         self.overlay.destroy();
5549                 }
5550                 self.uiDialog.hide();
5551                 self.element
5552                         .unbind('.dialog')
5553                         .removeData('dialog')
5554                         .removeClass('ui-dialog-content ui-widget-content')
5555                         .hide().appendTo('body');
5556                 self.uiDialog.remove();
5557
5558                 if (self.originalTitle) {
5559                         self.element.attr('title', self.originalTitle);
5560                 }
5561
5562                 return self;
5563         },
5564
5565         widget: function() {
5566                 return this.uiDialog;
5567         },
5568
5569         close: function(event) {
5570                 var self = this,
5571                         maxZ;
5572
5573                 if (false === self._trigger('beforeClose', event)) {
5574                         return;
5575                 }
5576
5577                 if (self.overlay) {
5578                         self.overlay.destroy();
5579                 }
5580                 self.uiDialog.unbind('keypress.ui-dialog');
5581
5582                 self._isOpen = false;
5583
5584                 if (self.options.hide) {
5585                         self.uiDialog.hide(self.options.hide, function() {
5586                                 self._trigger('close', event);
5587                         });
5588                 } else {
5589                         self.uiDialog.hide();
5590                         self._trigger('close', event);
5591                 }
5592
5593                 $.ui.dialog.overlay.resize();
5594
5595                 // adjust the maxZ to allow other modal dialogs to continue to work (see #4309)
5596                 if (self.options.modal) {
5597                         maxZ = 0;
5598                         $('.ui-dialog').each(function() {
5599                                 if (this !== self.uiDialog[0]) {
5600                                         maxZ = Math.max(maxZ, $(this).css('z-index'));
5601                                 }
5602                         });
5603                         $.ui.dialog.maxZ = maxZ;
5604                 }
5605
5606                 return self;
5607         },
5608
5609         isOpen: function() {
5610                 return this._isOpen;
5611         },
5612
5613         // the force parameter allows us to move modal dialogs to their correct
5614         // position on open
5615         moveToTop: function(force, event) {
5616                 var self = this,
5617                         options = self.options,
5618                         saveScroll;
5619
5620                 if ((options.modal && !force) ||
5621                         (!options.stack && !options.modal)) {
5622                         return self._trigger('focus', event);
5623                 }
5624
5625                 if (options.zIndex > $.ui.dialog.maxZ) {
5626                         $.ui.dialog.maxZ = options.zIndex;
5627                 }
5628                 if (self.overlay) {
5629                         $.ui.dialog.maxZ += 1;
5630                         self.overlay.$el.css('z-index', $.ui.dialog.overlay.maxZ = $.ui.dialog.maxZ);
5631                 }
5632
5633                 //Save and then restore scroll since Opera 9.5+ resets when parent z-Index is changed.
5634                 //  http://ui.jquery.com/bugs/ticket/3193
5635                 saveScroll = { scrollTop: self.element.attr('scrollTop'), scrollLeft: self.element.attr('scrollLeft') };
5636                 $.ui.dialog.maxZ += 1;
5637                 self.uiDialog.css('z-index', $.ui.dialog.maxZ);
5638                 self.element.attr(saveScroll);
5639                 self._trigger('focus', event);
5640
5641                 return self;
5642         },
5643
5644         open: function() {
5645                 if (this._isOpen) { return; }
5646
5647                 var self = this,
5648                         options = self.options,
5649                         uiDialog = self.uiDialog;
5650
5651                 self.overlay = options.modal ? new $.ui.dialog.overlay(self) : null;
5652                 if (uiDialog.next().length) {
5653                         uiDialog.appendTo('body');
5654                 }
5655                 self._size();
5656                 self._position(options.position);
5657                 uiDialog.show(options.show);
5658                 self.moveToTop(true);
5659
5660                 // prevent tabbing out of modal dialogs
5661                 if (options.modal) {
5662                         uiDialog.bind('keypress.ui-dialog', function(event) {
5663                                 if (event.keyCode !== $.ui.keyCode.TAB) {
5664                                         return;
5665                                 }
5666
5667                                 var tabbables = $(':tabbable', this),
5668                                         first = tabbables.filter(':first'),
5669                                         last  = tabbables.filter(':last');
5670
5671                                 if (event.target === last[0] && !event.shiftKey) {
5672                                         first.focus(1);
5673                                         return false;
5674                                 } else if (event.target === first[0] && event.shiftKey) {
5675                                         last.focus(1);
5676                                         return false;
5677                                 }
5678                         });
5679                 }
5680
5681                 // set focus to the first tabbable element in the content area or the first button
5682                 // if there are no tabbable elements, set focus on the dialog itself
5683                 $([])
5684                         .add(uiDialog.find('.ui-dialog-content :tabbable:first'))
5685                         .add(uiDialog.find('.ui-dialog-buttonpane :tabbable:first'))
5686                         .add(uiDialog)
5687                         .filter(':first')
5688                         .focus();
5689
5690                 self._trigger('open');
5691                 self._isOpen = true;
5692
5693                 return self;
5694         },
5695
5696         _createButtons: function(buttons) {
5697                 var self = this,
5698                         hasButtons = false,
5699                         uiDialogButtonPane = $('<div></div>')
5700                                 .addClass(
5701                                         'ui-dialog-buttonpane ' +
5702                                         'ui-widget-content ' +
5703                                         'ui-helper-clearfix'
5704                                 );
5705
5706                 // if we already have a button pane, remove it
5707                 self.uiDialog.find('.ui-dialog-buttonpane').remove();
5708
5709                 if (typeof buttons === 'object' && buttons !== null) {
5710                         $.each(buttons, function() {
5711                                 return !(hasButtons = true);
5712                         });
5713                 }
5714                 if (hasButtons) {
5715                         $.each(buttons, function(name, fn) {
5716                                 var button = $('<button type="button"></button>')
5717                                         .text(name)
5718                                         .click(function() { fn.apply(self.element[0], arguments); })
5719                                         .appendTo(uiDialogButtonPane);
5720                                 if ($.fn.button) {
5721                                         button.button();
5722                                 }
5723                         });
5724                         uiDialogButtonPane.appendTo(self.uiDialog);
5725                 }
5726         },
5727
5728         _makeDraggable: function() {
5729                 var self = this,
5730                         options = self.options,
5731                         doc = $(document),
5732                         heightBeforeDrag;
5733
5734                 function filteredUi(ui) {
5735                         return {
5736                                 position: ui.position,
5737                                 offset: ui.offset
5738                         };
5739                 }
5740
5741                 self.uiDialog.draggable({
5742                         cancel: '.ui-dialog-content, .ui-dialog-titlebar-close',
5743                         handle: '.ui-dialog-titlebar',
5744                         containment: 'document',
5745                         start: function(event, ui) {
5746                                 heightBeforeDrag = options.height === "auto" ? "auto" : $(this).height();
5747                                 $(this).height($(this).height()).addClass("ui-dialog-dragging");
5748                                 self._trigger('dragStart', event, filteredUi(ui));
5749                         },
5750                         drag: function(event, ui) {
5751                                 self._trigger('drag', event, filteredUi(ui));
5752                         },
5753                         stop: function(event, ui) {
5754                                 options.position = [ui.position.left - doc.scrollLeft(),
5755                                         ui.position.top - doc.scrollTop()];
5756                                 $(this).removeClass("ui-dialog-dragging").height(heightBeforeDrag);
5757                                 self._trigger('dragStop', event, filteredUi(ui));
5758                                 $.ui.dialog.overlay.resize();
5759                         }
5760                 });
5761         },
5762
5763         _makeResizable: function(handles) {
5764                 handles = (handles === undefined ? this.options.resizable : handles);
5765                 var self = this,
5766                         options = self.options,
5767                         // .ui-resizable has position: relative defined in the stylesheet
5768                         // but dialogs have to use absolute or fixed positioning
5769                         position = self.uiDialog.css('position'),
5770                         resizeHandles = (typeof handles === 'string' ?
5771                                 handles :
5772                                 'n,e,s,w,se,sw,ne,nw'
5773                         );
5774
5775                 function filteredUi(ui) {
5776                         return {
5777                                 originalPosition: ui.originalPosition,
5778                                 originalSize: ui.originalSize,
5779                                 position: ui.position,
5780                                 size: ui.size
5781                         };
5782                 }
5783
5784                 self.uiDialog.resizable({
5785                         cancel: '.ui-dialog-content',
5786                         containment: 'document',
5787                         alsoResize: self.element,
5788                         maxWidth: options.maxWidth,
5789                         maxHeight: options.maxHeight,
5790                         minWidth: options.minWidth,
5791                         minHeight: self._minHeight(),
5792                         handles: resizeHandles,
5793                         start: function(event, ui) {
5794                                 $(this).addClass("ui-dialog-resizing");
5795                                 self._trigger('resizeStart', event, filteredUi(ui));
5796                         },
5797                         resize: function(event, ui) {
5798                                 self._trigger('resize', event, filteredUi(ui));
5799                         },
5800                         stop: function(event, ui) {
5801                                 $(this).removeClass("ui-dialog-resizing");
5802                                 options.height = $(this).height();
5803                                 options.width = $(this).width();
5804                                 self._trigger('resizeStop', event, filteredUi(ui));
5805                                 $.ui.dialog.overlay.resize();
5806                         }
5807                 })
5808                 .css('position', position)
5809                 .find('.ui-resizable-se').addClass('ui-icon ui-icon-grip-diagonal-se');
5810         },
5811
5812         _minHeight: function() {
5813                 var options = this.options;
5814
5815                 if (options.height === 'auto') {
5816                         return options.minHeight;
5817                 } else {
5818                         return Math.min(options.minHeight, options.height);
5819                 }
5820         },
5821
5822         _position: function(position) {
5823                 var myAt = [],
5824                         offset = [0, 0],
5825                         isVisible;
5826
5827                 position = position || $.ui.dialog.prototype.options.position;
5828
5829                 // deep extending converts arrays to objects in jQuery <= 1.3.2 :-(
5830 //              if (typeof position == 'string' || $.isArray(position)) {
5831 //                      myAt = $.isArray(position) ? position : position.split(' ');
5832
5833                 if (typeof position === 'string' || (typeof position === 'object' && '0' in position)) {
5834                         myAt = position.split ? position.split(' ') : [position[0], position[1]];
5835                         if (myAt.length === 1) {
5836                                 myAt[1] = myAt[0];
5837                         }
5838
5839                         $.each(['left', 'top'], function(i, offsetPosition) {
5840                                 if (+myAt[i] === myAt[i]) {
5841                                         offset[i] = myAt[i];
5842                                         myAt[i] = offsetPosition;
5843                                 }
5844                         });
5845                 } else if (typeof position === 'object') {
5846                         if ('left' in position) {
5847                                 myAt[0] = 'left';
5848                                 offset[0] = position.left;
5849                         } else if ('right' in position) {
5850                                 myAt[0] = 'right';
5851                                 offset[0] = -position.right;
5852                         }
5853
5854                         if ('top' in position) {
5855                                 myAt[1] = 'top';
5856                                 offset[1] = position.top;
5857                         } else if ('bottom' in position) {
5858                                 myAt[1] = 'bottom';
5859                                 offset[1] = -position.bottom;
5860                         }
5861                 }
5862
5863                 // need to show the dialog to get the actual offset in the position plugin
5864                 isVisible = this.uiDialog.is(':visible');
5865                 if (!isVisible) {
5866                         this.uiDialog.show();
5867                 }
5868                 this.uiDialog
5869                         // workaround for jQuery bug #5781 http://dev.jquery.com/ticket/5781
5870                         .css({ top: 0, left: 0 })
5871                         .position({
5872                                 my: myAt.join(' '),
5873                                 at: myAt.join(' '),
5874                                 offset: offset.join(' '),
5875                                 of: window,
5876                                 collision: 'fit',
5877                                 // ensure that the titlebar is never outside the document
5878                                 using: function(pos) {
5879                                         var topOffset = $(this).css(pos).offset().top;
5880                                         if (topOffset < 0) {
5881                                                 $(this).css('top', pos.top - topOffset);
5882                                         }
5883                                 }
5884                         });
5885                 if (!isVisible) {
5886                         this.uiDialog.hide();
5887                 }
5888         },
5889
5890         _setOption: function(key, value){
5891                 var self = this,
5892                         uiDialog = self.uiDialog,
5893                         isResizable = uiDialog.is(':data(resizable)'),
5894                         resize = false;
5895
5896                 switch (key) {
5897                         //handling of deprecated beforeclose (vs beforeClose) option
5898                         //Ticket #4669 http://dev.jqueryui.com/ticket/4669
5899                         //TODO: remove in 1.9pre
5900                         case "beforeclose":
5901                                 key = "beforeClose";
5902                                 break;
5903                         case "buttons":
5904                                 self._createButtons(value);
5905                                 break;
5906                         case "closeText":
5907                                 // convert whatever was passed in to a string, for text() to not throw up
5908                                 self.uiDialogTitlebarCloseText.text("" + value);
5909                                 break;
5910                         case "dialogClass":
5911                                 uiDialog
5912                                         .removeClass(self.options.dialogClass)
5913                                         .addClass(uiDialogClasses + value);
5914                                 break;
5915                         case "disabled":
5916                                 if (value) {
5917                                         uiDialog.addClass('ui-dialog-disabled');
5918                                 } else {
5919                                         uiDialog.removeClass('ui-dialog-disabled');
5920                                 }
5921                                 break;
5922                         case "draggable":
5923                                 if (value) {
5924                                         self._makeDraggable();
5925                                 } else {
5926                                         uiDialog.draggable('destroy');
5927                                 }
5928                                 break;
5929                         case "height":
5930                                 resize = true;
5931                                 break;
5932                         case "maxHeight":
5933                                 if (isResizable) {
5934                                         uiDialog.resizable('option', 'maxHeight', value);
5935                                 }
5936                                 resize = true;
5937                                 break;
5938                         case "maxWidth":
5939                                 if (isResizable) {
5940                                         uiDialog.resizable('option', 'maxWidth', value);
5941                                 }
5942                                 resize = true;
5943                                 break;
5944                         case "minHeight":
5945                                 if (isResizable) {
5946                                         uiDialog.resizable('option', 'minHeight', value);
5947                                 }
5948                                 resize = true;
5949                                 break;
5950                         case "minWidth":
5951                                 if (isResizable) {
5952                                         uiDialog.resizable('option', 'minWidth', value);
5953                                 }
5954                                 resize = true;
5955                                 break;
5956                         case "position":
5957                                 self._position(value);
5958                                 break;
5959                         case "resizable":
5960                                 // currently resizable, becoming non-resizable
5961                                 if (isResizable && !value) {
5962                                         uiDialog.resizable('destroy');
5963                                 }
5964
5965                                 // currently resizable, changing handles
5966                                 if (isResizable && typeof value === 'string') {
5967                                         uiDialog.resizable('option', 'handles', value);
5968                                 }
5969
5970                                 // currently non-resizable, becoming resizable
5971                                 if (!isResizable && value !== false) {
5972                                         self._makeResizable(value);
5973                                 }
5974                                 break;
5975                         case "title":
5976                                 // convert whatever was passed in o a string, for html() to not throw up
5977                                 $(".ui-dialog-title", self.uiDialogTitlebar).html("" + (value || '&#160;'));
5978                                 break;
5979                         case "width":
5980                                 resize = true;
5981                                 break;
5982                 }
5983
5984                 $.Widget.prototype._setOption.apply(self, arguments);
5985                 if (resize) {
5986                         self._size();
5987                 }
5988         },
5989
5990         _size: function() {
5991                 /* If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
5992                  * divs will both have width and height set, so we need to reset them
5993                  */
5994                 var options = this.options,
5995                         nonContentHeight;
5996
5997                 // reset content sizing
5998                 // hide for non content measurement because height: 0 doesn't work in IE quirks mode (see #4350)
5999                 this.element.css('width', 'auto')
6000                         .hide();
6001
6002                 // reset wrapper sizing
6003                 // determine the height of all the non-content elements
6004                 nonContentHeight = this.uiDialog.css({
6005                                 height: 'auto',
6006                                 width: options.width
6007                         })
6008                         .height();
6009
6010                 this.element
6011                         .css(options.height === 'auto' ? {
6012                                         minHeight: Math.max(options.minHeight - nonContentHeight, 0),
6013                                         height: 'auto'
6014                                 } : {
6015                                         minHeight: 0,
6016                                         height: Math.max(options.height - nonContentHeight, 0)
6017                         })
6018                         .show();
6019
6020                 if (this.uiDialog.is(':data(resizable)')) {
6021                         this.uiDialog.resizable('option', 'minHeight', this._minHeight());
6022                 }
6023         }
6024 });
6025
6026 $.extend($.ui.dialog, {
6027         version: "1.8",
6028
6029         uuid: 0,
6030         maxZ: 0,
6031
6032         getTitleId: function($el) {
6033                 var id = $el.attr('id');
6034                 if (!id) {
6035                         this.uuid += 1;
6036                         id = this.uuid;
6037                 }
6038                 return 'ui-dialog-title-' + id;
6039         },
6040
6041         overlay: function(dialog) {
6042                 this.$el = $.ui.dialog.overlay.create(dialog);
6043         }
6044 });
6045
6046 $.extend($.ui.dialog.overlay, {
6047         instances: [],
6048         // reuse old instances due to IE memory leak with alpha transparency (see #5185)
6049         oldInstances: [],
6050         maxZ: 0,
6051         events: $.map('focus,mousedown,mouseup,keydown,keypress,click'.split(','),
6052                 function(event) { return event + '.dialog-overlay'; }).join(' '),
6053         create: function(dialog) {
6054                 if (this.instances.length === 0) {
6055                         // prevent use of anchors and inputs
6056                         // we use a setTimeout in case the overlay is created from an
6057                         // event that we're going to be cancelling (see #2804)
6058                         setTimeout(function() {
6059                                 // handle $(el).dialog().dialog('close') (see #4065)
6060                                 if ($.ui.dialog.overlay.instances.length) {
6061                                         $(document).bind($.ui.dialog.overlay.events, function(event) {
6062                                                 // stop events if the z-index of the target is < the z-index of the overlay
6063                                                 return ($(event.target).zIndex() >= $.ui.dialog.overlay.maxZ);
6064                                         });
6065                                 }
6066                         }, 1);
6067
6068                         // allow closing by pressing the escape key
6069                         $(document).bind('keydown.dialog-overlay', function(event) {
6070                                 if (dialog.options.closeOnEscape && event.keyCode &&
6071                                         event.keyCode === $.ui.keyCode.ESCAPE) {
6072
6073                                         dialog.close(event);
6074                                         event.preventDefault();
6075                                 }
6076                         });
6077
6078                         // handle window resize
6079                         $(window).bind('resize.dialog-overlay', $.ui.dialog.overlay.resize);
6080                 }
6081
6082                 var $el = (this.oldInstances.pop() || $('<div></div>').addClass('ui-widget-overlay'))
6083                         .appendTo(document.body)
6084                         .css({
6085                                 width: this.width(),
6086                                 height: this.height()
6087                         });
6088
6089                 if ($.fn.bgiframe) {
6090                         $el.bgiframe();
6091                 }
6092
6093                 this.instances.push($el);
6094                 return $el;
6095         },
6096
6097         destroy: function($el) {
6098                 this.oldInstances.push(this.instances.splice($.inArray($el, this.instances), 1)[0]);
6099
6100                 if (this.instances.length === 0) {
6101                         $([document, window]).unbind('.dialog-overlay');
6102                 }
6103
6104                 $el.remove();
6105
6106                 // adjust the maxZ to allow other modal dialogs to continue to work (see #4309)
6107                 var maxZ = 0;
6108                 $.each(this.instances, function() {
6109                         maxZ = Math.max(maxZ, this.css('z-index'));
6110                 });
6111                 this.maxZ = maxZ;
6112         },
6113
6114         height: function() {
6115                 var scrollHeight,
6116                         offsetHeight;
6117                 // handle IE 6
6118                 if ($.browser.msie && $.browser.version < 7) {
6119                         scrollHeight = Math.max(
6120                                 document.documentElement.scrollHeight,
6121                                 document.body.scrollHeight
6122                         );
6123                         offsetHeight = Math.max(
6124                                 document.documentElement.offsetHeight,
6125                                 document.body.offsetHeight
6126                         );
6127
6128                         if (scrollHeight < offsetHeight) {
6129                                 return $(window).height() + 'px';
6130                         } else {
6131                                 return scrollHeight + 'px';
6132                         }
6133                 // handle "good" browsers
6134                 } else {
6135                         return $(document).height() + 'px';
6136                 }
6137         },
6138
6139         width: function() {
6140                 var scrollWidth,
6141                         offsetWidth;
6142                 // handle IE 6
6143                 if ($.browser.msie && $.browser.version < 7) {
6144                         scrollWidth = Math.max(
6145                                 document.documentElement.scrollWidth,
6146                                 document.body.scrollWidth
6147                         );
6148                         offsetWidth = Math.max(
6149                                 document.documentElement.offsetWidth,
6150                                 document.body.offsetWidth
6151                         );
6152
6153                         if (scrollWidth < offsetWidth) {
6154                                 return $(window).width() + 'px';
6155                         } else {
6156                                 return scrollWidth + 'px';
6157                         }
6158                 // handle "good" browsers
6159                 } else {
6160                         return $(document).width() + 'px';
6161                 }
6162         },
6163
6164         resize: function() {
6165                 /* If the dialog is draggable and the user drags it past the
6166                  * right edge of the window, the document becomes wider so we
6167                  * need to stretch the overlay. If the user then drags the
6168                  * dialog back to the left, the document will become narrower,
6169                  * so we need to shrink the overlay to the appropriate size.
6170                  * This is handled by shrinking the overlay before setting it
6171                  * to the full document size.
6172                  */
6173                 var $overlays = $([]);
6174                 $.each($.ui.dialog.overlay.instances, function() {
6175                         $overlays = $overlays.add(this);
6176                 });
6177
6178                 $overlays.css({
6179                         width: 0,
6180                         height: 0
6181                 }).css({
6182                         width: $.ui.dialog.overlay.width(),
6183                         height: $.ui.dialog.overlay.height()
6184                 });
6185         }
6186 });
6187
6188 $.extend($.ui.dialog.overlay.prototype, {
6189         destroy: function() {
6190                 $.ui.dialog.overlay.destroy(this.$el);
6191         }
6192 });
6193
6194 }(jQuery));
6195 /*
6196  * jQuery UI Slider 1.8
6197  *
6198  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
6199  * Dual licensed under the MIT (MIT-LICENSE.txt)
6200  * and GPL (GPL-LICENSE.txt) licenses.
6201  *
6202  * http://docs.jquery.com/UI/Slider
6203  *
6204  * Depends:
6205  *      jquery.ui.core.js
6206  *      jquery.ui.mouse.js
6207  *      jquery.ui.widget.js
6208  */
6209
6210 (function($) {
6211
6212 // number of pages in a slider
6213 // (how many times can you page up/down to go through the whole range)
6214 var numPages = 5;
6215
6216 $.widget("ui.slider", $.ui.mouse, {
6217         widgetEventPrefix: "slide",
6218         options: {
6219                 animate: false,
6220                 distance: 0,
6221                 max: 100,
6222                 min: 0,
6223                 orientation: 'horizontal',
6224                 range: false,
6225                 step: 1,
6226                 value: 0,
6227                 values: null
6228         },
6229         _create: function() {
6230
6231                 var self = this, o = this.options;
6232                 this._keySliding = false;
6233                 this._mouseSliding = false;
6234                 this._animateOff = true;
6235                 this._handleIndex = null;
6236                 this._detectOrientation();
6237                 this._mouseInit();
6238
6239                 this.element
6240                         .addClass("ui-slider"
6241                                 + " ui-slider-" + this.orientation
6242                                 + " ui-widget"
6243                                 + " ui-widget-content"
6244                                 + " ui-corner-all");
6245
6246                 if (o.disabled) {
6247                         this.element.addClass('ui-slider-disabled ui-disabled');
6248                 }
6249
6250                 this.range = $([]);
6251
6252                 if (o.range) {
6253
6254                         if (o.range === true) {
6255                                 this.range = $('<div></div>');
6256                                 if (!o.values) o.values = [this._valueMin(), this._valueMin()];
6257                                 if (o.values.length && o.values.length != 2) {
6258                                         o.values = [o.values[0], o.values[0]];
6259                                 }
6260                         } else {
6261                                 this.range = $('<div></div>');
6262                         }
6263
6264                         this.range
6265                                 .appendTo(this.element)
6266                                 .addClass("ui-slider-range");
6267
6268                         if (o.range == "min" || o.range == "max") {
6269                                 this.range.addClass("ui-slider-range-" + o.range);
6270                         }
6271
6272                         // note: this isn't the most fittingly semantic framework class for this element,
6273                         // but worked best visually with a variety of themes
6274                         this.range.addClass("ui-widget-header");
6275
6276                 }
6277
6278                 if ($(".ui-slider-handle", this.element).length == 0)
6279                         $('<a href="#"></a>')
6280                                 .appendTo(this.element)
6281                                 .addClass("ui-slider-handle");
6282
6283                 if (o.values && o.values.length) {
6284                         while ($(".ui-slider-handle", this.element).length < o.values.length)
6285                                 $('<a href="#"></a>')
6286                                         .appendTo(this.element)
6287                                         .addClass("ui-slider-handle");
6288                 }
6289
6290                 this.handles = $(".ui-slider-handle", this.element)
6291                         .addClass("ui-state-default"
6292                                 + " ui-corner-all");
6293
6294                 this.handle = this.handles.eq(0);
6295
6296                 this.handles.add(this.range).filter("a")
6297                         .click(function(event) {
6298                                 event.preventDefault();
6299                         })
6300                         .hover(function() {
6301                                 if (!o.disabled) {
6302                                         $(this).addClass('ui-state-hover');
6303                                 }
6304                         }, function() {
6305                                 $(this).removeClass('ui-state-hover');
6306                         })
6307                         .focus(function() {
6308                                 if (!o.disabled) {
6309                                         $(".ui-slider .ui-state-focus").removeClass('ui-state-focus'); $(this).addClass('ui-state-focus');
6310                                 } else {
6311                                         $(this).blur();
6312                                 }
6313                         })
6314                         .blur(function() {
6315                                 $(this).removeClass('ui-state-focus');
6316                         });
6317
6318                 this.handles.each(function(i) {
6319                         $(this).data("index.ui-slider-handle", i);
6320                 });
6321
6322                 this.handles.keydown(function(event) {
6323
6324                         var ret = true;
6325
6326                         var index = $(this).data("index.ui-slider-handle");
6327
6328                         if (self.options.disabled)
6329                                 return;
6330
6331                         switch (event.keyCode) {
6332                                 case $.ui.keyCode.HOME:
6333                                 case $.ui.keyCode.END:
6334                                 case $.ui.keyCode.PAGE_UP:
6335                                 case $.ui.keyCode.PAGE_DOWN:
6336                                 case $.ui.keyCode.UP:
6337                                 case $.ui.keyCode.RIGHT:
6338                                 case $.ui.keyCode.DOWN:
6339                                 case $.ui.keyCode.LEFT:
6340                                         ret = false;
6341                                         if (!self._keySliding) {
6342                                                 self._keySliding = true;
6343                                                 $(this).addClass("ui-state-active");
6344                                                 self._start(event, index);
6345                                         }
6346                                         break;
6347                         }
6348
6349                         var curVal, newVal, step = self._step();
6350                         if (self.options.values && self.options.values.length) {
6351                                 curVal = newVal = self.values(index);
6352                         } else {
6353                                 curVal = newVal = self.value();
6354                         }
6355
6356                         switch (event.keyCode) {
6357                                 case $.ui.keyCode.HOME:
6358                                         newVal = self._valueMin();
6359                                         break;
6360                                 case $.ui.keyCode.END:
6361                                         newVal = self._valueMax();
6362                                         break;
6363                                 case $.ui.keyCode.PAGE_UP:
6364                                         newVal = curVal + ((self._valueMax() - self._valueMin()) / numPages);
6365                                         break;
6366                                 case $.ui.keyCode.PAGE_DOWN:
6367                                         newVal = curVal - ((self._valueMax() - self._valueMin()) / numPages);
6368                                         break;
6369                                 case $.ui.keyCode.UP:
6370                                 case $.ui.keyCode.RIGHT:
6371                                         if(curVal == self._valueMax()) return;
6372                                         newVal = curVal + step;
6373                                         break;
6374                                 case $.ui.keyCode.DOWN:
6375                                 case $.ui.keyCode.LEFT:
6376                                         if(curVal == self._valueMin()) return;
6377                                         newVal = curVal - step;
6378                                         break;
6379                         }
6380
6381                         self._slide(event, index, newVal);
6382
6383                         return ret;
6384
6385                 }).keyup(function(event) {
6386
6387                         var index = $(this).data("index.ui-slider-handle");
6388
6389                         if (self._keySliding) {
6390                                 self._keySliding = false;
6391                                 self._stop(event, index);
6392                                 self._change(event, index);
6393                                 $(this).removeClass("ui-state-active");
6394                         }
6395
6396                 });
6397
6398                 this._refreshValue();
6399
6400                 this._animateOff = false;
6401
6402         },
6403
6404         destroy: function() {
6405
6406                 this.handles.remove();
6407                 this.range.remove();
6408
6409                 this.element
6410                         .removeClass("ui-slider"
6411                                 + " ui-slider-horizontal"
6412                                 + " ui-slider-vertical"
6413                                 + " ui-slider-disabled"
6414                                 + " ui-widget"
6415                                 + " ui-widget-content"
6416                                 + " ui-corner-all")
6417                         .removeData("slider")
6418                         .unbind(".slider");
6419
6420                 this._mouseDestroy();
6421
6422                 return this;
6423         },
6424
6425         _mouseCapture: function(event) {
6426
6427                 var o = this.options;
6428
6429                 if (o.disabled)
6430                         return false;
6431
6432                 this.elementSize = {
6433                         width: this.element.outerWidth(),
6434                         height: this.element.outerHeight()
6435                 };
6436                 this.elementOffset = this.element.offset();
6437
6438                 var position = { x: event.pageX, y: event.pageY };
6439                 var normValue = this._normValueFromMouse(position);
6440
6441                 var distance = this._valueMax() - this._valueMin() + 1, closestHandle;
6442                 var self = this, index;
6443                 this.handles.each(function(i) {
6444                         var thisDistance = Math.abs(normValue - self.values(i));
6445                         if (distance > thisDistance) {
6446                                 distance = thisDistance;
6447                                 closestHandle = $(this);
6448                                 index = i;
6449                         }
6450                 });
6451
6452                 // workaround for bug #3736 (if both handles of a range are at 0,
6453                 // the first is always used as the one with least distance,
6454                 // and moving it is obviously prevented by preventing negative ranges)
6455                 if(o.range == true && this.values(1) == o.min) {
6456                         closestHandle = $(this.handles[++index]);
6457                 }
6458
6459                 this._start(event, index);
6460                 this._mouseSliding = true;
6461
6462                 self._handleIndex = index;
6463
6464                 closestHandle
6465                         .addClass("ui-state-active")
6466                         .focus();
6467
6468                 var offset = closestHandle.offset();
6469                 var mouseOverHandle = !$(event.target).parents().andSelf().is('.ui-slider-handle');
6470                 this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
6471                         left: event.pageX - offset.left - (closestHandle.width() / 2),
6472                         top: event.pageY - offset.top
6473                                 - (closestHandle.height() / 2)
6474                                 - (parseInt(closestHandle.css('borderTopWidth'),10) || 0)
6475                                 - (parseInt(closestHandle.css('borderBottomWidth'),10) || 0)
6476                                 + (parseInt(closestHandle.css('marginTop'),10) || 0)
6477                 };
6478
6479                 normValue = this._normValueFromMouse(position);
6480                 this._slide(event, index, normValue);
6481                 this._animateOff = true;
6482                 return true;
6483
6484         },
6485
6486         _mouseStart: function(event) {
6487                 return true;
6488         },
6489
6490         _mouseDrag: function(event) {
6491
6492                 var position = { x: event.pageX, y: event.pageY };
6493                 var normValue = this._normValueFromMouse(position);
6494
6495                 this._slide(event, this._handleIndex, normValue);
6496
6497                 return false;
6498
6499         },
6500
6501         _mouseStop: function(event) {
6502
6503                 this.handles.removeClass("ui-state-active");
6504                 this._mouseSliding = false;
6505                 this._stop(event, this._handleIndex);
6506                 this._change(event, this._handleIndex);
6507                 this._handleIndex = null;
6508                 this._clickOffset = null;
6509
6510                 this._animateOff = false;
6511                 return false;
6512
6513         },
6514
6515         _detectOrientation: function() {
6516                 this.orientation = this.options.orientation == 'vertical' ? 'vertical' : 'horizontal';
6517         },
6518
6519         _normValueFromMouse: function(position) {
6520
6521                 var pixelTotal, pixelMouse;
6522                 if ('horizontal' == this.orientation) {
6523                         pixelTotal = this.elementSize.width;
6524                         pixelMouse = position.x - this.elementOffset.left - (this._clickOffset ? this._clickOffset.left : 0);
6525                 } else {
6526                         pixelTotal = this.elementSize.height;
6527                         pixelMouse = position.y - this.elementOffset.top - (this._clickOffset ? this._clickOffset.top : 0);
6528                 }
6529
6530                 var percentMouse = (pixelMouse / pixelTotal);
6531                 if (percentMouse > 1) percentMouse = 1;
6532                 if (percentMouse < 0) percentMouse = 0;
6533                 if ('vertical' == this.orientation)
6534                         percentMouse = 1 - percentMouse;
6535
6536                 var valueTotal = this._valueMax() - this._valueMin(),
6537                         valueMouse = percentMouse * valueTotal,
6538                         valueMouseModStep = valueMouse % this.options.step,
6539                         normValue = this._valueMin() + valueMouse - valueMouseModStep;
6540
6541                 if (valueMouseModStep > (this.options.step / 2))
6542                         normValue += this.options.step;
6543
6544                 // Since JavaScript has problems with large floats, round
6545                 // the final value to 5 digits after the decimal point (see #4124)
6546                 return parseFloat(normValue.toFixed(5));
6547
6548         },
6549
6550         _start: function(event, index) {
6551                 var uiHash = {
6552                         handle: this.handles[index],
6553                         value: this.value()
6554                 };
6555                 if (this.options.values && this.options.values.length) {
6556                         uiHash.value = this.values(index);
6557                         uiHash.values = this.values();
6558                 }
6559                 this._trigger("start", event, uiHash);
6560         },
6561
6562         _slide: function(event, index, newVal) {
6563
6564                 var handle = this.handles[index];
6565
6566                 if (this.options.values && this.options.values.length) {
6567
6568                         var otherVal = this.values(index ? 0 : 1);
6569
6570                         if ((this.options.values.length == 2 && this.options.range === true) &&
6571                                 ((index == 0 && newVal > otherVal) || (index == 1 && newVal < otherVal))){
6572                                 newVal = otherVal;
6573                         }
6574
6575                         if (newVal != this.values(index)) {
6576                                 var newValues = this.values();
6577                                 newValues[index] = newVal;
6578                                 // A slide can be canceled by returning false from the slide callback
6579                                 var allowed = this._trigger("slide", event, {
6580                                         handle: this.handles[index],
6581                                         value: newVal,
6582                                         values: newValues
6583                                 });
6584                                 var otherVal = this.values(index ? 0 : 1);
6585                                 if (allowed !== false) {
6586                                         this.values(index, newVal, true);
6587                                 }
6588                         }
6589
6590                 } else {
6591
6592                         if (newVal != this.value()) {
6593                                 // A slide can be canceled by returning false from the slide callback
6594                                 var allowed = this._trigger("slide", event, {
6595                                         handle: this.handles[index],
6596                                         value: newVal
6597                                 });
6598                                 if (allowed !== false) {
6599                                         this.value(newVal);
6600                                 }
6601
6602                         }
6603
6604                 }
6605
6606         },
6607
6608         _stop: function(event, index) {
6609                 var uiHash = {
6610                         handle: this.handles[index],
6611                         value: this.value()
6612                 };
6613                 if (this.options.values && this.options.values.length) {
6614                         uiHash.value = this.values(index);
6615                         uiHash.values = this.values();
6616                 }
6617                 this._trigger("stop", event, uiHash);
6618         },
6619
6620         _change: function(event, index) {
6621                 if (!this._keySliding && !this._mouseSliding) {
6622                         var uiHash = {
6623                                 handle: this.handles[index],
6624                                 value: this.value()
6625                         };
6626                         if (this.options.values && this.options.values.length) {
6627                                 uiHash.value = this.values(index);
6628                                 uiHash.values = this.values();
6629                         }
6630                         this._trigger("change", event, uiHash);
6631                 }
6632         },
6633
6634         value: function(newValue) {
6635
6636                 if (arguments.length) {
6637                         this.options.value = this._trimValue(newValue);
6638                         this._refreshValue();
6639                         this._change(null, 0);
6640                 }
6641
6642                 return this._value();
6643
6644         },
6645
6646         values: function(index, newValue) {
6647
6648                 if (arguments.length > 1) {
6649                         this.options.values[index] = this._trimValue(newValue);
6650                         this._refreshValue();
6651                         this._change(null, index);
6652                 }
6653
6654                 if (arguments.length) {
6655                         if ($.isArray(arguments[0])) {
6656                                 var vals = this.options.values, newValues = arguments[0];
6657                                 for (var i = 0, l = vals.length; i < l; i++) {
6658                                         vals[i] = this._trimValue(newValues[i]);
6659                                         this._change(null, i);
6660                                 }
6661                                 this._refreshValue();
6662                         } else {
6663                                 if (this.options.values && this.options.values.length) {
6664                                         return this._values(index);
6665                                 } else {
6666                                         return this.value();
6667                                 }
6668                         }
6669                 } else {
6670                         return this._values();
6671                 }
6672
6673         },
6674
6675         _setOption: function(key, value) {
6676
6677                 var i,
6678                         valsLength = 0;
6679                 if ( jQuery.isArray(this.options.values) ) {
6680                         valsLength = this.options.values.length;
6681                 };
6682
6683                 $.Widget.prototype._setOption.apply(this, arguments);
6684
6685                 switch (key) {
6686                         case 'disabled':
6687                                 if (value) {
6688                                         this.handles.filter(".ui-state-focus").blur();
6689                                         this.handles.removeClass("ui-state-hover");
6690                                         this.handles.attr("disabled", "disabled");
6691                                         this.element.addClass("ui-disabled");
6692                                 } else {
6693                                         this.handles.removeAttr("disabled");
6694                                         this.element.removeClass("ui-disabled");
6695                                 }
6696                         case 'orientation':
6697
6698                                 this._detectOrientation();
6699
6700                                 this.element
6701                                         .removeClass("ui-slider-horizontal ui-slider-vertical")
6702                                         .addClass("ui-slider-" + this.orientation);
6703                                 this._refreshValue();
6704                                 break;
6705                         case 'value':
6706                                 this._animateOff = true;
6707                                 this._refreshValue();
6708                                 this._change(null, 0);
6709                                 this._animateOff = false;
6710                                 break;
6711                         case 'values':
6712                                 this._animateOff = true;
6713                                 this._refreshValue();
6714                                 for (i = 0; i < valsLength; i++) {
6715                                         this._change(null, i);
6716                                 }
6717                                 this._animateOff = false;
6718                                 break;
6719                 }
6720
6721         },
6722
6723         _step: function() {
6724                 var step = this.options.step;
6725                 return step;
6726         },
6727
6728         _value: function() {
6729                 //internal value getter
6730                 // _value() returns value trimmed by min and max
6731                 var val = this.options.value;
6732                 val = this._trimValue(val);
6733
6734                 return val;
6735         },
6736
6737         _values: function(index) {
6738                 //internal values getter
6739                 // _values() returns array of values trimmed by min and max
6740                 // _values(index) returns single value trimmed by min and max
6741
6742                 if (arguments.length) {
6743                         var val = this.options.values[index];
6744                         val = this._trimValue(val);
6745
6746                         return val;
6747                 } else {
6748                         // .slice() creates a copy of the array
6749                         // this copy gets trimmed by min and max and then returned
6750                         var vals = this.options.values.slice();
6751                         for (var i = 0, l = vals.length; i < l; i++) {
6752                                 vals[i] = this._trimValue(vals[i]);
6753                         }
6754
6755                         return vals;
6756                 }
6757
6758         },
6759
6760         _trimValue: function(val) {
6761                 if (val < this._valueMin()) val = this._valueMin();
6762                 if (val > this._valueMax()) val = this._valueMax();
6763
6764                 return val;
6765         },
6766
6767         _valueMin: function() {
6768                 var valueMin = this.options.min;
6769                 return valueMin;
6770         },
6771
6772         _valueMax: function() {
6773                 var valueMax = this.options.max;
6774                 return valueMax;
6775         },
6776
6777         _refreshValue: function() {
6778
6779                 var oRange = this.options.range, o = this.options, self = this;
6780                 var animate = (!this._animateOff) ? o.animate : false;
6781
6782                 if (this.options.values && this.options.values.length) {
6783                         var vp0, vp1;
6784                         this.handles.each(function(i, j) {
6785                                 var valPercent = (self.values(i) - self._valueMin()) / (self._valueMax() - self._valueMin()) * 100;
6786                                 var _set = {}; _set[self.orientation == 'horizontal' ? 'left' : 'bottom'] = valPercent + '%';
6787                                 $(this).stop(1,1)[animate ? 'animate' : 'css'](_set, o.animate);
6788                                 if (self.options.range === true) {
6789                                         if (self.orientation == 'horizontal') {
6790                                                 (i == 0) && self.range.stop(1,1)[animate ? 'animate' : 'css']({ left: valPercent + '%' }, o.animate);
6791                                                 (i == 1) && self.range[animate ? 'animate' : 'css']({ width: (valPercent - lastValPercent) + '%' }, { queue: false, duration: o.animate });
6792                                         } else {
6793                                                 (i == 0) && self.range.stop(1,1)[animate ? 'animate' : 'css']({ bottom: (valPercent) + '%' }, o.animate);
6794                                                 (i == 1) && self.range[animate ? 'animate' : 'css']({ height: (valPercent - lastValPercent) + '%' }, { queue: false, duration: o.animate });
6795                                         }
6796                                 }
6797                                 lastValPercent = valPercent;
6798                         });
6799                 } else {
6800                         var value = this.value(),
6801                                 valueMin = this._valueMin(),
6802                                 valueMax = this._valueMax(),
6803                                 valPercent = valueMax != valueMin
6804                                         ? (value - valueMin) / (valueMax - valueMin) * 100
6805                                         : 0;
6806                         var _set = {}; _set[self.orientation == 'horizontal' ? 'left' : 'bottom'] = valPercent + '%';
6807                         this.handle.stop(1,1)[animate ? 'animate' : 'css'](_set, o.animate);
6808
6809                         (oRange == "min") && (this.orientation == "horizontal") && this.range.stop(1,1)[animate ? 'animate' : 'css']({ width: valPercent + '%' }, o.animate);
6810                         (oRange == "max") && (this.orientation == "horizontal") && this.range[animate ? 'animate' : 'css']({ width: (100 - valPercent) + '%' }, { queue: false, duration: o.animate });
6811                         (oRange == "min") && (this.orientation == "vertical") && this.range.stop(1,1)[animate ? 'animate' : 'css']({ height: valPercent + '%' }, o.animate);
6812                         (oRange == "max") && (this.orientation == "vertical") && this.range[animate ? 'animate' : 'css']({ height: (100 - valPercent) + '%' }, { queue: false, duration: o.animate });
6813                 }
6814
6815         }
6816
6817 });
6818
6819 $.extend($.ui.slider, {
6820         version: "1.8"
6821 });
6822
6823 })(jQuery);
6824 /*
6825  * jQuery UI Tabs 1.8
6826  *
6827  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
6828  * Dual licensed under the MIT (MIT-LICENSE.txt)
6829  * and GPL (GPL-LICENSE.txt) licenses.
6830  *
6831  * http://docs.jquery.com/UI/Tabs
6832  *
6833  * Depends:
6834  *      jquery.ui.core.js
6835  *      jquery.ui.widget.js
6836  */
6837 (function($) {
6838
6839 var tabId = 0,
6840         listId = 0;
6841
6842 $.widget("ui.tabs", {
6843         options: {
6844                 add: null,
6845                 ajaxOptions: null,
6846                 cache: false,
6847                 cookie: null, // e.g. { expires: 7, path: '/', domain: 'jquery.com', secure: true }
6848                 collapsible: false,
6849                 disable: null,
6850                 disabled: [],
6851                 enable: null,
6852                 event: 'click',
6853                 fx: null, // e.g. { height: 'toggle', opacity: 'toggle', duration: 200 }
6854                 idPrefix: 'ui-tabs-',
6855                 load: null,
6856                 panelTemplate: '<div></div>',
6857                 remove: null,
6858                 select: null,
6859                 show: null,
6860                 spinner: '<em>Loading&#8230;</em>',
6861                 tabTemplate: '<li><a href="#{href}"><span>#{label}</span></a></li>'
6862         },
6863         _create: function() {
6864                 this._tabify(true);
6865         },
6866
6867         _setOption: function(key, value) {
6868                 if (key == 'selected') {
6869                         if (this.options.collapsible && value == this.options.selected) {
6870                                 return;
6871                         }
6872                         this.select(value);
6873                 }
6874                 else {
6875                         this.options[key] = value;
6876                         this._tabify();
6877                 }
6878         },
6879
6880         _tabId: function(a) {
6881                 return a.title && a.title.replace(/\s/g, '_').replace(/[^A-Za-z0-9\-_:\.]/g, '') ||
6882                         this.options.idPrefix + (++tabId);
6883         },
6884
6885         _sanitizeSelector: function(hash) {
6886                 return hash.replace(/:/g, '\\:'); // we need this because an id may contain a ":"
6887         },
6888
6889         _cookie: function() {
6890                 var cookie = this.cookie || (this.cookie = this.options.cookie.name || 'ui-tabs-' + (++listId));
6891                 return $.cookie.apply(null, [cookie].concat($.makeArray(arguments)));
6892         },
6893
6894         _ui: function(tab, panel) {
6895                 return {
6896                         tab: tab,
6897                         panel: panel,
6898                         index: this.anchors.index(tab)
6899                 };
6900         },
6901
6902         _cleanup: function() {
6903                 // restore all former loading tabs labels
6904                 this.lis.filter('.ui-state-processing').removeClass('ui-state-processing')
6905                                 .find('span:data(label.tabs)')
6906                                 .each(function() {
6907                                         var el = $(this);
6908                                         el.html(el.data('label.tabs')).removeData('label.tabs');
6909                                 });
6910         },
6911
6912         _tabify: function(init) {
6913
6914                 this.list = this.element.find('ol,ul').eq(0);
6915                 this.lis = $('li:has(a[href])', this.list);
6916                 this.anchors = this.lis.map(function() { return $('a', this)[0]; });
6917                 this.panels = $([]);
6918
6919                 var self = this, o = this.options;
6920
6921                 var fragmentId = /^#.+/; // Safari 2 reports '#' for an empty hash
6922                 this.anchors.each(function(i, a) {
6923                         var href = $(a).attr('href');
6924
6925                         // For dynamically created HTML that contains a hash as href IE < 8 expands
6926                         // such href to the full page url with hash and then misinterprets tab as ajax.
6927                         // Same consideration applies for an added tab with a fragment identifier
6928                         // since a[href=#fragment-identifier] does unexpectedly not match.
6929                         // Thus normalize href attribute...
6930                         var hrefBase = href.split('#')[0], baseEl;
6931                         if (hrefBase && (hrefBase === location.toString().split('#')[0] ||
6932                                         (baseEl = $('base')[0]) && hrefBase === baseEl.href)) {
6933                                 href = a.hash;
6934                                 a.href = href;
6935                         }
6936
6937                         // inline tab
6938                         if (fragmentId.test(href)) {
6939                                 self.panels = self.panels.add(self._sanitizeSelector(href));
6940                         }
6941
6942                         // remote tab
6943                         else if (href != '#') { // prevent loading the page itself if href is just "#"
6944                                 $.data(a, 'href.tabs', href); // required for restore on destroy
6945
6946                                 // TODO until #3808 is fixed strip fragment identifier from url
6947                                 // (IE fails to load from such url)
6948                                 $.data(a, 'load.tabs', href.replace(/#.*$/, '')); // mutable data
6949
6950                                 var id = self._tabId(a);
6951                                 a.href = '#' + id;
6952                                 var $panel = $('#' + id);
6953                                 if (!$panel.length) {
6954                                         $panel = $(o.panelTemplate).attr('id', id).addClass('ui-tabs-panel ui-widget-content ui-corner-bottom')
6955                                                 .insertAfter(self.panels[i - 1] || self.list);
6956                                         $panel.data('destroy.tabs', true);
6957                                 }
6958                                 self.panels = self.panels.add($panel);
6959                         }
6960
6961                         // invalid tab href
6962                         else {
6963                                 o.disabled.push(i);
6964                         }
6965                 });
6966
6967                 // initialization from scratch
6968                 if (init) {
6969
6970                         // attach necessary classes for styling
6971                         this.element.addClass('ui-tabs ui-widget ui-widget-content ui-corner-all');
6972                         this.list.addClass('ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all');
6973                         this.lis.addClass('ui-state-default ui-corner-top');
6974                         this.panels.addClass('ui-tabs-panel ui-widget-content ui-corner-bottom');
6975
6976                         // Selected tab
6977                         // use "selected" option or try to retrieve:
6978                         // 1. from fragment identifier in url
6979                         // 2. from cookie
6980                         // 3. from selected class attribute on <li>
6981                         if (o.selected === undefined) {
6982                                 if (location.hash) {
6983                                         this.anchors.each(function(i, a) {
6984                                                 if (a.hash == location.hash) {
6985                                                         o.selected = i;
6986                                                         return false; // break
6987                                                 }
6988                                         });
6989                                 }
6990                                 if (typeof o.selected != 'number' && o.cookie) {
6991                                         o.selected = parseInt(self._cookie(), 10);
6992                                 }
6993                                 if (typeof o.selected != 'number' && this.lis.filter('.ui-tabs-selected').length) {
6994                                         o.selected = this.lis.index(this.lis.filter('.ui-tabs-selected'));
6995                                 }
6996                                 o.selected = o.selected || (this.lis.length ? 0 : -1);
6997                         }
6998                         else if (o.selected === null) { // usage of null is deprecated, TODO remove in next release
6999                                 o.selected = -1;
7000                         }
7001
7002                         // sanity check - default to first tab...
7003                         o.selected = ((o.selected >= 0 && this.anchors[o.selected]) || o.selected < 0) ? o.selected : 0;
7004
7005                         // Take disabling tabs via class attribute from HTML
7006                         // into account and update option properly.
7007                         // A selected tab cannot become disabled.
7008                         o.disabled = $.unique(o.disabled.concat(
7009                                 $.map(this.lis.filter('.ui-state-disabled'),
7010                                         function(n, i) { return self.lis.index(n); } )
7011                         )).sort();
7012
7013                         if ($.inArray(o.selected, o.disabled) != -1) {
7014                                 o.disabled.splice($.inArray(o.selected, o.disabled), 1);
7015                         }
7016
7017                         // highlight selected tab
7018                         this.panels.addClass('ui-tabs-hide');
7019                         this.lis.removeClass('ui-tabs-selected ui-state-active');
7020                         if (o.selected >= 0 && this.anchors.length) { // check for length avoids error when initializing empty list
7021                                 this.panels.eq(o.selected).removeClass('ui-tabs-hide');
7022                                 this.lis.eq(o.selected).addClass('ui-tabs-selected ui-state-active');
7023
7024                                 // seems to be expected behavior that the show callback is fired
7025                                 self.element.queue("tabs", function() {
7026                                         self._trigger('show', null, self._ui(self.anchors[o.selected], self.panels[o.selected]));
7027                                 });
7028
7029                                 this.load(o.selected);
7030                         }
7031
7032                         // clean up to avoid memory leaks in certain versions of IE 6
7033                         $(window).bind('unload', function() {
7034                                 self.lis.add(self.anchors).unbind('.tabs');
7035                                 self.lis = self.anchors = self.panels = null;
7036                         });
7037
7038                 }
7039                 // update selected after add/remove
7040                 else {
7041                         o.selected = this.lis.index(this.lis.filter('.ui-tabs-selected'));
7042                 }
7043
7044                 // update collapsible
7045                 this.element[o.collapsible ? 'addClass' : 'removeClass']('ui-tabs-collapsible');
7046
7047                 // set or update cookie after init and add/remove respectively
7048                 if (o.cookie) {
7049                         this._cookie(o.selected, o.cookie);
7050                 }
7051
7052                 // disable tabs
7053                 for (var i = 0, li; (li = this.lis[i]); i++) {
7054                         $(li)[$.inArray(i, o.disabled) != -1 &&
7055                                 !$(li).hasClass('ui-tabs-selected') ? 'addClass' : 'removeClass']('ui-state-disabled');
7056                 }
7057
7058                 // reset cache if switching from cached to not cached
7059                 if (o.cache === false) {
7060                         this.anchors.removeData('cache.tabs');
7061                 }
7062
7063                 // remove all handlers before, tabify may run on existing tabs after add or option change
7064                 this.lis.add(this.anchors).unbind('.tabs');
7065
7066                 if (o.event != 'mouseover') {
7067                         var addState = function(state, el) {
7068                                 if (el.is(':not(.ui-state-disabled)')) {
7069                                         el.addClass('ui-state-' + state);
7070                                 }
7071                         };
7072                         var removeState = function(state, el) {
7073                                 el.removeClass('ui-state-' + state);
7074                         };
7075                         this.lis.bind('mouseover.tabs', function() {
7076                                 addState('hover', $(this));
7077                         });
7078                         this.lis.bind('mouseout.tabs', function() {
7079                                 removeState('hover', $(this));
7080                         });
7081                         this.anchors.bind('focus.tabs', function() {
7082                                 addState('focus', $(this).closest('li'));
7083                         });
7084                         this.anchors.bind('blur.tabs', function() {
7085                                 removeState('focus', $(this).closest('li'));
7086                         });
7087                 }
7088
7089                 // set up animations
7090                 var hideFx, showFx;
7091                 if (o.fx) {
7092                         if ($.isArray(o.fx)) {
7093                                 hideFx = o.fx[0];
7094                                 showFx = o.fx[1];
7095                         }
7096                         else {
7097                                 hideFx = showFx = o.fx;
7098                         }
7099                 }
7100
7101                 // Reset certain styles left over from animation
7102                 // and prevent IE's ClearType bug...
7103                 function resetStyle($el, fx) {
7104                         $el.css({ display: '' });
7105                         if (!$.support.opacity && fx.opacity) {
7106                                 $el[0].style.removeAttribute('filter');
7107                         }
7108                 }
7109
7110                 // Show a tab...
7111                 var showTab = showFx ?
7112                         function(clicked, $show) {
7113                                 $(clicked).closest('li').addClass('ui-tabs-selected ui-state-active');
7114                                 $show.hide().removeClass('ui-tabs-hide') // avoid flicker that way
7115                                         .animate(showFx, showFx.duration || 'normal', function() {
7116                                                 resetStyle($show, showFx);
7117                                                 self._trigger('show', null, self._ui(clicked, $show[0]));
7118                                         });
7119                         } :
7120                         function(clicked, $show) {
7121                                 $(clicked).closest('li').addClass('ui-tabs-selected ui-state-active');
7122                                 $show.removeClass('ui-tabs-hide');
7123                                 self._trigger('show', null, self._ui(clicked, $show[0]));
7124                         };
7125
7126                 // Hide a tab, $show is optional...
7127                 var hideTab = hideFx ?
7128                         function(clicked, $hide) {
7129                                 $hide.animate(hideFx, hideFx.duration || 'normal', function() {
7130                                         self.lis.removeClass('ui-tabs-selected ui-state-active');
7131                                         $hide.addClass('ui-tabs-hide');
7132                                         resetStyle($hide, hideFx);
7133                                         self.element.dequeue("tabs");
7134                                 });
7135                         } :
7136                         function(clicked, $hide, $show) {
7137                                 self.lis.removeClass('ui-tabs-selected ui-state-active');
7138                                 $hide.addClass('ui-tabs-hide');
7139                                 self.element.dequeue("tabs");
7140                         };
7141
7142                 // attach tab event handler, unbind to avoid duplicates from former tabifying...
7143                 this.anchors.bind(o.event + '.tabs', function() {
7144                         var el = this, $li = $(this).closest('li'), $hide = self.panels.filter(':not(.ui-tabs-hide)'),
7145                                         $show = $(self._sanitizeSelector(this.hash));
7146
7147                         // If tab is already selected and not collapsible or tab disabled or
7148                         // or is already loading or click callback returns false stop here.
7149                         // Check if click handler returns false last so that it is not executed
7150                         // for a disabled or loading tab!
7151                         if (($li.hasClass('ui-tabs-selected') && !o.collapsible) ||
7152                                 $li.hasClass('ui-state-disabled') ||
7153                                 $li.hasClass('ui-state-processing') ||
7154                                 self._trigger('select', null, self._ui(this, $show[0])) === false) {
7155                                 this.blur();
7156                                 return false;
7157                         }
7158
7159                         o.selected = self.anchors.index(this);
7160
7161                         self.abort();
7162
7163                         // if tab may be closed
7164                         if (o.collapsible) {
7165                                 if ($li.hasClass('ui-tabs-selected')) {
7166                                         o.selected = -1;
7167
7168                                         if (o.cookie) {
7169                                                 self._cookie(o.selected, o.cookie);
7170                                         }
7171
7172                                         self.element.queue("tabs", function() {
7173                                                 hideTab(el, $hide);
7174                                         }).dequeue("tabs");
7175
7176                                         this.blur();
7177                                         return false;
7178                                 }
7179                                 else if (!$hide.length) {
7180                                         if (o.cookie) {
7181                                                 self._cookie(o.selected, o.cookie);
7182                                         }
7183
7184                                         self.element.queue("tabs", function() {
7185                                                 showTab(el, $show);
7186                                         });
7187
7188                                         self.load(self.anchors.index(this)); // TODO make passing in node possible, see also http://dev.jqueryui.com/ticket/3171
7189
7190                                         this.blur();
7191                                         return false;
7192                                 }
7193                         }
7194
7195                         if (o.cookie) {
7196                                 self._cookie(o.selected, o.cookie);
7197                         }
7198
7199                         // show new tab
7200                         if ($show.length) {
7201                                 if ($hide.length) {
7202                                         self.element.queue("tabs", function() {
7203                                                 hideTab(el, $hide);
7204                                         });
7205                                 }
7206                                 self.element.queue("tabs", function() {
7207                                         showTab(el, $show);
7208                                 });
7209
7210                                 self.load(self.anchors.index(this));
7211                         }
7212                         else {
7213                                 throw 'jQuery UI Tabs: Mismatching fragment identifier.';
7214                         }
7215
7216                         // Prevent IE from keeping other link focussed when using the back button
7217                         // and remove dotted border from clicked link. This is controlled via CSS
7218                         // in modern browsers; blur() removes focus from address bar in Firefox
7219                         // which can become a usability and annoying problem with tabs('rotate').
7220                         if ($.browser.msie) {
7221                                 this.blur();
7222                         }
7223
7224                 });
7225
7226                 // disable click in any case
7227                 this.anchors.bind('click.tabs', function(){return false;});
7228
7229         },
7230
7231         destroy: function() {
7232                 var o = this.options;
7233
7234                 this.abort();
7235
7236                 this.element.unbind('.tabs')
7237                         .removeClass('ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible')
7238                         .removeData('tabs');
7239
7240                 this.list.removeClass('ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all');
7241
7242                 this.anchors.each(function() {
7243                         var href = $.data(this, 'href.tabs');
7244                         if (href) {
7245                                 this.href = href;
7246                         }
7247                         var $this = $(this).unbind('.tabs');
7248                         $.each(['href', 'load', 'cache'], function(i, prefix) {
7249                                 $this.removeData(prefix + '.tabs');
7250                         });
7251                 });
7252
7253                 this.lis.unbind('.tabs').add(this.panels).each(function() {
7254                         if ($.data(this, 'destroy.tabs')) {
7255                                 $(this).remove();
7256                         }
7257                         else {
7258                                 $(this).removeClass([
7259                                         'ui-state-default',
7260                                         'ui-corner-top',
7261                                         'ui-tabs-selected',
7262                                         'ui-state-active',
7263                                         'ui-state-hover',
7264                                         'ui-state-focus',
7265                                         'ui-state-disabled',
7266                                         'ui-tabs-panel',
7267                                         'ui-widget-content',
7268                                         'ui-corner-bottom',
7269                                         'ui-tabs-hide'
7270                                 ].join(' '));
7271                         }
7272                 });
7273
7274                 if (o.cookie) {
7275                         this._cookie(null, o.cookie);
7276                 }
7277
7278                 return this;
7279         },
7280
7281         add: function(url, label, index) {
7282                 if (index === undefined) {
7283                         index = this.anchors.length; // append by default
7284                 }
7285
7286                 var self = this, o = this.options,
7287                         $li = $(o.tabTemplate.replace(/#\{href\}/g, url).replace(/#\{label\}/g, label)),
7288                         id = !url.indexOf('#') ? url.replace('#', '') : this._tabId($('a', $li)[0]);
7289
7290                 $li.addClass('ui-state-default ui-corner-top').data('destroy.tabs', true);
7291
7292                 // try to find an existing element before creating a new one
7293                 var $panel = $('#' + id);
7294                 if (!$panel.length) {
7295                         $panel = $(o.panelTemplate).attr('id', id).data('destroy.tabs', true);
7296                 }
7297                 $panel.addClass('ui-tabs-panel ui-widget-content ui-corner-bottom ui-tabs-hide');
7298
7299                 if (index >= this.lis.length) {
7300                         $li.appendTo(this.list);
7301                         $panel.appendTo(this.list[0].parentNode);
7302                 }
7303                 else {
7304                         $li.insertBefore(this.lis[index]);
7305                         $panel.insertBefore(this.panels[index]);
7306                 }
7307
7308                 o.disabled = $.map(o.disabled,
7309                         function(n, i) { return n >= index ? ++n : n; });
7310
7311                 this._tabify();
7312
7313                 if (this.anchors.length == 1) { // after tabify
7314                         o.selected = 0;
7315                         $li.addClass('ui-tabs-selected ui-state-active');
7316                         $panel.removeClass('ui-tabs-hide');
7317                         this.element.queue("tabs", function() {
7318                                 self._trigger('show', null, self._ui(self.anchors[0], self.panels[0]));
7319                         });
7320
7321                         this.load(0);
7322                 }
7323
7324                 // callback
7325                 this._trigger('add', null, this._ui(this.anchors[index], this.panels[index]));
7326                 return this;
7327         },
7328
7329         remove: function(index) {
7330                 var o = this.options, $li = this.lis.eq(index).remove(),
7331                         $panel = this.panels.eq(index).remove();
7332
7333                 // If selected tab was removed focus tab to the right or
7334                 // in case the last tab was removed the tab to the left.
7335                 if ($li.hasClass('ui-tabs-selected') && this.anchors.length > 1) {
7336                         this.select(index + (index + 1 < this.anchors.length ? 1 : -1));
7337                 }
7338
7339                 o.disabled = $.map($.grep(o.disabled, function(n, i) { return n != index; }),
7340                         function(n, i) { return n >= index ? --n : n; });
7341
7342                 this._tabify();
7343
7344                 // callback
7345                 this._trigger('remove', null, this._ui($li.find('a')[0], $panel[0]));
7346                 return this;
7347         },
7348
7349         enable: function(index) {
7350                 var o = this.options;
7351                 if ($.inArray(index, o.disabled) == -1) {
7352                         return;
7353                 }
7354
7355                 this.lis.eq(index).removeClass('ui-state-disabled');
7356                 o.disabled = $.grep(o.disabled, function(n, i) { return n != index; });
7357
7358                 // callback
7359                 this._trigger('enable', null, this._ui(this.anchors[index], this.panels[index]));
7360                 return this;
7361         },
7362
7363         disable: function(index) {
7364                 var self = this, o = this.options;
7365                 if (index != o.selected) { // cannot disable already selected tab
7366                         this.lis.eq(index).addClass('ui-state-disabled');
7367
7368                         o.disabled.push(index);
7369                         o.disabled.sort();
7370
7371                         // callback
7372                         this._trigger('disable', null, this._ui(this.anchors[index], this.panels[index]));
7373                 }
7374
7375                 return this;
7376         },
7377
7378         select: function(index) {
7379                 if (typeof index == 'string') {
7380                         index = this.anchors.index(this.anchors.filter('[href$=' + index + ']'));
7381                 }
7382                 else if (index === null) { // usage of null is deprecated, TODO remove in next release
7383                         index = -1;
7384                 }
7385                 if (index == -1 && this.options.collapsible) {
7386                         index = this.options.selected;
7387                 }
7388
7389                 this.anchors.eq(index).trigger(this.options.event + '.tabs');
7390                 return this;
7391         },
7392
7393         load: function(index) {
7394                 var self = this, o = this.options, a = this.anchors.eq(index)[0], url = $.data(a, 'load.tabs');
7395
7396                 this.abort();
7397
7398                 // not remote or from cache
7399                 if (!url || this.element.queue("tabs").length !== 0 && $.data(a, 'cache.tabs')) {
7400                         this.element.dequeue("tabs");
7401                         return;
7402                 }
7403
7404                 // load remote from here on
7405                 this.lis.eq(index).addClass('ui-state-processing');
7406
7407                 if (o.spinner) {
7408                         var span = $('span', a);
7409                         span.data('label.tabs', span.html()).html(o.spinner);
7410                 }
7411
7412                 this.xhr = $.ajax($.extend({}, o.ajaxOptions, {
7413                         url: url,
7414                         success: function(r, s) {
7415                                 $(self._sanitizeSelector(a.hash)).html(r);
7416
7417                                 // take care of tab labels
7418                                 self._cleanup();
7419
7420                                 if (o.cache) {
7421                                         $.data(a, 'cache.tabs', true); // if loaded once do not load them again
7422                                 }
7423
7424                                 // callbacks
7425                                 self._trigger('load', null, self._ui(self.anchors[index], self.panels[index]));
7426                                 try {
7427                                         o.ajaxOptions.success(r, s);
7428                                 }
7429                                 catch (e) {}
7430                         },
7431                         error: function(xhr, s, e) {
7432                                 // take care of tab labels
7433                                 self._cleanup();
7434
7435                                 // callbacks
7436                                 self._trigger('load', null, self._ui(self.anchors[index], self.panels[index]));
7437                                 try {
7438                                         // Passing index avoid a race condition when this method is
7439                                         // called after the user has selected another tab.
7440                                         // Pass the anchor that initiated this request allows
7441                                         // loadError to manipulate the tab content panel via $(a.hash)
7442                                         o.ajaxOptions.error(xhr, s, index, a);
7443                                 }
7444                                 catch (e) {}
7445                         }
7446                 }));
7447
7448                 // last, so that load event is fired before show...
7449                 self.element.dequeue("tabs");
7450
7451                 return this;
7452         },
7453
7454         abort: function() {
7455                 // stop possibly running animations
7456                 this.element.queue([]);
7457                 this.panels.stop(false, true);
7458
7459                 // "tabs" queue must not contain more than two elements,
7460                 // which are the callbacks for the latest clicked tab...
7461                 this.element.queue("tabs", this.element.queue("tabs").splice(-2, 2));
7462
7463                 // terminate pending requests from other tabs
7464                 if (this.xhr) {
7465                         this.xhr.abort();
7466                         delete this.xhr;
7467                 }
7468
7469                 // take care of tab labels
7470                 this._cleanup();
7471                 return this;
7472         },
7473
7474         url: function(index, url) {
7475                 this.anchors.eq(index).removeData('cache.tabs').data('load.tabs', url);
7476                 return this;
7477         },
7478
7479         length: function() {
7480                 return this.anchors.length;
7481         }
7482
7483 });
7484
7485 $.extend($.ui.tabs, {
7486         version: '1.8'
7487 });
7488
7489 /*
7490  * Tabs Extensions
7491  */
7492
7493 /*
7494  * Rotate
7495  */
7496 $.extend($.ui.tabs.prototype, {
7497         rotation: null,
7498         rotate: function(ms, continuing) {
7499
7500                 var self = this, o = this.options;
7501
7502                 var rotate = self._rotate || (self._rotate = function(e) {
7503                         clearTimeout(self.rotation);
7504                         self.rotation = setTimeout(function() {
7505                                 var t = o.selected;
7506                                 self.select( ++t < self.anchors.length ? t : 0 );
7507                         }, ms);
7508
7509                         if (e) {
7510                                 e.stopPropagation();
7511                         }
7512                 });
7513
7514                 var stop = self._unrotate || (self._unrotate = !continuing ?
7515                         function(e) {
7516                                 if (e.clientX) { // in case of a true click
7517                                         self.rotate(null);
7518                                 }
7519                         } :
7520                         function(e) {
7521                                 t = o.selected;
7522                                 rotate();
7523                         });
7524
7525                 // start rotation
7526                 if (ms) {
7527                         this.element.bind('tabsshow', rotate);
7528                         this.anchors.bind(o.event + '.tabs', stop);
7529                         rotate();
7530                 }
7531                 // stop rotation
7532                 else {
7533                         clearTimeout(self.rotation);
7534                         this.element.unbind('tabsshow', rotate);
7535                         this.anchors.unbind(o.event + '.tabs', stop);
7536                         delete this._rotate;
7537                         delete this._unrotate;
7538                 }
7539
7540                 return this;
7541         }
7542 });
7543
7544 })(jQuery);
7545 /*
7546  * jQuery UI Datepicker 1.8
7547  *
7548  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
7549  * Dual licensed under the MIT (MIT-LICENSE.txt)
7550  * and GPL (GPL-LICENSE.txt) licenses.
7551  *
7552  * http://docs.jquery.com/UI/Datepicker
7553  *
7554  * Depends:
7555  *      jquery.ui.core.js
7556  */
7557
7558 (function($) { // hide the namespace
7559
7560 $.extend($.ui, { datepicker: { version: "1.8" } });
7561
7562 var PROP_NAME = 'datepicker';
7563 var dpuuid = new Date().getTime();
7564
7565 /* Date picker manager.
7566    Use the singleton instance of this class, $.datepicker, to interact with the date picker.
7567    Settings for (groups of) date pickers are maintained in an instance object,
7568    allowing multiple different settings on the same page. */
7569
7570 function Datepicker() {
7571         this.debug = false; // Change this to true to start debugging
7572         this._curInst = null; // The current instance in use
7573         this._keyEvent = false; // If the last event was a key event
7574         this._disabledInputs = []; // List of date picker inputs that have been disabled
7575         this._datepickerShowing = false; // True if the popup picker is showing , false if not
7576         this._inDialog = false; // True if showing within a "dialog", false if not
7577         this._mainDivId = 'ui-datepicker-div'; // The ID of the main datepicker division
7578         this._inlineClass = 'ui-datepicker-inline'; // The name of the inline marker class
7579         this._appendClass = 'ui-datepicker-append'; // The name of the append marker class
7580         this._triggerClass = 'ui-datepicker-trigger'; // The name of the trigger marker class
7581         this._dialogClass = 'ui-datepicker-dialog'; // The name of the dialog marker class
7582         this._disableClass = 'ui-datepicker-disabled'; // The name of the disabled covering marker class
7583         this._unselectableClass = 'ui-datepicker-unselectable'; // The name of the unselectable cell marker class
7584         this._currentClass = 'ui-datepicker-current-day'; // The name of the current day marker class
7585         this._dayOverClass = 'ui-datepicker-days-cell-over'; // The name of the day hover marker class
7586         this.regional = []; // Available regional settings, indexed by language code
7587         this.regional[''] = { // Default regional settings
7588                 closeText: 'Done', // Display text for close link
7589                 prevText: 'Prev', // Display text for previous month link
7590                 nextText: 'Next', // Display text for next month link
7591                 currentText: 'Today', // Display text for current month link
7592                 monthNames: ['January','February','March','April','May','June',
7593                         'July','August','September','October','November','December'], // Names of months for drop-down and formatting
7594                 monthNamesShort: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'], // For formatting
7595                 dayNames: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'], // For formatting
7596                 dayNamesShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'], // For formatting
7597                 dayNamesMin: ['Su','Mo','Tu','We','Th','Fr','Sa'], // Column headings for days starting at Sunday
7598                 weekHeader: 'Wk', // Column header for week of the year
7599                 dateFormat: 'mm/dd/yy', // See format options on parseDate
7600                 firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
7601                 isRTL: false, // True if right-to-left language, false if left-to-right
7602                 showMonthAfterYear: false, // True if the year select precedes month, false for month then year
7603                 yearSuffix: '' // Additional text to append to the year in the month headers
7604         };
7605         this._defaults = { // Global defaults for all the date picker instances
7606                 showOn: 'focus', // 'focus' for popup on focus,
7607                         // 'button' for trigger button, or 'both' for either
7608                 showAnim: 'show', // Name of jQuery animation for popup
7609                 showOptions: {}, // Options for enhanced animations
7610                 defaultDate: null, // Used when field is blank: actual date,
7611                         // +/-number for offset from today, null for today
7612                 appendText: '', // Display text following the input box, e.g. showing the format
7613                 buttonText: '...', // Text for trigger button
7614                 buttonImage: '', // URL for trigger button image
7615                 buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
7616                 hideIfNoPrevNext: false, // True to hide next/previous month links
7617                         // if not applicable, false to just disable them
7618                 navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
7619                 gotoCurrent: false, // True if today link goes back to current selection instead
7620                 changeMonth: false, // True if month can be selected directly, false if only prev/next
7621                 changeYear: false, // True if year can be selected directly, false if only prev/next
7622                 yearRange: 'c-10:c+10', // Range of years to display in drop-down,
7623                         // either relative to today's year (-nn:+nn), relative to currently displayed year
7624                         // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
7625                 showOtherMonths: false, // True to show dates in other months, false to leave blank
7626                 selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
7627                 showWeek: false, // True to show week of the year, false to not show it
7628                 calculateWeek: this.iso8601Week, // How to calculate the week of the year,
7629                         // takes a Date and returns the number of the week for it
7630                 shortYearCutoff: '+10', // Short year values < this are in the current century,
7631                         // > this are in the previous century,
7632                         // string value starting with '+' for current year + value
7633                 minDate: null, // The earliest selectable date, or null for no limit
7634                 maxDate: null, // The latest selectable date, or null for no limit
7635                 duration: '_default', // Duration of display/closure
7636                 beforeShowDay: null, // Function that takes a date and returns an array with
7637                         // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or '',
7638                         // [2] = cell title (optional), e.g. $.datepicker.noWeekends
7639                 beforeShow: null, // Function that takes an input field and
7640                         // returns a set of custom settings for the date picker
7641                 onSelect: null, // Define a callback function when a date is selected
7642                 onChangeMonthYear: null, // Define a callback function when the month or year is changed
7643                 onClose: null, // Define a callback function when the datepicker is closed
7644                 numberOfMonths: 1, // Number of months to show at a time
7645                 showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
7646                 stepMonths: 1, // Number of months to step back/forward
7647                 stepBigMonths: 12, // Number of months to step back/forward for the big links
7648                 altField: '', // Selector for an alternate field to store selected dates into
7649                 altFormat: '', // The date format to use for the alternate field
7650                 constrainInput: true, // The input is constrained by the current date format
7651                 showButtonPanel: false, // True to show button panel, false to not show it
7652                 autoSize: false // True to size the input for the date format, false to leave as is
7653         };
7654         $.extend(this._defaults, this.regional['']);
7655         this.dpDiv = $('<div id="' + this._mainDivId + '" class="ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all ui-helper-hidden-accessible"></div>');
7656 }
7657
7658 $.extend(Datepicker.prototype, {
7659         /* Class name added to elements to indicate already configured with a date picker. */
7660         markerClassName: 'hasDatepicker',
7661
7662         /* Debug logging (if enabled). */
7663         log: function () {
7664                 if (this.debug)
7665                         console.log.apply('', arguments);
7666         },
7667
7668         // TODO rename to "widget" when switching to widget factory
7669         _widgetDatepicker: function() {
7670                 return this.dpDiv;
7671         },
7672
7673         /* Override the default settings for all instances of the date picker.
7674            @param  settings  object - the new settings to use as defaults (anonymous object)
7675            @return the manager object */
7676         setDefaults: function(settings) {
7677                 extendRemove(this._defaults, settings || {});
7678                 return this;
7679         },
7680
7681         /* Attach the date picker to a jQuery selection.
7682            @param  target    element - the target input field or division or span
7683            @param  settings  object - the new settings to use for this date picker instance (anonymous) */
7684         _attachDatepicker: function(target, settings) {
7685                 // check for settings on the control itself - in namespace 'date:'
7686                 var inlineSettings = null;
7687                 for (var attrName in this._defaults) {
7688                         var attrValue = target.getAttribute('date:' + attrName);
7689                         if (attrValue) {
7690                                 inlineSettings = inlineSettings || {};
7691                                 try {
7692                                         inlineSettings[attrName] = eval(attrValue);
7693                                 } catch (err) {
7694                                         inlineSettings[attrName] = attrValue;
7695                                 }
7696                         }
7697                 }
7698                 var nodeName = target.nodeName.toLowerCase();
7699                 var inline = (nodeName == 'div' || nodeName == 'span');
7700                 if (!target.id)
7701                         target.id = 'dp' + (++this.uuid);
7702                 var inst = this._newInst($(target), inline);
7703                 inst.settings = $.extend({}, settings || {}, inlineSettings || {});
7704                 if (nodeName == 'input') {
7705                         this._connectDatepicker(target, inst);
7706                 } else if (inline) {
7707                         this._inlineDatepicker(target, inst);
7708                 }
7709         },
7710
7711         /* Create a new instance object. */
7712         _newInst: function(target, inline) {
7713                 var id = target[0].id.replace(/([^A-Za-z0-9_])/g, '\\\\$1'); // escape jQuery meta chars
7714                 return {id: id, input: target, // associated target
7715                         selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
7716                         drawMonth: 0, drawYear: 0, // month being drawn
7717                         inline: inline, // is datepicker inline or not
7718                         dpDiv: (!inline ? this.dpDiv : // presentation div
7719                         $('<div class="' + this._inlineClass + ' ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all"></div>'))};
7720         },
7721
7722         /* Attach the date picker to an input field. */
7723         _connectDatepicker: function(target, inst) {
7724                 var input = $(target);
7725                 inst.append = $([]);
7726                 inst.trigger = $([]);
7727                 if (input.hasClass(this.markerClassName))
7728                         return;
7729                 this._attachments(input, inst);
7730                 input.addClass(this.markerClassName).keydown(this._doKeyDown).
7731                         keypress(this._doKeyPress).keyup(this._doKeyUp).
7732                         bind("setData.datepicker", function(event, key, value) {
7733                                 inst.settings[key] = value;
7734                         }).bind("getData.datepicker", function(event, key) {
7735                                 return this._get(inst, key);
7736                         });
7737                 this._autoSize(inst);
7738                 $.data(target, PROP_NAME, inst);
7739         },
7740
7741         /* Make attachments based on settings. */
7742         _attachments: function(input, inst) {
7743                 var appendText = this._get(inst, 'appendText');
7744                 var isRTL = this._get(inst, 'isRTL');
7745                 if (inst.append)
7746                         inst.append.remove();
7747                 if (appendText) {
7748                         inst.append = $('<span class="' + this._appendClass + '">' + appendText + '</span>');
7749                         input[isRTL ? 'before' : 'after'](inst.append);
7750                 }
7751                 input.unbind('focus', this._showDatepicker);
7752                 if (inst.trigger)
7753                         inst.trigger.remove();
7754                 var showOn = this._get(inst, 'showOn');
7755                 if (showOn == 'focus' || showOn == 'both') // pop-up date picker when in the marked field
7756                         input.focus(this._showDatepicker);
7757                 if (showOn == 'button' || showOn == 'both') { // pop-up date picker when button clicked
7758                         var buttonText = this._get(inst, 'buttonText');
7759                         var buttonImage = this._get(inst, 'buttonImage');
7760                         inst.trigger = $(this._get(inst, 'buttonImageOnly') ?
7761                                 $('<img/>').addClass(this._triggerClass).
7762                                         attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
7763                                 $('<button type="button"></button>').addClass(this._triggerClass).
7764                                         html(buttonImage == '' ? buttonText : $('<img/>').attr(
7765                                         { src:buttonImage, alt:buttonText, title:buttonText })));
7766                         input[isRTL ? 'before' : 'after'](inst.trigger);
7767                         inst.trigger.click(function() {
7768                                 if ($.datepicker._datepickerShowing && $.datepicker._lastInput == input[0])
7769                                         $.datepicker._hideDatepicker();
7770                                 else
7771                                         $.datepicker._showDatepicker(input[0]);
7772                                 return false;
7773                         });
7774                 }
7775         },
7776
7777         /* Apply the maximum length for the date format. */
7778         _autoSize: function(inst) {
7779                 if (this._get(inst, 'autoSize') && !inst.inline) {
7780                         var date = new Date(2009, 12 - 1, 20); // Ensure double digits
7781                         var dateFormat = this._get(inst, 'dateFormat');
7782                         if (dateFormat.match(/[DM]/)) {
7783                                 var findMax = function(names) {
7784                                         var max = 0;
7785                                         var maxI = 0;
7786                                         for (var i = 0; i < names.length; i++) {
7787                                                 if (names[i].length > max) {
7788                                                         max = names[i].length;
7789                                                         maxI = i;
7790                                                 }
7791                                         }
7792                                         return maxI;
7793                                 };
7794                                 date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
7795                                         'monthNames' : 'monthNamesShort'))));
7796                                 date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
7797                                         'dayNames' : 'dayNamesShort'))) + 20 - date.getDay());
7798                         }
7799                         inst.input.attr('size', this._formatDate(inst, date).length);
7800                 }
7801         },
7802
7803         /* Attach an inline date picker to a div. */
7804         _inlineDatepicker: function(target, inst) {
7805                 var divSpan = $(target);
7806                 if (divSpan.hasClass(this.markerClassName))
7807                         return;
7808                 divSpan.addClass(this.markerClassName).append(inst.dpDiv).
7809                         bind("setData.datepicker", function(event, key, value){
7810                                 inst.settings[key] = value;
7811                         }).bind("getData.datepicker", function(event, key){
7812                                 return this._get(inst, key);
7813                         });
7814                 $.data(target, PROP_NAME, inst);
7815                 this._setDate(inst, this._getDefaultDate(inst), true);
7816                 this._updateDatepicker(inst);
7817                 this._updateAlternate(inst);
7818         },
7819
7820         /* Pop-up the date picker in a "dialog" box.
7821            @param  input     element - ignored
7822            @param  date      string or Date - the initial date to display
7823            @param  onSelect  function - the function to call when a date is selected
7824            @param  settings  object - update the dialog date picker instance's settings (anonymous object)
7825            @param  pos       int[2] - coordinates for the dialog's position within the screen or
7826                              event - with x/y coordinates or
7827                              leave empty for default (screen centre)
7828            @return the manager object */
7829         _dialogDatepicker: function(input, date, onSelect, settings, pos) {
7830                 var inst = this._dialogInst; // internal instance
7831                 if (!inst) {
7832                         var id = 'dp' + (++this.uuid);
7833                         this._dialogInput = $('<input type="text" id="' + id +
7834                                 '" style="position: absolute; top: -100px; width: 0px; z-index: -10;"/>');
7835                         this._dialogInput.keydown(this._doKeyDown);
7836                         $('body').append(this._dialogInput);
7837                         inst = this._dialogInst = this._newInst(this._dialogInput, false);
7838                         inst.settings = {};
7839                         $.data(this._dialogInput[0], PROP_NAME, inst);
7840                 }
7841                 extendRemove(inst.settings, settings || {});
7842                 date = (date && date.constructor == Date ? this._formatDate(inst, date) : date);
7843                 this._dialogInput.val(date);
7844
7845                 this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
7846                 if (!this._pos) {
7847                         var browserWidth = document.documentElement.clientWidth;
7848                         var browserHeight = document.documentElement.clientHeight;
7849                         var scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
7850                         var scrollY = document.documentElement.scrollTop || document.body.scrollTop;
7851                         this._pos = // should use actual width/height below
7852                                 [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
7853                 }
7854
7855                 // move input on screen for focus, but hidden behind dialog
7856                 this._dialogInput.css('left', (this._pos[0] + 20) + 'px').css('top', this._pos[1] + 'px');
7857                 inst.settings.onSelect = onSelect;
7858                 this._inDialog = true;
7859                 this.dpDiv.addClass(this._dialogClass);
7860                 this._showDatepicker(this._dialogInput[0]);
7861                 if ($.blockUI)
7862                         $.blockUI(this.dpDiv);
7863                 $.data(this._dialogInput[0], PROP_NAME, inst);
7864                 return this;
7865         },
7866
7867         /* Detach a datepicker from its control.
7868            @param  target    element - the target input field or division or span */
7869         _destroyDatepicker: function(target) {
7870                 var $target = $(target);
7871                 var inst = $.data(target, PROP_NAME);
7872                 if (!$target.hasClass(this.markerClassName)) {
7873                         return;
7874                 }
7875                 var nodeName = target.nodeName.toLowerCase();
7876                 $.removeData(target, PROP_NAME);
7877                 if (nodeName == 'input') {
7878                         inst.append.remove();
7879                         inst.trigger.remove();
7880                         $target.removeClass(this.markerClassName).
7881                                 unbind('focus', this._showDatepicker).
7882                                 unbind('keydown', this._doKeyDown).
7883                                 unbind('keypress', this._doKeyPress).
7884                                 unbind('keyup', this._doKeyUp);
7885                 } else if (nodeName == 'div' || nodeName == 'span')
7886                         $target.removeClass(this.markerClassName).empty();
7887         },
7888
7889         /* Enable the date picker to a jQuery selection.
7890            @param  target    element - the target input field or division or span */
7891         _enableDatepicker: function(target) {
7892                 var $target = $(target);
7893                 var inst = $.data(target, PROP_NAME);
7894                 if (!$target.hasClass(this.markerClassName)) {
7895                         return;
7896                 }
7897                 var nodeName = target.nodeName.toLowerCase();
7898                 if (nodeName == 'input') {
7899                         target.disabled = false;
7900                         inst.trigger.filter('button').
7901                                 each(function() { this.disabled = false; }).end().
7902                                 filter('img').css({opacity: '1.0', cursor: ''});
7903                 }
7904                 else if (nodeName == 'div' || nodeName == 'span') {
7905                         var inline = $target.children('.' + this._inlineClass);
7906                         inline.children().removeClass('ui-state-disabled');
7907                 }
7908                 this._disabledInputs = $.map(this._disabledInputs,
7909                         function(value) { return (value == target ? null : value); }); // delete entry
7910         },
7911
7912         /* Disable the date picker to a jQuery selection.
7913            @param  target    element - the target input field or division or span */
7914         _disableDatepicker: function(target) {
7915                 var $target = $(target);
7916                 var inst = $.data(target, PROP_NAME);
7917                 if (!$target.hasClass(this.markerClassName)) {
7918                         return;
7919                 }
7920                 var nodeName = target.nodeName.toLowerCase();
7921                 if (nodeName == 'input') {
7922                         target.disabled = true;
7923                         inst.trigger.filter('button').
7924                                 each(function() { this.disabled = true; }).end().
7925                                 filter('img').css({opacity: '0.5', cursor: 'default'});
7926                 }
7927                 else if (nodeName == 'div' || nodeName == 'span') {
7928                         var inline = $target.children('.' + this._inlineClass);
7929                         inline.children().addClass('ui-state-disabled');
7930                 }
7931                 this._disabledInputs = $.map(this._disabledInputs,
7932                         function(value) { return (value == target ? null : value); }); // delete entry
7933                 this._disabledInputs[this._disabledInputs.length] = target;
7934         },
7935
7936         /* Is the first field in a jQuery collection disabled as a datepicker?
7937            @param  target    element - the target input field or division or span
7938            @return boolean - true if disabled, false if enabled */
7939         _isDisabledDatepicker: function(target) {
7940                 if (!target) {
7941                         return false;
7942                 }
7943                 for (var i = 0; i < this._disabledInputs.length; i++) {
7944                         if (this._disabledInputs[i] == target)
7945                                 return true;
7946                 }
7947                 return false;
7948         },
7949
7950         /* Retrieve the instance data for the target control.
7951            @param  target  element - the target input field or division or span
7952            @return  object - the associated instance data
7953            @throws  error if a jQuery problem getting data */
7954         _getInst: function(target) {
7955                 try {
7956                         return $.data(target, PROP_NAME);
7957                 }
7958                 catch (err) {
7959                         throw 'Missing instance data for this datepicker';
7960                 }
7961         },
7962
7963         /* Update or retrieve the settings for a date picker attached to an input field or division.
7964            @param  target  element - the target input field or division or span
7965            @param  name    object - the new settings to update or
7966                            string - the name of the setting to change or retrieve,
7967                            when retrieving also 'all' for all instance settings or
7968                            'defaults' for all global defaults
7969            @param  value   any - the new value for the setting
7970                            (omit if above is an object or to retrieve a value) */
7971         _optionDatepicker: function(target, name, value) {
7972                 var inst = this._getInst(target);
7973                 if (arguments.length == 2 && typeof name == 'string') {
7974                         return (name == 'defaults' ? $.extend({}, $.datepicker._defaults) :
7975                                 (inst ? (name == 'all' ? $.extend({}, inst.settings) :
7976                                 this._get(inst, name)) : null));
7977                 }
7978                 var settings = name || {};
7979                 if (typeof name == 'string') {
7980                         settings = {};
7981                         settings[name] = value;
7982                 }
7983                 if (inst) {
7984                         if (this._curInst == inst) {
7985                                 this._hideDatepicker();
7986                         }
7987                         var date = this._getDateDatepicker(target, true);
7988                         extendRemove(inst.settings, settings);
7989                         this._attachments($(target), inst);
7990                         this._autoSize(inst);
7991                         this._setDateDatepicker(target, date);
7992                         this._updateDatepicker(inst);
7993                 }
7994         },
7995
7996         // change method deprecated
7997         _changeDatepicker: function(target, name, value) {
7998                 this._optionDatepicker(target, name, value);
7999         },
8000
8001         /* Redraw the date picker attached to an input field or division.
8002            @param  target  element - the target input field or division or span */
8003         _refreshDatepicker: function(target) {
8004                 var inst = this._getInst(target);
8005                 if (inst) {
8006                         this._updateDatepicker(inst);
8007                 }
8008         },
8009
8010         /* Set the dates for a jQuery selection.
8011            @param  target   element - the target input field or division or span
8012            @param  date     Date - the new date */
8013         _setDateDatepicker: function(target, date) {
8014                 var inst = this._getInst(target);
8015                 if (inst) {
8016                         this._setDate(inst, date);
8017                         this._updateDatepicker(inst);
8018                         this._updateAlternate(inst);
8019                 }
8020         },
8021
8022         /* Get the date(s) for the first entry in a jQuery selection.
8023            @param  target     element - the target input field or division or span
8024            @param  noDefault  boolean - true if no default date is to be used
8025            @return Date - the current date */
8026         _getDateDatepicker: function(target, noDefault) {
8027                 var inst = this._getInst(target);
8028                 if (inst && !inst.inline)
8029                         this._setDateFromField(inst, noDefault);
8030                 return (inst ? this._getDate(inst) : null);
8031         },
8032
8033         /* Handle keystrokes. */
8034         _doKeyDown: function(event) {
8035                 var inst = $.datepicker._getInst(event.target);
8036                 var handled = true;
8037                 var isRTL = inst.dpDiv.is('.ui-datepicker-rtl');
8038                 inst._keyEvent = true;
8039                 if ($.datepicker._datepickerShowing)
8040                         switch (event.keyCode) {
8041                                 case 9: $.datepicker._hideDatepicker();
8042                                                 handled = false;
8043                                                 break; // hide on tab out
8044                                 case 13: var sel = $('td.' + $.datepicker._dayOverClass, inst.dpDiv).
8045                                                         add($('td.' + $.datepicker._currentClass, inst.dpDiv));
8046                                                 if (sel[0])
8047                                                         $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
8048                                                 else
8049                                                         $.datepicker._hideDatepicker();
8050                                                 return false; // don't submit the form
8051                                                 break; // select the value on enter
8052                                 case 27: $.datepicker._hideDatepicker();
8053                                                 break; // hide on escape
8054                                 case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8055                                                         -$.datepicker._get(inst, 'stepBigMonths') :
8056                                                         -$.datepicker._get(inst, 'stepMonths')), 'M');
8057                                                 break; // previous month/year on page up/+ ctrl
8058                                 case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8059                                                         +$.datepicker._get(inst, 'stepBigMonths') :
8060                                                         +$.datepicker._get(inst, 'stepMonths')), 'M');
8061                                                 break; // next month/year on page down/+ ctrl
8062                                 case 35: if (event.ctrlKey || event.metaKey) $.datepicker._clearDate(event.target);
8063                                                 handled = event.ctrlKey || event.metaKey;
8064                                                 break; // clear on ctrl or command +end
8065                                 case 36: if (event.ctrlKey || event.metaKey) $.datepicker._gotoToday(event.target);
8066                                                 handled = event.ctrlKey || event.metaKey;
8067                                                 break; // current on ctrl or command +home
8068                                 case 37: if (event.ctrlKey || event.metaKey) $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), 'D');
8069                                                 handled = event.ctrlKey || event.metaKey;
8070                                                 // -1 day on ctrl or command +left
8071                                                 if (event.originalEvent.altKey) $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8072                                                                         -$.datepicker._get(inst, 'stepBigMonths') :
8073                                                                         -$.datepicker._get(inst, 'stepMonths')), 'M');
8074                                                 // next month/year on alt +left on Mac
8075                                                 break;
8076                                 case 38: if (event.ctrlKey || event.metaKey) $.datepicker._adjustDate(event.target, -7, 'D');
8077                                                 handled = event.ctrlKey || event.metaKey;
8078                                                 break; // -1 week on ctrl or command +up
8079                                 case 39: if (event.ctrlKey || event.metaKey) $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), 'D');
8080                                                 handled = event.ctrlKey || event.metaKey;
8081                                                 // +1 day on ctrl or command +right
8082                                                 if (event.originalEvent.altKey) $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8083                                                                         +$.datepicker._get(inst, 'stepBigMonths') :
8084                                                                         +$.datepicker._get(inst, 'stepMonths')), 'M');
8085                                                 // next month/year on alt +right
8086                                                 break;
8087                                 case 40: if (event.ctrlKey || event.metaKey) $.datepicker._adjustDate(event.target, +7, 'D');
8088                                                 handled = event.ctrlKey || event.metaKey;
8089                                                 break; // +1 week on ctrl or command +down
8090                                 default: handled = false;
8091                         }
8092                 else if (event.keyCode == 36 && event.ctrlKey) // display the date picker on ctrl+home
8093                         $.datepicker._showDatepicker(this);
8094                 else {
8095                         handled = false;
8096                 }
8097                 if (handled) {
8098                         event.preventDefault();
8099                         event.stopPropagation();
8100                 }
8101         },
8102
8103         /* Filter entered characters - based on date format. */
8104         _doKeyPress: function(event) {
8105                 var inst = $.datepicker._getInst(event.target);
8106                 if ($.datepicker._get(inst, 'constrainInput')) {
8107                         var chars = $.datepicker._possibleChars($.datepicker._get(inst, 'dateFormat'));
8108                         var chr = String.fromCharCode(event.charCode == undefined ? event.keyCode : event.charCode);
8109                         return event.ctrlKey || (chr < ' ' || !chars || chars.indexOf(chr) > -1);
8110                 }
8111         },
8112
8113         /* Synchronise manual entry and field/alternate field. */
8114         _doKeyUp: function(event) {
8115                 var inst = $.datepicker._getInst(event.target);
8116                 if (inst.input.val() != inst.lastVal) {
8117                         try {
8118                                 var date = $.datepicker.parseDate($.datepicker._get(inst, 'dateFormat'),
8119                                         (inst.input ? inst.input.val() : null),
8120                                         $.datepicker._getFormatConfig(inst));
8121                                 if (date) { // only if valid
8122                                         $.datepicker._setDateFromField(inst);
8123                                         $.datepicker._updateAlternate(inst);
8124                                         $.datepicker._updateDatepicker(inst);
8125                                 }
8126                         }
8127                         catch (event) {
8128                                 $.datepicker.log(event);
8129                         }
8130                 }
8131                 return true;
8132         },
8133
8134         /* Pop-up the date picker for a given input field.
8135            @param  input  element - the input field attached to the date picker or
8136                           event - if triggered by focus */
8137         _showDatepicker: function(input) {
8138                 input = input.target || input;
8139                 if (input.nodeName.toLowerCase() != 'input') // find from button/image trigger
8140                         input = $('input', input.parentNode)[0];
8141                 if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput == input) // already here
8142                         return;
8143                 var inst = $.datepicker._getInst(input);
8144                 if ($.datepicker._curInst && $.datepicker._curInst != inst) {
8145                         $.datepicker._curInst.dpDiv.stop(true, true);
8146                 }
8147                 var beforeShow = $.datepicker._get(inst, 'beforeShow');
8148                 extendRemove(inst.settings, (beforeShow ? beforeShow.apply(input, [input, inst]) : {}));
8149                 inst.lastVal = null;
8150                 $.datepicker._lastInput = input;
8151                 $.datepicker._setDateFromField(inst);
8152                 if ($.datepicker._inDialog) // hide cursor
8153                         input.value = '';
8154                 if (!$.datepicker._pos) { // position below input
8155                         $.datepicker._pos = $.datepicker._findPos(input);
8156                         $.datepicker._pos[1] += input.offsetHeight; // add the height
8157                 }
8158                 var isFixed = false;
8159                 $(input).parents().each(function() {
8160                         isFixed |= $(this).css('position') == 'fixed';
8161                         return !isFixed;
8162                 });
8163                 if (isFixed && $.browser.opera) { // correction for Opera when fixed and scrolled
8164                         $.datepicker._pos[0] -= document.documentElement.scrollLeft;
8165                         $.datepicker._pos[1] -= document.documentElement.scrollTop;
8166                 }
8167                 var offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
8168                 $.datepicker._pos = null;
8169                 // determine sizing offscreen
8170                 inst.dpDiv.css({position: 'absolute', display: 'block', top: '-1000px'});
8171                 $.datepicker._updateDatepicker(inst);
8172                 // fix width for dynamic number of date pickers
8173                 // and adjust position before showing
8174                 offset = $.datepicker._checkOffset(inst, offset, isFixed);
8175                 inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
8176                         'static' : (isFixed ? 'fixed' : 'absolute')), display: 'none',
8177                         left: offset.left + 'px', top: offset.top + 'px'});
8178                 if (!inst.inline) {
8179                         var showAnim = $.datepicker._get(inst, 'showAnim');
8180                         var duration = $.datepicker._get(inst, 'duration');
8181                         var postProcess = function() {
8182                                 $.datepicker._datepickerShowing = true;
8183                                 var borders = $.datepicker._getBorders(inst.dpDiv);
8184                                 inst.dpDiv.find('iframe.ui-datepicker-cover'). // IE6- only
8185                                         css({left: -borders[0], top: -borders[1],
8186                                                 width: inst.dpDiv.outerWidth(), height: inst.dpDiv.outerHeight()});
8187                         };
8188                         inst.dpDiv.zIndex($(input).zIndex()+1);
8189                         if ($.effects && $.effects[showAnim])
8190                                 inst.dpDiv.show(showAnim, $.datepicker._get(inst, 'showOptions'), duration, postProcess);
8191                         else
8192                                 inst.dpDiv[showAnim || 'show']((showAnim ? duration : null), postProcess);
8193                         if (!showAnim || !duration)
8194                                 postProcess();
8195                         if (inst.input.is(':visible') && !inst.input.is(':disabled'))
8196                                 inst.input.focus();
8197                         $.datepicker._curInst = inst;
8198                 }
8199         },
8200
8201         /* Generate the date picker content. */
8202         _updateDatepicker: function(inst) {
8203                 var self = this;
8204                 var borders = $.datepicker._getBorders(inst.dpDiv);
8205                 inst.dpDiv.empty().append(this._generateHTML(inst))
8206                         .find('iframe.ui-datepicker-cover') // IE6- only
8207                                 .css({left: -borders[0], top: -borders[1],
8208                                         width: inst.dpDiv.outerWidth(), height: inst.dpDiv.outerHeight()})
8209                         .end()
8210                         .find('button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a')
8211                                 .bind('mouseout', function(){
8212                                         $(this).removeClass('ui-state-hover');
8213                                         if(this.className.indexOf('ui-datepicker-prev') != -1) $(this).removeClass('ui-datepicker-prev-hover');
8214                                         if(this.className.indexOf('ui-datepicker-next') != -1) $(this).removeClass('ui-datepicker-next-hover');
8215                                 })
8216                                 .bind('mouseover', function(){
8217                                         if (!self._isDisabledDatepicker( inst.inline ? inst.dpDiv.parent()[0] : inst.input[0])) {
8218                                                 $(this).parents('.ui-datepicker-calendar').find('a').removeClass('ui-state-hover');
8219                                                 $(this).addClass('ui-state-hover');
8220                                                 if(this.className.indexOf('ui-datepicker-prev') != -1) $(this).addClass('ui-datepicker-prev-hover');
8221                                                 if(this.className.indexOf('ui-datepicker-next') != -1) $(this).addClass('ui-datepicker-next-hover');
8222                                         }
8223                                 })
8224                         .end()
8225                         .find('.' + this._dayOverClass + ' a')
8226                                 .trigger('mouseover')
8227                         .end();
8228                 var numMonths = this._getNumberOfMonths(inst);
8229                 var cols = numMonths[1];
8230                 var width = 17;
8231                 if (cols > 1)
8232                         inst.dpDiv.addClass('ui-datepicker-multi-' + cols).css('width', (width * cols) + 'em');
8233                 else
8234                         inst.dpDiv.removeClass('ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4').width('');
8235                 inst.dpDiv[(numMonths[0] != 1 || numMonths[1] != 1 ? 'add' : 'remove') +
8236                         'Class']('ui-datepicker-multi');
8237                 inst.dpDiv[(this._get(inst, 'isRTL') ? 'add' : 'remove') +
8238                         'Class']('ui-datepicker-rtl');
8239                 if (inst == $.datepicker._curInst && $.datepicker._datepickerShowing && inst.input &&
8240                                 inst.input.is(':visible') && !inst.input.is(':disabled'))
8241                         inst.input.focus();
8242         },
8243
8244         /* Retrieve the size of left and top borders for an element.
8245            @param  elem  (jQuery object) the element of interest
8246            @return  (number[2]) the left and top borders */
8247         _getBorders: function(elem) {
8248                 var convert = function(value) {
8249                         return {thin: 1, medium: 2, thick: 3}[value] || value;
8250                 };
8251                 return [parseFloat(convert(elem.css('border-left-width'))),
8252                         parseFloat(convert(elem.css('border-top-width')))];
8253         },
8254
8255         /* Check positioning to remain on screen. */
8256         _checkOffset: function(inst, offset, isFixed) {
8257                 var dpWidth = inst.dpDiv.outerWidth();
8258                 var dpHeight = inst.dpDiv.outerHeight();
8259                 var inputWidth = inst.input ? inst.input.outerWidth() : 0;
8260                 var inputHeight = inst.input ? inst.input.outerHeight() : 0;
8261                 var viewWidth = document.documentElement.clientWidth + $(document).scrollLeft();
8262                 var viewHeight = document.documentElement.clientHeight + $(document).scrollTop();
8263
8264                 offset.left -= (this._get(inst, 'isRTL') ? (dpWidth - inputWidth) : 0);
8265                 offset.left -= (isFixed && offset.left == inst.input.offset().left) ? $(document).scrollLeft() : 0;
8266                 offset.top -= (isFixed && offset.top == (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
8267
8268                 // now check if datepicker is showing outside window viewport - move to a better place if so.
8269                 offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
8270                         Math.abs(offset.left + dpWidth - viewWidth) : 0);
8271                 offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
8272                         Math.abs(dpHeight + inputHeight) : 0);
8273
8274                 return offset;
8275         },
8276
8277         /* Find an object's position on the screen. */
8278         _findPos: function(obj) {
8279                 var inst = this._getInst(obj);
8280                 var isRTL = this._get(inst, 'isRTL');
8281         while (obj && (obj.type == 'hidden' || obj.nodeType != 1)) {
8282             obj = obj[isRTL ? 'previousSibling' : 'nextSibling'];
8283         }
8284         var position = $(obj).offset();
8285             return [position.left, position.top];
8286         },
8287
8288         /* Hide the date picker from view.
8289            @param  input  element - the input field attached to the date picker */
8290         _hideDatepicker: function(input) {
8291                 var inst = this._curInst;
8292                 if (!inst || (input && inst != $.data(input, PROP_NAME)))
8293                         return;
8294                 if (this._datepickerShowing) {
8295                         var showAnim = this._get(inst, 'showAnim');
8296                         var duration = this._get(inst, 'duration');
8297                         var postProcess = function() {
8298                                 $.datepicker._tidyDialog(inst);
8299                                 this._curInst = null;
8300                         };
8301                         if ($.effects && $.effects[showAnim])
8302                                 inst.dpDiv.hide(showAnim, $.datepicker._get(inst, 'showOptions'), duration, postProcess);
8303                         else
8304                                 inst.dpDiv[(showAnim == 'slideDown' ? 'slideUp' :
8305                                         (showAnim == 'fadeIn' ? 'fadeOut' : 'hide'))]((showAnim ? duration : null), postProcess);
8306                         if (!showAnim)
8307                                 postProcess();
8308                         var onClose = this._get(inst, 'onClose');
8309                         if (onClose)
8310                                 onClose.apply((inst.input ? inst.input[0] : null),
8311                                         [(inst.input ? inst.input.val() : ''), inst]);  // trigger custom callback
8312                         this._datepickerShowing = false;
8313                         this._lastInput = null;
8314                         if (this._inDialog) {
8315                                 this._dialogInput.css({ position: 'absolute', left: '0', top: '-100px' });
8316                                 if ($.blockUI) {
8317                                         $.unblockUI();
8318                                         $('body').append(this.dpDiv);
8319                                 }
8320                         }
8321                         this._inDialog = false;
8322                 }
8323         },
8324
8325         /* Tidy up after a dialog display. */
8326         _tidyDialog: function(inst) {
8327                 inst.dpDiv.removeClass(this._dialogClass).unbind('.ui-datepicker-calendar');
8328         },
8329
8330         /* Close date picker if clicked elsewhere. */
8331         _checkExternalClick: function(event) {
8332                 if (!$.datepicker._curInst)
8333                         return;
8334                 var $target = $(event.target);
8335                 if ($target[0].id != $.datepicker._mainDivId &&
8336                                 $target.parents('#' + $.datepicker._mainDivId).length == 0 &&
8337                                 !$target.hasClass($.datepicker.markerClassName) &&
8338                                 !$target.hasClass($.datepicker._triggerClass) &&
8339                                 $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI))
8340                         $.datepicker._hideDatepicker();
8341         },
8342
8343         /* Adjust one of the date sub-fields. */
8344         _adjustDate: function(id, offset, period) {
8345                 var target = $(id);
8346                 var inst = this._getInst(target[0]);
8347                 if (this._isDisabledDatepicker(target[0])) {
8348                         return;
8349                 }
8350                 this._adjustInstDate(inst, offset +
8351                         (period == 'M' ? this._get(inst, 'showCurrentAtPos') : 0), // undo positioning
8352                         period);
8353                 this._updateDatepicker(inst);
8354         },
8355
8356         /* Action for current link. */
8357         _gotoToday: function(id) {
8358                 var target = $(id);
8359                 var inst = this._getInst(target[0]);
8360                 if (this._get(inst, 'gotoCurrent') && inst.currentDay) {
8361                         inst.selectedDay = inst.currentDay;
8362                         inst.drawMonth = inst.selectedMonth = inst.currentMonth;
8363                         inst.drawYear = inst.selectedYear = inst.currentYear;
8364                 }
8365                 else {
8366                         var date = new Date();
8367                         inst.selectedDay = date.getDate();
8368                         inst.drawMonth = inst.selectedMonth = date.getMonth();
8369                         inst.drawYear = inst.selectedYear = date.getFullYear();
8370                 }
8371                 this._notifyChange(inst);
8372                 this._adjustDate(target);
8373         },
8374
8375         /* Action for selecting a new month/year. */
8376         _selectMonthYear: function(id, select, period) {
8377                 var target = $(id);
8378                 var inst = this._getInst(target[0]);
8379                 inst._selectingMonthYear = false;
8380                 inst['selected' + (period == 'M' ? 'Month' : 'Year')] =
8381                 inst['draw' + (period == 'M' ? 'Month' : 'Year')] =
8382                         parseInt(select.options[select.selectedIndex].value,10);
8383                 this._notifyChange(inst);
8384                 this._adjustDate(target);
8385         },
8386
8387         /* Restore input focus after not changing month/year. */
8388         _clickMonthYear: function(id) {
8389                 var target = $(id);
8390                 var inst = this._getInst(target[0]);
8391                 if (inst.input && inst._selectingMonthYear && !$.browser.msie)
8392                         inst.input.focus();
8393                 inst._selectingMonthYear = !inst._selectingMonthYear;
8394         },
8395
8396         /* Action for selecting a day. */
8397         _selectDay: function(id, month, year, td) {
8398                 var target = $(id);
8399                 if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
8400                         return;
8401                 }
8402                 var inst = this._getInst(target[0]);
8403                 inst.selectedDay = inst.currentDay = $('a', td).html();
8404                 inst.selectedMonth = inst.currentMonth = month;
8405                 inst.selectedYear = inst.currentYear = year;
8406                 this._selectDate(id, this._formatDate(inst,
8407                         inst.currentDay, inst.currentMonth, inst.currentYear));
8408         },
8409
8410         /* Erase the input field and hide the date picker. */
8411         _clearDate: function(id) {
8412                 var target = $(id);
8413                 var inst = this._getInst(target[0]);
8414                 this._selectDate(target, '');
8415         },
8416
8417         /* Update the input field with the selected date. */
8418         _selectDate: function(id, dateStr) {
8419                 var target = $(id);
8420                 var inst = this._getInst(target[0]);
8421                 dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
8422                 if (inst.input)
8423                         inst.input.val(dateStr);
8424                 this._updateAlternate(inst);
8425                 var onSelect = this._get(inst, 'onSelect');
8426                 if (onSelect)
8427                         onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);  // trigger custom callback
8428                 else if (inst.input)
8429                         inst.input.trigger('change'); // fire the change event
8430                 if (inst.inline)
8431                         this._updateDatepicker(inst);
8432                 else {
8433                         this._hideDatepicker();
8434                         this._lastInput = inst.input[0];
8435                         if (typeof(inst.input[0]) != 'object')
8436                                 inst.input.focus(); // restore focus
8437                         this._lastInput = null;
8438                 }
8439         },
8440
8441         /* Update any alternate field to synchronise with the main field. */
8442         _updateAlternate: function(inst) {
8443                 var altField = this._get(inst, 'altField');
8444                 if (altField) { // update alternate field too
8445                         var altFormat = this._get(inst, 'altFormat') || this._get(inst, 'dateFormat');
8446                         var date = this._getDate(inst);
8447                         var dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
8448                         $(altField).each(function() { $(this).val(dateStr); });
8449                 }
8450         },
8451
8452         /* Set as beforeShowDay function to prevent selection of weekends.
8453            @param  date  Date - the date to customise
8454            @return [boolean, string] - is this date selectable?, what is its CSS class? */
8455         noWeekends: function(date) {
8456                 var day = date.getDay();
8457                 return [(day > 0 && day < 6), ''];
8458         },
8459
8460         /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
8461            @param  date  Date - the date to get the week for
8462            @return  number - the number of the week within the year that contains this date */
8463         iso8601Week: function(date) {
8464                 var checkDate = new Date(date.getTime());
8465                 // Find Thursday of this week starting on Monday
8466                 checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
8467                 var time = checkDate.getTime();
8468                 checkDate.setMonth(0); // Compare with Jan 1
8469                 checkDate.setDate(1);
8470                 return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
8471         },
8472
8473         /* Parse a string value into a date object.
8474            See formatDate below for the possible formats.
8475
8476            @param  format    string - the expected format of the date
8477            @param  value     string - the date in the above format
8478            @param  settings  Object - attributes include:
8479                              shortYearCutoff  number - the cutoff year for determining the century (optional)
8480                              dayNamesShort    string[7] - abbreviated names of the days from Sunday (optional)
8481                              dayNames         string[7] - names of the days from Sunday (optional)
8482                              monthNamesShort  string[12] - abbreviated names of the months (optional)
8483                              monthNames       string[12] - names of the months (optional)
8484            @return  Date - the extracted date value or null if value is blank */
8485         parseDate: function (format, value, settings) {
8486                 if (format == null || value == null)
8487                         throw 'Invalid arguments';
8488                 value = (typeof value == 'object' ? value.toString() : value + '');
8489                 if (value == '')
8490                         return null;
8491                 var shortYearCutoff = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff;
8492                 var dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort;
8493                 var dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames;
8494                 var monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort;
8495                 var monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames;
8496                 var year = -1;
8497                 var month = -1;
8498                 var day = -1;
8499                 var doy = -1;
8500                 var literal = false;
8501                 // Check whether a format character is doubled
8502                 var lookAhead = function(match) {
8503                         var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) == match);
8504                         if (matches)
8505                                 iFormat++;
8506                         return matches;
8507                 };
8508                 // Extract a number from the string value
8509                 var getNumber = function(match) {
8510                         lookAhead(match);
8511                         var size = (match == '@' ? 14 : (match == '!' ? 20 :
8512                                 (match == 'y' ? 4 : (match == 'o' ? 3 : 2))));
8513                         var digits = new RegExp('^\\d{1,' + size + '}');
8514                         var num = value.substring(iValue).match(digits);
8515                         if (!num)
8516                                 throw 'Missing number at position ' + iValue;
8517                         iValue += num[0].length;
8518                         return parseInt(num[0], 10);
8519                 };
8520                 // Extract a name from the string value and convert to an index
8521                 var getName = function(match, shortNames, longNames) {
8522                         var names = (lookAhead(match) ? longNames : shortNames);
8523                         for (var i = 0; i < names.length; i++) {
8524                                 if (value.substr(iValue, names[i].length) == names[i]) {
8525                                         iValue += names[i].length;
8526                                         return i + 1;
8527                                 }
8528                         }
8529                         throw 'Unknown name at position ' + iValue;
8530                 };
8531                 // Confirm that a literal character matches the string value
8532                 var checkLiteral = function() {
8533                         if (value.charAt(iValue) != format.charAt(iFormat))
8534                                 throw 'Unexpected literal at position ' + iValue;
8535                         iValue++;
8536                 };
8537                 var iValue = 0;
8538                 for (var iFormat = 0; iFormat < format.length; iFormat++) {
8539                         if (literal)
8540                                 if (format.charAt(iFormat) == "'" && !lookAhead("'"))
8541                                         literal = false;
8542                                 else
8543                                         checkLiteral();
8544                         else
8545                                 switch (format.charAt(iFormat)) {
8546                                         case 'd':
8547                                                 day = getNumber('d');
8548                                                 break;
8549                                         case 'D':
8550                                                 getName('D', dayNamesShort, dayNames);
8551                                                 break;
8552                                         case 'o':
8553                                                 doy = getNumber('o');
8554                                                 break;
8555                                         case 'm':
8556                                                 month = getNumber('m');
8557                                                 break;
8558                                         case 'M':
8559                                                 month = getName('M', monthNamesShort, monthNames);
8560                                                 break;
8561                                         case 'y':
8562                                                 year = getNumber('y');
8563                                                 break;
8564                                         case '@':
8565                                                 var date = new Date(getNumber('@'));
8566                                                 year = date.getFullYear();
8567                                                 month = date.getMonth() + 1;
8568                                                 day = date.getDate();
8569                                                 break;
8570                                         case '!':
8571                                                 var date = new Date((getNumber('!') - this._ticksTo1970) / 10000);
8572                                                 year = date.getFullYear();
8573                                                 month = date.getMonth() + 1;
8574                                                 day = date.getDate();
8575                                                 break;
8576                                         case "'":
8577                                                 if (lookAhead("'"))
8578                                                         checkLiteral();
8579                                                 else
8580                                                         literal = true;
8581                                                 break;
8582                                         default:
8583                                                 checkLiteral();
8584                                 }
8585                 }
8586                 if (year == -1)
8587                         year = new Date().getFullYear();
8588                 else if (year < 100)
8589                         year += new Date().getFullYear() - new Date().getFullYear() % 100 +
8590                                 (year <= shortYearCutoff ? 0 : -100);
8591                 if (doy > -1) {
8592                         month = 1;
8593                         day = doy;
8594                         do {
8595                                 var dim = this._getDaysInMonth(year, month - 1);
8596                                 if (day <= dim)
8597                                         break;
8598                                 month++;
8599                                 day -= dim;
8600                         } while (true);
8601                 }
8602                 var date = this._daylightSavingAdjust(new Date(year, month - 1, day));
8603                 if (date.getFullYear() != year || date.getMonth() + 1 != month || date.getDate() != day)
8604                         throw 'Invalid date'; // E.g. 31/02/*
8605                 return date;
8606         },
8607
8608         /* Standard date formats. */
8609         ATOM: 'yy-mm-dd', // RFC 3339 (ISO 8601)
8610         COOKIE: 'D, dd M yy',
8611         ISO_8601: 'yy-mm-dd',
8612         RFC_822: 'D, d M y',
8613         RFC_850: 'DD, dd-M-y',
8614         RFC_1036: 'D, d M y',
8615         RFC_1123: 'D, d M yy',
8616         RFC_2822: 'D, d M yy',
8617         RSS: 'D, d M y', // RFC 822
8618         TICKS: '!',
8619         TIMESTAMP: '@',
8620         W3C: 'yy-mm-dd', // ISO 8601
8621
8622         _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
8623                 Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
8624
8625         /* Format a date object into a string value.
8626            The format can be combinations of the following:
8627            d  - day of month (no leading zero)
8628            dd - day of month (two digit)
8629            o  - day of year (no leading zeros)
8630            oo - day of year (three digit)
8631            D  - day name short
8632            DD - day name long
8633            m  - month of year (no leading zero)
8634            mm - month of year (two digit)
8635            M  - month name short
8636            MM - month name long
8637            y  - year (two digit)
8638            yy - year (four digit)
8639            @ - Unix timestamp (ms since 01/01/1970)
8640            ! - Windows ticks (100ns since 01/01/0001)
8641            '...' - literal text
8642            '' - single quote
8643
8644            @param  format    string - the desired format of the date
8645            @param  date      Date - the date value to format
8646            @param  settings  Object - attributes include:
8647                              dayNamesShort    string[7] - abbreviated names of the days from Sunday (optional)
8648                              dayNames         string[7] - names of the days from Sunday (optional)
8649                              monthNamesShort  string[12] - abbreviated names of the months (optional)
8650                              monthNames       string[12] - names of the months (optional)
8651            @return  string - the date in the above format */
8652         formatDate: function (format, date, settings) {
8653                 if (!date)
8654                         return '';
8655                 var dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort;
8656                 var dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames;
8657                 var monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort;
8658                 var monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames;
8659                 // Check whether a format character is doubled
8660                 var lookAhead = function(match) {
8661                         var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) == match);
8662                         if (matches)
8663                                 iFormat++;
8664                         return matches;
8665                 };
8666                 // Format a number, with leading zero if necessary
8667                 var formatNumber = function(match, value, len) {
8668                         var num = '' + value;
8669                         if (lookAhead(match))
8670                                 while (num.length < len)
8671                                         num = '0' + num;
8672                         return num;
8673                 };
8674                 // Format a name, short or long as requested
8675                 var formatName = function(match, value, shortNames, longNames) {
8676                         return (lookAhead(match) ? longNames[value] : shortNames[value]);
8677                 };
8678                 var output = '';
8679                 var literal = false;
8680                 if (date)
8681                         for (var iFormat = 0; iFormat < format.length; iFormat++) {
8682                                 if (literal)
8683                                         if (format.charAt(iFormat) == "'" && !lookAhead("'"))
8684                                                 literal = false;
8685                                         else
8686                                                 output += format.charAt(iFormat);
8687                                 else
8688                                         switch (format.charAt(iFormat)) {
8689                                                 case 'd':
8690                                                         output += formatNumber('d', date.getDate(), 2);
8691                                                         break;
8692                                                 case 'D':
8693                                                         output += formatName('D', date.getDay(), dayNamesShort, dayNames);
8694                                                         break;
8695                                                 case 'o':
8696                                                         output += formatNumber('o',
8697                                                                 (date.getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000, 3);
8698                                                         break;
8699                                                 case 'm':
8700                                                         output += formatNumber('m', date.getMonth() + 1, 2);
8701                                                         break;
8702                                                 case 'M':
8703                                                         output += formatName('M', date.getMonth(), monthNamesShort, monthNames);
8704                                                         break;
8705                                                 case 'y':
8706                                                         output += (lookAhead('y') ? date.getFullYear() :
8707                                                                 (date.getYear() % 100 < 10 ? '0' : '') + date.getYear() % 100);
8708                                                         break;
8709                                                 case '@':
8710                                                         output += date.getTime();
8711                                                         break;
8712                                                 case '!':
8713                                                         output += date.getTime() * 10000 + this._ticksTo1970;
8714                                                         break;
8715                                                 case "'":
8716                                                         if (lookAhead("'"))
8717                                                                 output += "'";
8718                                                         else
8719                                                                 literal = true;
8720                                                         break;
8721                                                 default:
8722                                                         output += format.charAt(iFormat);
8723                                         }
8724                         }
8725                 return output;
8726         },
8727
8728         /* Extract all possible characters from the date format. */
8729         _possibleChars: function (format) {
8730                 var chars = '';
8731                 var literal = false;
8732                 // Check whether a format character is doubled
8733                 var lookAhead = function(match) {
8734                         var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) == match);
8735                         if (matches)
8736                                 iFormat++;
8737                         return matches;
8738                 };
8739                 for (var iFormat = 0; iFormat < format.length; iFormat++)
8740                         if (literal)
8741                                 if (format.charAt(iFormat) == "'" && !lookAhead("'"))
8742                                         literal = false;
8743                                 else
8744                                         chars += format.charAt(iFormat);
8745                         else
8746                                 switch (format.charAt(iFormat)) {
8747                                         case 'd': case 'm': case 'y': case '@':
8748                                                 chars += '0123456789';
8749                                                 break;
8750                                         case 'D': case 'M':
8751                                                 return null; // Accept anything
8752                                         case "'":
8753                                                 if (lookAhead("'"))
8754                                                         chars += "'";
8755                                                 else
8756                                                         literal = true;
8757                                                 break;
8758                                         default:
8759                                                 chars += format.charAt(iFormat);
8760                                 }
8761                 return chars;
8762         },
8763
8764         /* Get a setting value, defaulting if necessary. */
8765         _get: function(inst, name) {
8766                 return inst.settings[name] !== undefined ?
8767                         inst.settings[name] : this._defaults[name];
8768         },
8769
8770         /* Parse existing date and initialise date picker. */
8771         _setDateFromField: function(inst, noDefault) {
8772                 if (inst.input.val() == inst.lastVal) {
8773                         return;
8774                 }
8775                 var dateFormat = this._get(inst, 'dateFormat');
8776                 var dates = inst.lastVal = inst.input ? inst.input.val() : null;
8777                 var date, defaultDate;
8778                 date = defaultDate = this._getDefaultDate(inst);
8779                 var settings = this._getFormatConfig(inst);
8780                 try {
8781                         date = this.parseDate(dateFormat, dates, settings) || defaultDate;
8782                 } catch (event) {
8783                         this.log(event);
8784                         dates = (noDefault ? '' : dates);
8785                 }
8786                 inst.selectedDay = date.getDate();
8787                 inst.drawMonth = inst.selectedMonth = date.getMonth();
8788                 inst.drawYear = inst.selectedYear = date.getFullYear();
8789                 inst.currentDay = (dates ? date.getDate() : 0);
8790                 inst.currentMonth = (dates ? date.getMonth() : 0);
8791                 inst.currentYear = (dates ? date.getFullYear() : 0);
8792                 this._adjustInstDate(inst);
8793         },
8794
8795         /* Retrieve the default date shown on opening. */
8796         _getDefaultDate: function(inst) {
8797                 return this._restrictMinMax(inst,
8798                         this._determineDate(inst, this._get(inst, 'defaultDate'), new Date()));
8799         },
8800
8801         /* A date may be specified as an exact value or a relative one. */
8802         _determineDate: function(inst, date, defaultDate) {
8803                 var offsetNumeric = function(offset) {
8804                         var date = new Date();
8805                         date.setDate(date.getDate() + offset);
8806                         return date;
8807                 };
8808                 var offsetString = function(offset) {
8809                         try {
8810                                 return $.datepicker.parseDate($.datepicker._get(inst, 'dateFormat'),
8811                                         offset, $.datepicker._getFormatConfig(inst));
8812                         }
8813                         catch (e) {
8814                                 // Ignore
8815                         }
8816                         var date = (offset.toLowerCase().match(/^c/) ?
8817                                 $.datepicker._getDate(inst) : null) || new Date();
8818                         var year = date.getFullYear();
8819                         var month = date.getMonth();
8820                         var day = date.getDate();
8821                         var pattern = /([+-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g;
8822                         var matches = pattern.exec(offset);
8823                         while (matches) {
8824                                 switch (matches[2] || 'd') {
8825                                         case 'd' : case 'D' :
8826                                                 day += parseInt(matches[1],10); break;
8827                                         case 'w' : case 'W' :
8828                                                 day += parseInt(matches[1],10) * 7; break;
8829                                         case 'm' : case 'M' :
8830                                                 month += parseInt(matches[1],10);
8831                                                 day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
8832                                                 break;
8833                                         case 'y': case 'Y' :
8834                                                 year += parseInt(matches[1],10);
8835                                                 day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
8836                                                 break;
8837                                 }
8838                                 matches = pattern.exec(offset);
8839                         }
8840                         return new Date(year, month, day);
8841                 };
8842                 date = (date == null ? defaultDate : (typeof date == 'string' ? offsetString(date) :
8843                         (typeof date == 'number' ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : date)));
8844                 date = (date && date.toString() == 'Invalid Date' ? defaultDate : date);
8845                 if (date) {
8846                         date.setHours(0);
8847                         date.setMinutes(0);
8848                         date.setSeconds(0);
8849                         date.setMilliseconds(0);
8850                 }
8851                 return this._daylightSavingAdjust(date);
8852         },
8853
8854         /* Handle switch to/from daylight saving.
8855            Hours may be non-zero on daylight saving cut-over:
8856            > 12 when midnight changeover, but then cannot generate
8857            midnight datetime, so jump to 1AM, otherwise reset.
8858            @param  date  (Date) the date to check
8859            @return  (Date) the corrected date */
8860         _daylightSavingAdjust: function(date) {
8861                 if (!date) return null;
8862                 date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
8863                 return date;
8864         },
8865
8866         /* Set the date(s) directly. */
8867         _setDate: function(inst, date, noChange) {
8868                 var clear = !(date);
8869                 var origMonth = inst.selectedMonth;
8870                 var origYear = inst.selectedYear;
8871                 date = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
8872                 inst.selectedDay = inst.currentDay = date.getDate();
8873                 inst.drawMonth = inst.selectedMonth = inst.currentMonth = date.getMonth();
8874                 inst.drawYear = inst.selectedYear = inst.currentYear = date.getFullYear();
8875                 if ((origMonth != inst.selectedMonth || origYear != inst.selectedYear) && !noChange)
8876                         this._notifyChange(inst);
8877                 this._adjustInstDate(inst);
8878                 if (inst.input) {
8879                         inst.input.val(clear ? '' : this._formatDate(inst));
8880                 }
8881         },
8882
8883         /* Retrieve the date(s) directly. */
8884         _getDate: function(inst) {
8885                 var startDate = (!inst.currentYear || (inst.input && inst.input.val() == '') ? null :
8886                         this._daylightSavingAdjust(new Date(
8887                         inst.currentYear, inst.currentMonth, inst.currentDay)));
8888                         return startDate;
8889         },
8890
8891         /* Generate the HTML for the current state of the date picker. */
8892         _generateHTML: function(inst) {
8893                 var today = new Date();
8894                 today = this._daylightSavingAdjust(
8895                         new Date(today.getFullYear(), today.getMonth(), today.getDate())); // clear time
8896                 var isRTL = this._get(inst, 'isRTL');
8897                 var showButtonPanel = this._get(inst, 'showButtonPanel');
8898                 var hideIfNoPrevNext = this._get(inst, 'hideIfNoPrevNext');
8899                 var navigationAsDateFormat = this._get(inst, 'navigationAsDateFormat');
8900                 var numMonths = this._getNumberOfMonths(inst);
8901                 var showCurrentAtPos = this._get(inst, 'showCurrentAtPos');
8902                 var stepMonths = this._get(inst, 'stepMonths');
8903                 var isMultiMonth = (numMonths[0] != 1 || numMonths[1] != 1);
8904                 var currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
8905                         new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
8906                 var minDate = this._getMinMaxDate(inst, 'min');
8907                 var maxDate = this._getMinMaxDate(inst, 'max');
8908                 var drawMonth = inst.drawMonth - showCurrentAtPos;
8909                 var drawYear = inst.drawYear;
8910                 if (drawMonth < 0) {
8911                         drawMonth += 12;
8912                         drawYear--;
8913                 }
8914                 if (maxDate) {
8915                         var maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
8916                                 maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
8917                         maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
8918                         while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
8919                                 drawMonth--;
8920                                 if (drawMonth < 0) {
8921                                         drawMonth = 11;
8922                                         drawYear--;
8923                                 }
8924                         }
8925                 }
8926                 inst.drawMonth = drawMonth;
8927                 inst.drawYear = drawYear;
8928                 var prevText = this._get(inst, 'prevText');
8929                 prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
8930                         this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
8931                         this._getFormatConfig(inst)));
8932                 var prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
8933                         '<a class="ui-datepicker-prev ui-corner-all" onclick="DP_jQuery_' + dpuuid +
8934                         '.datepicker._adjustDate(\'#' + inst.id + '\', -' + stepMonths + ', \'M\');"' +
8935                         ' title="' + prevText + '"><span class="ui-icon ui-icon-circle-triangle-' + ( isRTL ? 'e' : 'w') + '">' + prevText + '</span></a>' :
8936                         (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>'));
8937                 var nextText = this._get(inst, 'nextText');
8938                 nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
8939                         this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
8940                         this._getFormatConfig(inst)));
8941                 var next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
8942                         '<a class="ui-datepicker-next ui-corner-all" onclick="DP_jQuery_' + dpuuid +
8943                         '.datepicker._adjustDate(\'#' + inst.id + '\', +' + stepMonths + ', \'M\');"' +
8944                         ' title="' + nextText + '"><span class="ui-icon ui-icon-circle-triangle-' + ( isRTL ? 'w' : 'e') + '">' + nextText + '</span></a>' :
8945                         (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>'));
8946                 var currentText = this._get(inst, 'currentText');
8947                 var gotoDate = (this._get(inst, 'gotoCurrent') && inst.currentDay ? currentDate : today);
8948                 currentText = (!navigationAsDateFormat ? currentText :
8949                         this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
8950                 var controls = (!inst.inline ? '<button type="button" class="ui-datepicker-close ui-state-default ui-priority-primary ui-corner-all" onclick="DP_jQuery_' + dpuuid +
8951                         '.datepicker._hideDatepicker();">' + this._get(inst, 'closeText') + '</button>' : '');
8952                 var buttonPanel = (showButtonPanel) ? '<div class="ui-datepicker-buttonpane ui-widget-content">' + (isRTL ? controls : '') +
8953                         (this._isInRange(inst, gotoDate) ? '<button type="button" class="ui-datepicker-current ui-state-default ui-priority-secondary ui-corner-all" onclick="DP_jQuery_' + dpuuid +
8954                         '.datepicker._gotoToday(\'#' + inst.id + '\');"' +
8955                         '>' + currentText + '</button>' : '') + (isRTL ? '' : controls) + '</div>' : '';
8956                 var firstDay = parseInt(this._get(inst, 'firstDay'),10);
8957                 firstDay = (isNaN(firstDay) ? 0 : firstDay);
8958                 var showWeek = this._get(inst, 'showWeek');
8959                 var dayNames = this._get(inst, 'dayNames');
8960                 var dayNamesShort = this._get(inst, 'dayNamesShort');
8961                 var dayNamesMin = this._get(inst, 'dayNamesMin');
8962                 var monthNames = this._get(inst, 'monthNames');
8963                 var monthNamesShort = this._get(inst, 'monthNamesShort');
8964                 var beforeShowDay = this._get(inst, 'beforeShowDay');
8965                 var showOtherMonths = this._get(inst, 'showOtherMonths');
8966                 var selectOtherMonths = this._get(inst, 'selectOtherMonths');
8967                 var calculateWeek = this._get(inst, 'calculateWeek') || this.iso8601Week;
8968                 var defaultDate = this._getDefaultDate(inst);
8969                 var html = '';
8970                 for (var row = 0; row < numMonths[0]; row++) {
8971                         var group = '';
8972                         for (var col = 0; col < numMonths[1]; col++) {
8973                                 var selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
8974                                 var cornerClass = ' ui-corner-all';
8975                                 var calender = '';
8976                                 if (isMultiMonth) {
8977                                         calender += '<div class="ui-datepicker-group';
8978                                         if (numMonths[1] > 1)
8979                                                 switch (col) {
8980                                                         case 0: calender += ' ui-datepicker-group-first';
8981                                                                 cornerClass = ' ui-corner-' + (isRTL ? 'right' : 'left'); break;
8982                                                         case numMonths[1]-1: calender += ' ui-datepicker-group-last';
8983                                                                 cornerClass = ' ui-corner-' + (isRTL ? 'left' : 'right'); break;
8984                                                         default: calender += ' ui-datepicker-group-middle'; cornerClass = ''; break;
8985                                                 }
8986                                         calender += '">';
8987                                 }
8988                                 calender += '<div class="ui-datepicker-header ui-widget-header ui-helper-clearfix' + cornerClass + '">' +
8989                                         (/all|left/.test(cornerClass) && row == 0 ? (isRTL ? next : prev) : '') +
8990                                         (/all|right/.test(cornerClass) && row == 0 ? (isRTL ? prev : next) : '') +
8991                                         this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
8992                                         row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
8993                                         '</div><table class="ui-datepicker-calendar"><thead>' +
8994                                         '<tr>';
8995                                 var thead = (showWeek ? '<th class="ui-datepicker-week-col">' + this._get(inst, 'weekHeader') + '</th>' : '');
8996                                 for (var dow = 0; dow < 7; dow++) { // days of the week
8997                                         var day = (dow + firstDay) % 7;
8998                                         thead += '<th' + ((dow + firstDay + 6) % 7 >= 5 ? ' class="ui-datepicker-week-end"' : '') + '>' +
8999                                                 '<span title="' + dayNames[day] + '">' + dayNamesMin[day] + '</span></th>';
9000                                 }
9001                                 calender += thead + '</tr></thead><tbody>';
9002                                 var daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
9003                                 if (drawYear == inst.selectedYear && drawMonth == inst.selectedMonth)
9004                                         inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
9005                                 var leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
9006                                 var numRows = (isMultiMonth ? 6 : Math.ceil((leadDays + daysInMonth) / 7)); // calculate the number of rows to generate
9007                                 var printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
9008                                 for (var dRow = 0; dRow < numRows; dRow++) { // create date picker rows
9009                                         calender += '<tr>';
9010                                         var tbody = (!showWeek ? '' : '<td class="ui-datepicker-week-col">' +
9011                                                 this._get(inst, 'calculateWeek')(printDate) + '</td>');
9012                                         for (var dow = 0; dow < 7; dow++) { // create date picker days
9013                                                 var daySettings = (beforeShowDay ?
9014                                                         beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, '']);
9015                                                 var otherMonth = (printDate.getMonth() != drawMonth);
9016                                                 var unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
9017                                                         (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
9018                                                 tbody += '<td class="' +
9019                                                         ((dow + firstDay + 6) % 7 >= 5 ? ' ui-datepicker-week-end' : '') + // highlight weekends
9020                                                         (otherMonth ? ' ui-datepicker-other-month' : '') + // highlight days from other months
9021                                                         ((printDate.getTime() == selectedDate.getTime() && drawMonth == inst.selectedMonth && inst._keyEvent) || // user pressed key
9022                                                         (defaultDate.getTime() == printDate.getTime() && defaultDate.getTime() == selectedDate.getTime()) ?
9023                                                         // or defaultDate is current printedDate and defaultDate is selectedDate
9024                                                         ' ' + this._dayOverClass : '') + // highlight selected day
9025                                                         (unselectable ? ' ' + this._unselectableClass + ' ui-state-disabled': '') +  // highlight unselectable days
9026                                                         (otherMonth && !showOtherMonths ? '' : ' ' + daySettings[1] + // highlight custom dates
9027                                                         (printDate.getTime() == currentDate.getTime() ? ' ' + this._currentClass : '') + // highlight selected day
9028                                                         (printDate.getTime() == today.getTime() ? ' ui-datepicker-today' : '')) + '"' + // highlight today (if different)
9029                                                         ((!otherMonth || showOtherMonths) && daySettings[2] ? ' title="' + daySettings[2] + '"' : '') + // cell title
9030                                                         (unselectable ? '' : ' onclick="DP_jQuery_' + dpuuid + '.datepicker._selectDay(\'#' +
9031                                                         inst.id + '\',' + printDate.getMonth() + ',' + printDate.getFullYear() + ', this);return false;"') + '>' + // actions
9032                                                         (otherMonth && !showOtherMonths ? '&#xa0;' : // display for other months
9033                                                         (unselectable ? '<span class="ui-state-default">' + printDate.getDate() + '</span>' : '<a class="ui-state-default' +
9034                                                         (printDate.getTime() == today.getTime() ? ' ui-state-highlight' : '') +
9035                                                         (printDate.getTime() == currentDate.getTime() ? ' ui-state-active' : '') + // highlight selected day
9036                                                         (otherMonth ? ' ui-priority-secondary' : '') + // distinguish dates from other months
9037                                                         '" href="#">' + printDate.getDate() + '</a>')) + '</td>'; // display selectable date
9038                                                 printDate.setDate(printDate.getDate() + 1);
9039                                                 printDate = this._daylightSavingAdjust(printDate);
9040                                         }
9041                                         calender += tbody + '</tr>';
9042                                 }
9043                                 drawMonth++;
9044                                 if (drawMonth > 11) {
9045                                         drawMonth = 0;
9046                                         drawYear++;
9047                                 }
9048                                 calender += '</tbody></table>' + (isMultiMonth ? '</div>' +
9049                                                         ((numMonths[0] > 0 && col == numMonths[1]-1) ? '<div class="ui-datepicker-row-break"></div>' : '') : '');
9050                                 group += calender;
9051                         }
9052                         html += group;
9053                 }
9054                 html += buttonPanel + ($.browser.msie && parseInt($.browser.version,10) < 7 && !inst.inline ?
9055                         '<iframe src="javascript:false;" class="ui-datepicker-cover" frameborder="0"></iframe>' : '');
9056                 inst._keyEvent = false;
9057                 return html;
9058         },
9059
9060         /* Generate the month and year header. */
9061         _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
9062                         secondary, monthNames, monthNamesShort) {
9063                 var changeMonth = this._get(inst, 'changeMonth');
9064                 var changeYear = this._get(inst, 'changeYear');
9065                 var showMonthAfterYear = this._get(inst, 'showMonthAfterYear');
9066                 var html = '<div class="ui-datepicker-title">';
9067                 var monthHtml = '';
9068                 // month selection
9069                 if (secondary || !changeMonth)
9070                         monthHtml += '<span class="ui-datepicker-month">' + monthNames[drawMonth] + '</span>';
9071                 else {
9072                         var inMinYear = (minDate && minDate.getFullYear() == drawYear);
9073                         var inMaxYear = (maxDate && maxDate.getFullYear() == drawYear);
9074                         monthHtml += '<select class="ui-datepicker-month" ' +
9075                                 'onchange="DP_jQuery_' + dpuuid + '.datepicker._selectMonthYear(\'#' + inst.id + '\', this, \'M\');" ' +
9076                                 'onclick="DP_jQuery_' + dpuuid + '.datepicker._clickMonthYear(\'#' + inst.id + '\');"' +
9077                                 '>';
9078                         for (var month = 0; month < 12; month++) {
9079                                 if ((!inMinYear || month >= minDate.getMonth()) &&
9080                                                 (!inMaxYear || month <= maxDate.getMonth()))
9081                                         monthHtml += '<option value="' + month + '"' +
9082                                                 (month == drawMonth ? ' selected="selected"' : '') +
9083                                                 '>' + monthNamesShort[month] + '</option>';
9084                         }
9085                         monthHtml += '</select>';
9086                 }
9087                 if (!showMonthAfterYear)
9088                         html += monthHtml + (secondary || !(changeMonth && changeYear) ? '&#xa0;' : '');
9089                 // year selection
9090                 if (secondary || !changeYear)
9091                         html += '<span class="ui-datepicker-year">' + drawYear + '</span>';
9092                 else {
9093                         // determine range of years to display
9094                         var years = this._get(inst, 'yearRange').split(':');
9095                         var thisYear = new Date().getFullYear();
9096                         var determineYear = function(value) {
9097                                 var year = (value.match(/c[+-].*/) ? drawYear + parseInt(value.substring(1), 10) :
9098                                         (value.match(/[+-].*/) ? thisYear + parseInt(value, 10) :
9099                                         parseInt(value, 10)));
9100                                 return (isNaN(year) ? thisYear : year);
9101                         };
9102                         var year = determineYear(years[0]);
9103                         var endYear = Math.max(year, determineYear(years[1] || ''));
9104                         year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
9105                         endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
9106                         html += '<select class="ui-datepicker-year" ' +
9107                                 'onchange="DP_jQuery_' + dpuuid + '.datepicker._selectMonthYear(\'#' + inst.id + '\', this, \'Y\');" ' +
9108                                 'onclick="DP_jQuery_' + dpuuid + '.datepicker._clickMonthYear(\'#' + inst.id + '\');"' +
9109                                 '>';
9110                         for (; year <= endYear; year++) {
9111                                 html += '<option value="' + year + '"' +
9112                                         (year == drawYear ? ' selected="selected"' : '') +
9113                                         '>' + year + '</option>';
9114                         }
9115                         html += '</select>';
9116                 }
9117                 html += this._get(inst, 'yearSuffix');
9118                 if (showMonthAfterYear)
9119                         html += (secondary || !(changeMonth && changeYear) ? '&#xa0;' : '') + monthHtml;
9120                 html += '</div>'; // Close datepicker_header
9121                 return html;
9122         },
9123
9124         /* Adjust one of the date sub-fields. */
9125         _adjustInstDate: function(inst, offset, period) {
9126                 var year = inst.drawYear + (period == 'Y' ? offset : 0);
9127                 var month = inst.drawMonth + (period == 'M' ? offset : 0);
9128                 var day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) +
9129                         (period == 'D' ? offset : 0);
9130                 var date = this._restrictMinMax(inst,
9131                         this._daylightSavingAdjust(new Date(year, month, day)));
9132                 inst.selectedDay = date.getDate();
9133                 inst.drawMonth = inst.selectedMonth = date.getMonth();
9134                 inst.drawYear = inst.selectedYear = date.getFullYear();
9135                 if (period == 'M' || period == 'Y')
9136                         this._notifyChange(inst);
9137         },
9138
9139         /* Ensure a date is within any min/max bounds. */
9140         _restrictMinMax: function(inst, date) {
9141                 var minDate = this._getMinMaxDate(inst, 'min');
9142                 var maxDate = this._getMinMaxDate(inst, 'max');
9143                 date = (minDate && date < minDate ? minDate : date);
9144                 date = (maxDate && date > maxDate ? maxDate : date);
9145                 return date;
9146         },
9147
9148         /* Notify change of month/year. */
9149         _notifyChange: function(inst) {
9150                 var onChange = this._get(inst, 'onChangeMonthYear');
9151                 if (onChange)
9152                         onChange.apply((inst.input ? inst.input[0] : null),
9153                                 [inst.selectedYear, inst.selectedMonth + 1, inst]);
9154         },
9155
9156         /* Determine the number of months to show. */
9157         _getNumberOfMonths: function(inst) {
9158                 var numMonths = this._get(inst, 'numberOfMonths');
9159                 return (numMonths == null ? [1, 1] : (typeof numMonths == 'number' ? [1, numMonths] : numMonths));
9160         },
9161
9162         /* Determine the current maximum date - ensure no time components are set. */
9163         _getMinMaxDate: function(inst, minMax) {
9164                 return this._determineDate(inst, this._get(inst, minMax + 'Date'), null);
9165         },
9166
9167         /* Find the number of days in a given month. */
9168         _getDaysInMonth: function(year, month) {
9169                 return 32 - new Date(year, month, 32).getDate();
9170         },
9171
9172         /* Find the day of the week of the first of a month. */
9173         _getFirstDayOfMonth: function(year, month) {
9174                 return new Date(year, month, 1).getDay();
9175         },
9176
9177         /* Determines if we should allow a "next/prev" month display change. */
9178         _canAdjustMonth: function(inst, offset, curYear, curMonth) {
9179                 var numMonths = this._getNumberOfMonths(inst);
9180                 var date = this._daylightSavingAdjust(new Date(curYear,
9181                         curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
9182                 if (offset < 0)
9183                         date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
9184                 return this._isInRange(inst, date);
9185         },
9186
9187         /* Is the given date in the accepted range? */
9188         _isInRange: function(inst, date) {
9189                 var minDate = this._getMinMaxDate(inst, 'min');
9190                 var maxDate = this._getMinMaxDate(inst, 'max');
9191                 return ((!minDate || date.getTime() >= minDate.getTime()) &&
9192                         (!maxDate || date.getTime() <= maxDate.getTime()));
9193         },
9194
9195         /* Provide the configuration settings for formatting/parsing. */
9196         _getFormatConfig: function(inst) {
9197                 var shortYearCutoff = this._get(inst, 'shortYearCutoff');
9198                 shortYearCutoff = (typeof shortYearCutoff != 'string' ? shortYearCutoff :
9199                         new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
9200                 return {shortYearCutoff: shortYearCutoff,
9201                         dayNamesShort: this._get(inst, 'dayNamesShort'), dayNames: this._get(inst, 'dayNames'),
9202                         monthNamesShort: this._get(inst, 'monthNamesShort'), monthNames: this._get(inst, 'monthNames')};
9203         },
9204
9205         /* Format the given date for display. */
9206         _formatDate: function(inst, day, month, year) {
9207                 if (!day) {
9208                         inst.currentDay = inst.selectedDay;
9209                         inst.currentMonth = inst.selectedMonth;
9210                         inst.currentYear = inst.selectedYear;
9211                 }
9212                 var date = (day ? (typeof day == 'object' ? day :
9213                         this._daylightSavingAdjust(new Date(year, month, day))) :
9214                         this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
9215                 return this.formatDate(this._get(inst, 'dateFormat'), date, this._getFormatConfig(inst));
9216         }
9217 });
9218
9219 /* jQuery extend now ignores nulls! */
9220 function extendRemove(target, props) {
9221         $.extend(target, props);
9222         for (var name in props)
9223                 if (props[name] == null || props[name] == undefined)
9224                         target[name] = props[name];
9225         return target;
9226 };
9227
9228 /* Determine whether an object is an array. */
9229 function isArray(a) {
9230         return (a && (($.browser.safari && typeof a == 'object' && a.length) ||
9231                 (a.constructor && a.constructor.toString().match(/\Array\(\)/))));
9232 };
9233
9234 /* Invoke the datepicker functionality.
9235    @param  options  string - a command, optionally followed by additional parameters or
9236                     Object - settings for attaching new datepicker functionality
9237    @return  jQuery object */
9238 $.fn.datepicker = function(options){
9239
9240         /* Initialise the date picker. */
9241         if (!$.datepicker.initialized) {
9242                 $(document).mousedown($.datepicker._checkExternalClick).
9243                         find('body').append($.datepicker.dpDiv);
9244                 $.datepicker.initialized = true;
9245         }
9246
9247         var otherArgs = Array.prototype.slice.call(arguments, 1);
9248         if (typeof options == 'string' && (options == 'isDisabled' || options == 'getDate' || options == 'widget'))
9249                 return $.datepicker['_' + options + 'Datepicker'].
9250                         apply($.datepicker, [this[0]].concat(otherArgs));
9251         if (options == 'option' && arguments.length == 2 && typeof arguments[1] == 'string')
9252                 return $.datepicker['_' + options + 'Datepicker'].
9253                         apply($.datepicker, [this[0]].concat(otherArgs));
9254         return this.each(function() {
9255                 typeof options == 'string' ?
9256                         $.datepicker['_' + options + 'Datepicker'].
9257                                 apply($.datepicker, [this].concat(otherArgs)) :
9258                         $.datepicker._attachDatepicker(this, options);
9259         });
9260 };
9261
9262 $.datepicker = new Datepicker(); // singleton instance
9263 $.datepicker.initialized = false;
9264 $.datepicker.uuid = new Date().getTime();
9265 $.datepicker.version = "1.8";
9266
9267 // Workaround for #4055
9268 // Add another global to avoid noConflict issues with inline event handlers
9269 window['DP_jQuery_' + dpuuid] = $;
9270
9271 })(jQuery);
9272 /*
9273  * jQuery UI Progressbar 1.8
9274  *
9275  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
9276  * Dual licensed under the MIT (MIT-LICENSE.txt)
9277  * and GPL (GPL-LICENSE.txt) licenses.
9278  *
9279  * http://docs.jquery.com/UI/Progressbar
9280  *
9281  * Depends:
9282  *   jquery.ui.core.js
9283  *   jquery.ui.widget.js
9284  */
9285 (function( $ ) {
9286
9287 $.widget( "ui.progressbar", {
9288         options: {
9289                 value: 0
9290         },
9291         _create: function() {
9292                 this.element
9293                         .addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
9294                         .attr({
9295                                 role: "progressbar",
9296                                 "aria-valuemin": this._valueMin(),
9297                                 "aria-valuemax": this._valueMax(),
9298                                 "aria-valuenow": this._value()
9299                         });
9300
9301                 this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
9302                         .appendTo( this.element );
9303
9304                 this._refreshValue();
9305         },
9306
9307         destroy: function() {
9308                 this.element
9309                         .removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
9310                         .removeAttr( "role" )
9311                         .removeAttr( "aria-valuemin" )
9312                         .removeAttr( "aria-valuemax" )
9313                         .removeAttr( "aria-valuenow" );
9314
9315                 this.valueDiv.remove();
9316
9317                 $.Widget.prototype.destroy.apply( this, arguments );
9318         },
9319
9320         value: function( newValue ) {
9321                 if ( newValue === undefined ) {
9322                         return this._value();
9323                 }
9324
9325                 this._setOption( "value", newValue );
9326                 return this;
9327         },
9328
9329         _setOption: function( key, value ) {
9330                 switch ( key ) {
9331                         case "value":
9332                                 this.options.value = value;
9333                                 this._refreshValue();
9334                                 this._trigger( "change" );
9335                                 break;
9336                 }
9337
9338                 $.Widget.prototype._setOption.apply( this, arguments );
9339         },
9340
9341         _value: function() {
9342                 var val = this.options.value;
9343                 // normalize invalid value
9344                 if ( typeof val !== "number" ) {
9345                         val = 0;
9346                 }
9347                 if ( val < this._valueMin() ) {
9348                         val = this._valueMin();
9349                 }
9350                 if ( val > this._valueMax() ) {
9351                         val = this._valueMax();
9352                 }
9353
9354                 return val;
9355         },
9356
9357         _valueMin: function() {
9358                 return 0;
9359         },
9360
9361         _valueMax: function() {
9362                 return 100;
9363         },
9364
9365         _refreshValue: function() {
9366                 var value = this.value();
9367                 this.valueDiv
9368                         [ value === this._valueMax() ? "addClass" : "removeClass"]( "ui-corner-right" )
9369                         .width( value + "%" );
9370                 this.element.attr( "aria-valuenow", value );
9371         }
9372 });
9373
9374 $.extend( $.ui.progressbar, {
9375         version: "1.8"
9376 });
9377
9378 })( jQuery );
9379 /*
9380  * jQuery UI Effects 1.8
9381  *
9382  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
9383  * Dual licensed under the MIT (MIT-LICENSE.txt)
9384  * and GPL (GPL-LICENSE.txt) licenses.
9385  *
9386  * http://docs.jquery.com/UI/Effects/
9387  */
9388 ;jQuery.effects || (function($) {
9389
9390 $.effects = {};
9391
9392
9393
9394 /******************************************************************************/
9395 /****************************** COLOR ANIMATIONS ******************************/
9396 /******************************************************************************/
9397
9398 // override the animation for color styles
9399 $.each(['backgroundColor', 'borderBottomColor', 'borderLeftColor',
9400         'borderRightColor', 'borderTopColor', 'color', 'outlineColor'],
9401 function(i, attr) {
9402         $.fx.step[attr] = function(fx) {
9403                 if (!fx.colorInit) {
9404                         fx.start = getColor(fx.elem, attr);
9405                         fx.end = getRGB(fx.end);
9406                         fx.colorInit = true;
9407                 }
9408
9409                 fx.elem.style[attr] = 'rgb(' +
9410                         Math.max(Math.min(parseInt((fx.pos * (fx.end[0] - fx.start[0])) + fx.start[0], 10), 255), 0) + ',' +
9411                         Math.max(Math.min(parseInt((fx.pos * (fx.end[1] - fx.start[1])) + fx.start[1], 10), 255), 0) + ',' +
9412                         Math.max(Math.min(parseInt((fx.pos * (fx.end[2] - fx.start[2])) + fx.start[2], 10), 255), 0) + ')';
9413         };
9414 });
9415
9416 // Color Conversion functions from highlightFade
9417 // By Blair Mitchelmore
9418 // http://jquery.offput.ca/highlightFade/
9419
9420 // Parse strings looking for color tuples [255,255,255]
9421 function getRGB(color) {
9422                 var result;
9423
9424                 // Check if we're already dealing with an array of colors
9425                 if ( color && color.constructor == Array && color.length == 3 )
9426                                 return color;
9427
9428                 // Look for rgb(num,num,num)
9429                 if (result = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(color))
9430                                 return [parseInt(result[1],10), parseInt(result[2],10), parseInt(result[3],10)];
9431
9432                 // Look for rgb(num%,num%,num%)
9433                 if (result = /rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(color))
9434                                 return [parseFloat(result[1])*2.55, parseFloat(result[2])*2.55, parseFloat(result[3])*2.55];
9435
9436                 // Look for #a0b1c2
9437                 if (result = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(color))
9438                                 return [parseInt(result[1],16), parseInt(result[2],16), parseInt(result[3],16)];
9439
9440                 // Look for #fff
9441                 if (result = /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(color))
9442                                 return [parseInt(result[1]+result[1],16), parseInt(result[2]+result[2],16), parseInt(result[3]+result[3],16)];
9443
9444                 // Look for rgba(0, 0, 0, 0) == transparent in Safari 3
9445                 if (result = /rgba\(0, 0, 0, 0\)/.exec(color))
9446                                 return colors['transparent'];
9447
9448                 // Otherwise, we're most likely dealing with a named color
9449                 return colors[$.trim(color).toLowerCase()];
9450 }
9451
9452 function getColor(elem, attr) {
9453                 var color;
9454
9455                 do {
9456                                 color = $.curCSS(elem, attr);
9457
9458                                 // Keep going until we find an element that has color, or we hit the body
9459                                 if ( color != '' && color != 'transparent' || $.nodeName(elem, "body") )
9460                                                 break;
9461
9462                                 attr = "backgroundColor";
9463                 } while ( elem = elem.parentNode );
9464
9465                 return getRGB(color);
9466 };
9467
9468 // Some named colors to work with
9469 // From Interface by Stefan Petre
9470 // http://interface.eyecon.ro/
9471
9472 var colors = {
9473         aqua:[0,255,255],
9474         azure:[240,255,255],
9475         beige:[245,245,220],
9476         black:[0,0,0],
9477         blue:[0,0,255],
9478         brown:[165,42,42],
9479         cyan:[0,255,255],
9480         darkblue:[0,0,139],
9481         darkcyan:[0,139,139],
9482         darkgrey:[169,169,169],
9483         darkgreen:[0,100,0],
9484         darkkhaki:[189,183,107],
9485         darkmagenta:[139,0,139],
9486         darkolivegreen:[85,107,47],
9487         darkorange:[255,140,0],
9488         darkorchid:[153,50,204],
9489         darkred:[139,0,0],
9490         darksalmon:[233,150,122],
9491         darkviolet:[148,0,211],
9492         fuchsia:[255,0,255],
9493         gold:[255,215,0],
9494         green:[0,128,0],
9495         indigo:[75,0,130],
9496         khaki:[240,230,140],
9497         lightblue:[173,216,230],
9498         lightcyan:[224,255,255],
9499         lightgreen:[144,238,144],
9500         lightgrey:[211,211,211],
9501         lightpink:[255,182,193],
9502         lightyellow:[255,255,224],
9503         lime:[0,255,0],
9504         magenta:[255,0,255],
9505         maroon:[128,0,0],
9506         navy:[0,0,128],
9507         olive:[128,128,0],
9508         orange:[255,165,0],
9509         pink:[255,192,203],
9510         purple:[128,0,128],
9511         violet:[128,0,128],
9512         red:[255,0,0],
9513         silver:[192,192,192],
9514         white:[255,255,255],
9515         yellow:[255,255,0],
9516         transparent: [255,255,255]
9517 };
9518
9519
9520
9521 /******************************************************************************/
9522 /****************************** CLASS ANIMATIONS ******************************/
9523 /******************************************************************************/
9524
9525 var classAnimationActions = ['add', 'remove', 'toggle'],
9526         shorthandStyles = {
9527                 border: 1,
9528                 borderBottom: 1,
9529                 borderColor: 1,
9530                 borderLeft: 1,
9531                 borderRight: 1,
9532                 borderTop: 1,
9533                 borderWidth: 1,
9534                 margin: 1,
9535                 padding: 1
9536         };
9537
9538 function getElementStyles() {
9539         var style = document.defaultView
9540                         ? document.defaultView.getComputedStyle(this, null)
9541                         : this.currentStyle,
9542                 newStyle = {},
9543                 key,
9544                 camelCase;
9545
9546         // webkit enumerates style porperties
9547         if (style && style.length && style[0] && style[style[0]]) {
9548                 var len = style.length;
9549                 while (len--) {
9550                         key = style[len];
9551                         if (typeof style[key] == 'string') {
9552                                 camelCase = key.replace(/\-(\w)/g, function(all, letter){
9553                                         return letter.toUpperCase();
9554                                 });
9555                                 newStyle[camelCase] = style[key];
9556                         }
9557                 }
9558         } else {
9559                 for (key in style) {
9560                         if (typeof style[key] === 'string') {
9561                                 newStyle[key] = style[key];
9562                         }
9563                 }
9564         }
9565
9566         return newStyle;
9567 }
9568
9569 function filterStyles(styles) {
9570         var name, value;
9571         for (name in styles) {
9572                 value = styles[name];
9573                 if (
9574                         // ignore null and undefined values
9575                         value == null ||
9576                         // ignore functions (when does this occur?)
9577                         $.isFunction(value) ||
9578                         // shorthand styles that need to be expanded
9579                         name in shorthandStyles ||
9580                         // ignore scrollbars (break in IE)
9581                         (/scrollbar/).test(name) ||
9582
9583                         // only colors or values that can be converted to numbers
9584                         (!(/color/i).test(name) && isNaN(parseFloat(value)))
9585                 ) {
9586                         delete styles[name];
9587                 }
9588         }
9589
9590         return styles;
9591 }
9592
9593 function styleDifference(oldStyle, newStyle) {
9594         var diff = { _: 0 }, // http://dev.jquery.com/ticket/5459
9595                 name;
9596
9597         for (name in newStyle) {
9598                 if (oldStyle[name] != newStyle[name]) {
9599                         diff[name] = newStyle[name];
9600                 }
9601         }
9602
9603         return diff;
9604 }
9605
9606 $.effects.animateClass = function(value, duration, easing, callback) {
9607         if ($.isFunction(easing)) {
9608                 callback = easing;
9609                 easing = null;
9610         }
9611
9612         return this.each(function() {
9613
9614                 var that = $(this),
9615                         originalStyleAttr = that.attr('style') || ' ',
9616                         originalStyle = filterStyles(getElementStyles.call(this)),
9617                         newStyle,
9618                         className = that.attr('className');
9619
9620                 $.each(classAnimationActions, function(i, action) {
9621                         if (value[action]) {
9622                                 that[action + 'Class'](value[action]);
9623                         }
9624                 });
9625                 newStyle = filterStyles(getElementStyles.call(this));
9626                 that.attr('className', className);
9627
9628                 that.animate(styleDifference(originalStyle, newStyle), duration, easing, function() {
9629                         $.each(classAnimationActions, function(i, action) {
9630                                 if (value[action]) { that[action + 'Class'](value[action]); }
9631                         });
9632                         // work around bug in IE by clearing the cssText before setting it
9633                         if (typeof that.attr('style') == 'object') {
9634                                 that.attr('style').cssText = '';
9635                                 that.attr('style').cssText = originalStyleAttr;
9636                         } else {
9637                                 that.attr('style', originalStyleAttr);
9638                         }
9639                         if (callback) { callback.apply(this, arguments); }
9640                 });
9641         });
9642 };
9643
9644 $.fn.extend({
9645         _addClass: $.fn.addClass,
9646         addClass: function(classNames, speed, easing, callback) {
9647                 return speed ? $.effects.animateClass.apply(this, [{ add: classNames },speed,easing,callback]) : this._addClass(classNames);
9648         },
9649
9650         _removeClass: $.fn.removeClass,
9651         removeClass: function(classNames,speed,easing,callback) {
9652                 return speed ? $.effects.animateClass.apply(this, [{ remove: classNames },speed,easing,callback]) : this._removeClass(classNames);
9653         },
9654
9655         _toggleClass: $.fn.toggleClass,
9656         toggleClass: function(classNames, force, speed, easing, callback) {
9657                 if ( typeof force == "boolean" || force === undefined ) {
9658                         if ( !speed ) {
9659                                 // without speed parameter;
9660                                 return this._toggleClass(classNames, force);
9661                         } else {
9662                                 return $.effects.animateClass.apply(this, [(force?{add:classNames}:{remove:classNames}),speed,easing,callback]);
9663                         }
9664                 } else {
9665                         // without switch parameter;
9666                         return $.effects.animateClass.apply(this, [{ toggle: classNames },force,speed,easing]);
9667                 }
9668         },
9669
9670         switchClass: function(remove,add,speed,easing,callback) {
9671                 return $.effects.animateClass.apply(this, [{ add: add, remove: remove },speed,easing,callback]);
9672         }
9673 });
9674
9675
9676
9677 /******************************************************************************/
9678 /*********************************** EFFECTS **********************************/
9679 /******************************************************************************/
9680
9681 $.extend($.effects, {
9682         version: "1.8",
9683
9684         // Saves a set of properties in a data storage
9685         save: function(element, set) {
9686                 for(var i=0; i < set.length; i++) {
9687                         if(set[i] !== null) element.data("ec.storage."+set[i], element[0].style[set[i]]);
9688                 }
9689         },
9690
9691         // Restores a set of previously saved properties from a data storage
9692         restore: function(element, set) {
9693                 for(var i=0; i < set.length; i++) {
9694                         if(set[i] !== null) element.css(set[i], element.data("ec.storage."+set[i]));
9695                 }
9696         },
9697
9698         setMode: function(el, mode) {
9699                 if (mode == 'toggle') mode = el.is(':hidden') ? 'show' : 'hide'; // Set for toggle
9700                 return mode;
9701         },
9702
9703         getBaseline: function(origin, original) { // Translates a [top,left] array into a baseline value
9704                 // this should be a little more flexible in the future to handle a string & hash
9705                 var y, x;
9706                 switch (origin[0]) {
9707                         case 'top': y = 0; break;
9708                         case 'middle': y = 0.5; break;
9709                         case 'bottom': y = 1; break;
9710                         default: y = origin[0] / original.height;
9711                 };
9712                 switch (origin[1]) {
9713                         case 'left': x = 0; break;
9714                         case 'center': x = 0.5; break;
9715                         case 'right': x = 1; break;
9716                         default: x = origin[1] / original.width;
9717                 };
9718                 return {x: x, y: y};
9719         },
9720
9721         // Wraps the element around a wrapper that copies position properties
9722         createWrapper: function(element) {
9723
9724                 // if the element is already wrapped, return it
9725                 if (element.parent().is('.ui-effects-wrapper')) {
9726                         return element.parent();
9727                 }
9728
9729                 // wrap the element
9730                 var props = {
9731                                 width: element.outerWidth(true),
9732                                 height: element.outerHeight(true),
9733                                 'float': element.css('float')
9734                         },
9735                         wrapper = $('<div></div>')
9736                                 .addClass('ui-effects-wrapper')
9737                                 .css({
9738                                         fontSize: '100%',
9739                                         background: 'transparent',
9740                                         border: 'none',
9741                                         margin: 0,
9742                                         padding: 0
9743                                 });
9744
9745                 element.wrap(wrapper);
9746                 wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually loose the reference to the wrapped element
9747
9748                 // transfer positioning properties to the wrapper
9749                 if (element.css('position') == 'static') {
9750                         wrapper.css({ position: 'relative' });
9751                         element.css({ position: 'relative' });
9752                 } else {
9753                         $.extend(props, {
9754                                 position: element.css('position'),
9755                                 zIndex: element.css('z-index')
9756                         });
9757                         $.each(['top', 'left', 'bottom', 'right'], function(i, pos) {
9758                                 props[pos] = element.css(pos);
9759                                 if (isNaN(parseInt(props[pos], 10))) {
9760                                         props[pos] = 'auto';
9761                                 }
9762                         });
9763                         element.css({position: 'relative', top: 0, left: 0 });
9764                 }
9765
9766                 return wrapper.css(props).show();
9767         },
9768
9769         removeWrapper: function(element) {
9770                 if (element.parent().is('.ui-effects-wrapper'))
9771                         return element.parent().replaceWith(element);
9772                 return element;
9773         },
9774
9775         setTransition: function(element, list, factor, value) {
9776                 value = value || {};
9777                 $.each(list, function(i, x){
9778                         unit = element.cssUnit(x);
9779                         if (unit[0] > 0) value[x] = unit[0] * factor + unit[1];
9780                 });
9781                 return value;
9782         }
9783 });
9784
9785
9786 function _normalizeArguments(effect, options, speed, callback) {
9787         // shift params for method overloading
9788         if (typeof effect == 'object') {
9789                 callback = options;
9790                 speed = null;
9791                 options = effect;
9792                 effect = options.effect;
9793         }
9794         if ($.isFunction(options)) {
9795                 callback = options;
9796                 speed = null;
9797                 options = {};
9798         }
9799         if ($.isFunction(speed)) {
9800                 callback = speed;
9801                 speed = null;
9802         }
9803         if (typeof options == 'number' || $.fx.speeds[options]) {
9804                 callback = speed;
9805                 speed = options;
9806                 options = {};
9807         }
9808
9809         options = options || {};
9810
9811         speed = speed || options.duration;
9812         speed = $.fx.off ? 0 : typeof speed == 'number'
9813                 ? speed : $.fx.speeds[speed] || $.fx.speeds._default;
9814
9815         callback = callback || options.complete;
9816
9817         return [effect, options, speed, callback];
9818 }
9819
9820 $.fn.extend({
9821         effect: function(effect, options, speed, callback) {
9822                 var args = _normalizeArguments.apply(this, arguments),
9823                         // TODO: make effects takes actual parameters instead of a hash
9824                         args2 = {
9825                                 options: args[1],
9826                                 duration: args[2],
9827                                 callback: args[3]
9828                         },
9829                         effectMethod = $.effects[effect];
9830
9831                 return effectMethod && !$.fx.off ? effectMethod.call(this, args2) : this;
9832         },
9833
9834         _show: $.fn.show,
9835         show: function(speed) {
9836                 if (!speed || typeof speed == 'number' || $.fx.speeds[speed]) {
9837                         return this._show.apply(this, arguments);
9838                 } else {
9839                         var args = _normalizeArguments.apply(this, arguments);
9840                         args[1].mode = 'show';
9841                         return this.effect.apply(this, args);
9842                 }
9843         },
9844
9845         _hide: $.fn.hide,
9846         hide: function(speed) {
9847                 if (!speed || typeof speed == 'number' || $.fx.speeds[speed]) {
9848                         return this._hide.apply(this, arguments);
9849                 } else {
9850                         var args = _normalizeArguments.apply(this, arguments);
9851                         args[1].mode = 'hide';
9852                         return this.effect.apply(this, args);
9853                 }
9854         },
9855
9856         // jQuery core overloads toggle and create _toggle
9857         __toggle: $.fn.toggle,
9858         toggle: function(speed) {
9859                 if (!speed || typeof speed == 'number' || $.fx.speeds[speed] ||
9860                         typeof speed == 'boolean' || $.isFunction(speed)) {
9861                         return this.__toggle.apply(this, arguments);
9862                 } else {
9863                         var args = _normalizeArguments.apply(this, arguments);
9864                         args[1].mode = 'toggle';
9865                         return this.effect.apply(this, args);
9866                 }
9867         },
9868
9869         // helper functions
9870         cssUnit: function(key) {
9871                 var style = this.css(key), val = [];
9872                 $.each( ['em','px','%','pt'], function(i, unit){
9873                         if(style.indexOf(unit) > 0)
9874                                 val = [parseFloat(style), unit];
9875                 });
9876                 return val;
9877         }
9878 });
9879
9880
9881
9882 /******************************************************************************/
9883 /*********************************** EASING ***********************************/
9884 /******************************************************************************/
9885
9886 /*
9887  * jQuery Easing v1.3 - http://gsgd.co.uk/sandbox/jquery/easing/
9888  *
9889  * Uses the built in easing capabilities added In jQuery 1.1
9890  * to offer multiple easing options
9891  *
9892  * TERMS OF USE - jQuery Easing
9893  *
9894  * Open source under the BSD License.
9895  *
9896  * Copyright 2008 George McGinley Smith
9897  * All rights reserved.
9898  *
9899  * Redistribution and use in source and binary forms, with or without modification,
9900  * are permitted provided that the following conditions are met:
9901  *
9902  * Redistributions of source code must retain the above copyright notice, this list of
9903  * conditions and the following disclaimer.
9904  * Redistributions in binary form must reproduce the above copyright notice, this list
9905  * of conditions and the following disclaimer in the documentation and/or other materials
9906  * provided with the distribution.
9907  *
9908  * Neither the name of the author nor the names of contributors may be used to endorse
9909  * or promote products derived from this software without specific prior written permission.
9910  *
9911  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
9912  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
9913  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
9914  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
9915  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
9916  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
9917  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
9918  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
9919  * OF THE POSSIBILITY OF SUCH DAMAGE.
9920  *
9921 */
9922
9923 // t: current time, b: begInnIng value, c: change In value, d: duration
9924 $.easing.jswing = $.easing.swing;
9925
9926 $.extend($.easing,
9927 {
9928         def: 'easeOutQuad',
9929         swing: function (x, t, b, c, d) {
9930                 //alert($.easing.default);
9931                 return $.easing[$.easing.def](x, t, b, c, d);
9932         },
9933         easeInQuad: function (x, t, b, c, d) {
9934                 return c*(t/=d)*t + b;
9935         },
9936         easeOutQuad: function (x, t, b, c, d) {
9937                 return -c *(t/=d)*(t-2) + b;
9938         },
9939         easeInOutQuad: function (x, t, b, c, d) {
9940                 if ((t/=d/2) < 1) return c/2*t*t + b;
9941                 return -c/2 * ((--t)*(t-2) - 1) + b;
9942         },
9943         easeInCubic: function (x, t, b, c, d) {
9944                 return c*(t/=d)*t*t + b;
9945         },
9946         easeOutCubic: function (x, t, b, c, d) {
9947                 return c*((t=t/d-1)*t*t + 1) + b;
9948         },
9949         easeInOutCubic: function (x, t, b, c, d) {
9950                 if ((t/=d/2) < 1) return c/2*t*t*t + b;
9951                 return c/2*((t-=2)*t*t + 2) + b;
9952         },
9953         easeInQuart: function (x, t, b, c, d) {
9954                 return c*(t/=d)*t*t*t + b;
9955         },
9956         easeOutQuart: function (x, t, b, c, d) {
9957                 return -c * ((t=t/d-1)*t*t*t - 1) + b;
9958         },
9959         easeInOutQuart: function (x, t, b, c, d) {
9960                 if ((t/=d/2) < 1) return c/2*t*t*t*t + b;
9961                 return -c/2 * ((t-=2)*t*t*t - 2) + b;
9962         },
9963         easeInQuint: function (x, t, b, c, d) {
9964                 return c*(t/=d)*t*t*t*t + b;
9965         },
9966         easeOutQuint: function (x, t, b, c, d) {
9967                 return c*((t=t/d-1)*t*t*t*t + 1) + b;
9968         },
9969         easeInOutQuint: function (x, t, b, c, d) {
9970                 if ((t/=d/2) < 1) return c/2*t*t*t*t*t + b;
9971                 return c/2*((t-=2)*t*t*t*t + 2) + b;
9972         },
9973         easeInSine: function (x, t, b, c, d) {
9974                 return -c * Math.cos(t/d * (Math.PI/2)) + c + b;
9975         },
9976         easeOutSine: function (x, t, b, c, d) {
9977                 return c * Math.sin(t/d * (Math.PI/2)) + b;
9978         },
9979         easeInOutSine: function (x, t, b, c, d) {
9980                 return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
9981         },
9982         easeInExpo: function (x, t, b, c, d) {
9983                 return (t==0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b;
9984         },
9985         easeOutExpo: function (x, t, b, c, d) {
9986                 return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
9987         },
9988         easeInOutExpo: function (x, t, b, c, d) {
9989                 if (t==0) return b;
9990                 if (t==d) return b+c;
9991                 if ((t/=d/2) < 1) return c/2 * Math.pow(2, 10 * (t - 1)) + b;
9992                 return c/2 * (-Math.pow(2, -10 * --t) + 2) + b;
9993         },
9994         easeInCirc: function (x, t, b, c, d) {
9995                 return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
9996         },
9997         easeOutCirc: function (x, t, b, c, d) {
9998                 return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
9999         },
10000         easeInOutCirc: function (x, t, b, c, d) {
10001                 if ((t/=d/2) < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b;
10002                 return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b;
10003         },
10004         easeInElastic: function (x, t, b, c, d) {
10005                 var s=1.70158;var p=0;var a=c;
10006                 if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
10007                 if (a < Math.abs(c)) { a=c; var s=p/4; }
10008                 else var s = p/(2*Math.PI) * Math.asin (c/a);
10009                 return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
10010         },
10011         easeOutElastic: function (x, t, b, c, d) {
10012                 var s=1.70158;var p=0;var a=c;
10013                 if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
10014                 if (a < Math.abs(c)) { a=c; var s=p/4; }
10015                 else var s = p/(2*Math.PI) * Math.asin (c/a);
10016                 return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
10017         },
10018         easeInOutElastic: function (x, t, b, c, d) {
10019                 var s=1.70158;var p=0;var a=c;
10020                 if (t==0) return b;  if ((t/=d/2)==2) return b+c;  if (!p) p=d*(.3*1.5);
10021                 if (a < Math.abs(c)) { a=c; var s=p/4; }
10022                 else var s = p/(2*Math.PI) * Math.asin (c/a);
10023                 if (t < 1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
10024                 return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*.5 + c + b;
10025         },
10026         easeInBack: function (x, t, b, c, d, s) {
10027                 if (s == undefined) s = 1.70158;
10028                 return c*(t/=d)*t*((s+1)*t - s) + b;
10029         },
10030         easeOutBack: function (x, t, b, c, d, s) {
10031                 if (s == undefined) s = 1.70158;
10032                 return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
10033         },
10034         easeInOutBack: function (x, t, b, c, d, s) {
10035                 if (s == undefined) s = 1.70158;
10036                 if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
10037                 return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
10038         },
10039         easeInBounce: function (x, t, b, c, d) {
10040                 return c - $.easing.easeOutBounce (x, d-t, 0, c, d) + b;
10041         },
10042         easeOutBounce: function (x, t, b, c, d) {
10043                 if ((t/=d) < (1/2.75)) {
10044                         return c*(7.5625*t*t) + b;
10045                 } else if (t < (2/2.75)) {
10046                         return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
10047                 } else if (t < (2.5/2.75)) {
10048                         return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
10049                 } else {
10050                         return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
10051                 }
10052         },
10053         easeInOutBounce: function (x, t, b, c, d) {
10054                 if (t < d/2) return $.easing.easeInBounce (x, t*2, 0, c, d) * .5 + b;
10055                 return $.easing.easeOutBounce (x, t*2-d, 0, c, d) * .5 + c*.5 + b;
10056         }
10057 });
10058
10059 /*
10060  *
10061  * TERMS OF USE - EASING EQUATIONS
10062  *
10063  * Open source under the BSD License.
10064  *
10065  * Copyright 2001 Robert Penner
10066  * All rights reserved.
10067  *
10068  * Redistribution and use in source and binary forms, with or without modification,
10069  * are permitted provided that the following conditions are met:
10070  *
10071  * Redistributions of source code must retain the above copyright notice, this list of
10072  * conditions and the following disclaimer.
10073  * Redistributions in binary form must reproduce the above copyright notice, this list
10074  * of conditions and the following disclaimer in the documentation and/or other materials
10075  * provided with the distribution.
10076  *
10077  * Neither the name of the author nor the names of contributors may be used to endorse
10078  * or promote products derived from this software without specific prior written permission.
10079  *
10080  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
10081  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
10082  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
10083  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
10084  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
10085  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
10086  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
10087  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
10088  * OF THE POSSIBILITY OF SUCH DAMAGE.
10089  *
10090  */
10091
10092 })(jQuery);
10093 /*
10094  * jQuery UI Effects Blind 1.8
10095  *
10096  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
10097  * Dual licensed under the MIT (MIT-LICENSE.txt)
10098  * and GPL (GPL-LICENSE.txt) licenses.
10099  *
10100  * http://docs.jquery.com/UI/Effects/Blind
10101  *
10102  * Depends:
10103  *      jquery.effects.core.js
10104  */
10105 (function($) {
10106
10107 $.effects.blind = function(o) {
10108
10109         return this.queue(function() {
10110
10111                 // Create element
10112                 var el = $(this), props = ['position','top','left'];
10113
10114                 // Set options
10115                 var mode = $.effects.setMode(el, o.options.mode || 'hide'); // Set Mode
10116                 var direction = o.options.direction || 'vertical'; // Default direction
10117
10118                 // Adjust
10119                 $.effects.save(el, props); el.show(); // Save & Show
10120                 var wrapper = $.effects.createWrapper(el).css({overflow:'hidden'}); // Create Wrapper
10121                 var ref = (direction == 'vertical') ? 'height' : 'width';
10122                 var distance = (direction == 'vertical') ? wrapper.height() : wrapper.width();
10123                 if(mode == 'show') wrapper.css(ref, 0); // Shift
10124
10125                 // Animation
10126                 var animation = {};
10127                 animation[ref] = mode == 'show' ? distance : 0;
10128
10129                 // Animate
10130                 wrapper.animate(animation, o.duration, o.options.easing, function() {
10131                         if(mode == 'hide') el.hide(); // Hide
10132                         $.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
10133                         if(o.callback) o.callback.apply(el[0], arguments); // Callback
10134                         el.dequeue();
10135                 });
10136
10137         });
10138
10139 };
10140
10141 })(jQuery);
10142 /*
10143  * jQuery UI Effects Bounce 1.8
10144  *
10145  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
10146  * Dual licensed under the MIT (MIT-LICENSE.txt)
10147  * and GPL (GPL-LICENSE.txt) licenses.
10148  *
10149  * http://docs.jquery.com/UI/Effects/Bounce
10150  *
10151  * Depends:
10152  *      jquery.effects.core.js
10153  */
10154 (function($) {
10155
10156 $.effects.bounce = function(o) {
10157
10158         return this.queue(function() {
10159
10160                 // Create element
10161                 var el = $(this), props = ['position','top','left'];
10162
10163                 // Set options
10164                 var mode = $.effects.setMode(el, o.options.mode || 'effect'); // Set Mode
10165                 var direction = o.options.direction || 'up'; // Default direction
10166                 var distance = o.options.distance || 20; // Default distance
10167                 var times = o.options.times || 5; // Default # of times
10168                 var speed = o.duration || 250; // Default speed per bounce
10169                 if (/show|hide/.test(mode)) props.push('opacity'); // Avoid touching opacity to prevent clearType and PNG issues in IE
10170
10171                 // Adjust
10172                 $.effects.save(el, props); el.show(); // Save & Show
10173                 $.effects.createWrapper(el); // Create Wrapper
10174                 var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
10175                 var motion = (direction == 'up' || direction == 'left') ? 'pos' : 'neg';
10176                 var distance = o.options.distance || (ref == 'top' ? el.outerHeight({margin:true}) / 3 : el.outerWidth({margin:true}) / 3);
10177                 if (mode == 'show') el.css('opacity', 0).css(ref, motion == 'pos' ? -distance : distance); // Shift
10178                 if (mode == 'hide') distance = distance / (times * 2);
10179                 if (mode != 'hide') times--;
10180
10181                 // Animate
10182                 if (mode == 'show') { // Show Bounce
10183                         var animation = {opacity: 1};
10184                         animation[ref] = (motion == 'pos' ? '+=' : '-=') + distance;
10185                         el.animate(animation, speed / 2, o.options.easing);
10186                         distance = distance / 2;
10187                         times--;
10188                 };
10189                 for (var i = 0; i < times; i++) { // Bounces
10190                         var animation1 = {}, animation2 = {};
10191                         animation1[ref] = (motion == 'pos' ? '-=' : '+=') + distance;
10192                         animation2[ref] = (motion == 'pos' ? '+=' : '-=') + distance;
10193                         el.animate(animation1, speed / 2, o.options.easing).animate(animation2, speed / 2, o.options.easing);
10194                         distance = (mode == 'hide') ? distance * 2 : distance / 2;
10195                 };
10196                 if (mode == 'hide') { // Last Bounce
10197                         var animation = {opacity: 0};
10198                         animation[ref] = (motion == 'pos' ? '-=' : '+=')  + distance;
10199                         el.animate(animation, speed / 2, o.options.easing, function(){
10200                                 el.hide(); // Hide
10201                                 $.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
10202                                 if(o.callback) o.callback.apply(this, arguments); // Callback
10203                         });
10204                 } else {
10205                         var animation1 = {}, animation2 = {};
10206                         animation1[ref] = (motion == 'pos' ? '-=' : '+=') + distance;
10207                         animation2[ref] = (motion == 'pos' ? '+=' : '-=') + distance;
10208                         el.animate(animation1, speed / 2, o.options.easing).animate(animation2, speed / 2, o.options.easing, function(){
10209                                 $.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
10210                                 if(o.callback) o.callback.apply(this, arguments); // Callback
10211                         });
10212                 };
10213                 el.queue('fx', function() { el.dequeue(); });
10214                 el.dequeue();
10215         });
10216
10217 };
10218
10219 })(jQuery);
10220 /*
10221  * jQuery UI Effects Clip 1.8
10222  *
10223  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
10224  * Dual licensed under the MIT (MIT-LICENSE.txt)
10225  * and GPL (GPL-LICENSE.txt) licenses.
10226  *
10227  * http://docs.jquery.com/UI/Effects/Clip
10228  *
10229  * Depends:
10230  *      jquery.effects.core.js
10231  */
10232 (function($) {
10233
10234 $.effects.clip = function(o) {
10235
10236         return this.queue(function() {
10237
10238                 // Create element
10239                 var el = $(this), props = ['position','top','left','height','width'];
10240
10241                 // Set options
10242                 var mode = $.effects.setMode(el, o.options.mode || 'hide'); // Set Mode
10243                 var direction = o.options.direction || 'vertical'; // Default direction
10244
10245                 // Adjust
10246                 $.effects.save(el, props); el.show(); // Save & Show
10247                 var wrapper = $.effects.createWrapper(el).css({overflow:'hidden'}); // Create Wrapper
10248                 var animate = el[0].tagName == 'IMG' ? wrapper : el;
10249                 var ref = {
10250                         size: (direction == 'vertical') ? 'height' : 'width',
10251                         position: (direction == 'vertical') ? 'top' : 'left'
10252                 };
10253                 var distance = (direction == 'vertical') ? animate.height() : animate.width();
10254                 if(mode == 'show') { animate.css(ref.size, 0); animate.css(ref.position, distance / 2); } // Shift
10255
10256                 // Animation
10257                 var animation = {};
10258                 animation[ref.size] = mode == 'show' ? distance : 0;
10259                 animation[ref.position] = mode == 'show' ? 0 : distance / 2;
10260
10261                 // Animate
10262                 animate.animate(animation, { queue: false, duration: o.duration, easing: o.options.easing, complete: function() {
10263                         if(mode == 'hide') el.hide(); // Hide
10264                         $.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
10265                         if(o.callback) o.callback.apply(el[0], arguments); // Callback
10266                         el.dequeue();
10267                 }});
10268
10269         });
10270
10271 };
10272
10273 })(jQuery);
10274 /*
10275  * jQuery UI Effects Drop 1.8
10276  *
10277  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
10278  * Dual licensed under the MIT (MIT-LICENSE.txt)
10279  * and GPL (GPL-LICENSE.txt) licenses.
10280  *
10281  * http://docs.jquery.com/UI/Effects/Drop
10282  *
10283  * Depends:
10284  *      jquery.effects.core.js
10285  */
10286 (function($) {
10287
10288 $.effects.drop = function(o) {
10289
10290         return this.queue(function() {
10291
10292                 // Create element
10293                 var el = $(this), props = ['position','top','left','opacity'];
10294
10295                 // Set options
10296                 var mode = $.effects.setMode(el, o.options.mode || 'hide'); // Set Mode
10297                 var direction = o.options.direction || 'left'; // Default Direction
10298
10299                 // Adjust
10300                 $.effects.save(el, props); el.show(); // Save & Show
10301                 $.effects.createWrapper(el); // Create Wrapper
10302                 var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
10303                 var motion = (direction == 'up' || direction == 'left') ? 'pos' : 'neg';
10304                 var distance = o.options.distance || (ref == 'top' ? el.outerHeight({margin:true}) / 2 : el.outerWidth({margin:true}) / 2);
10305                 if (mode == 'show') el.css('opacity', 0).css(ref, motion == 'pos' ? -distance : distance); // Shift
10306
10307                 // Animation
10308                 var animation = {opacity: mode == 'show' ? 1 : 0};
10309                 animation[ref] = (mode == 'show' ? (motion == 'pos' ? '+=' : '-=') : (motion == 'pos' ? '-=' : '+=')) + distance;
10310
10311                 // Animate
10312                 el.animate(animation, { queue: false, duration: o.duration, easing: o.options.easing, complete: function() {
10313                         if(mode == 'hide') el.hide(); // Hide
10314                         $.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
10315                         if(o.callback) o.callback.apply(this, arguments); // Callback
10316                         el.dequeue();
10317                 }});
10318
10319         });
10320
10321 };
10322
10323 })(jQuery);
10324 /*
10325  * jQuery UI Effects Explode 1.8
10326  *
10327  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
10328  * Dual licensed under the MIT (MIT-LICENSE.txt)
10329  * and GPL (GPL-LICENSE.txt) licenses.
10330  *
10331  * http://docs.jquery.com/UI/Effects/Explode
10332  *
10333  * Depends:
10334  *      jquery.effects.core.js
10335  */
10336 (function($) {
10337
10338 $.effects.explode = function(o) {
10339
10340         return this.queue(function() {
10341
10342         var rows = o.options.pieces ? Math.round(Math.sqrt(o.options.pieces)) : 3;
10343         var cells = o.options.pieces ? Math.round(Math.sqrt(o.options.pieces)) : 3;
10344
10345         o.options.mode = o.options.mode == 'toggle' ? ($(this).is(':visible') ? 'hide' : 'show') : o.options.mode;
10346         var el = $(this).show().css('visibility', 'hidden');
10347         var offset = el.offset();
10348
10349         //Substract the margins - not fixing the problem yet.
10350         offset.top -= parseInt(el.css("marginTop"),10) || 0;
10351         offset.left -= parseInt(el.css("marginLeft"),10) || 0;
10352
10353         var width = el.outerWidth(true);
10354         var height = el.outerHeight(true);
10355
10356         for(var i=0;i<rows;i++) { // =
10357                 for(var j=0;j<cells;j++) { // ||
10358                         el
10359                                 .clone()
10360                                 .appendTo('body')
10361                                 .wrap('<div></div>')
10362                                 .css({
10363                                         position: 'absolute',
10364                                         visibility: 'visible',
10365                                         left: -j*(width/cells),
10366                                         top: -i*(height/rows)
10367                                 })
10368                                 .parent()
10369                                 .addClass('ui-effects-explode')
10370                                 .css({
10371                                         position: 'absolute',
10372                                         overflow: 'hidden',
10373                                         width: width/cells,
10374                                         height: height/rows,
10375                                         left: offset.left + j*(width/cells) + (o.options.mode == 'show' ? (j-Math.floor(cells/2))*(width/cells) : 0),
10376                                         top: offset.top + i*(height/rows) + (o.options.mode == 'show' ? (i-Math.floor(rows/2))*(height/rows) : 0),
10377                                         opacity: o.options.mode == 'show' ? 0 : 1
10378                                 }).animate({
10379                                         left: offset.left + j*(width/cells) + (o.options.mode == 'show' ? 0 : (j-Math.floor(cells/2))*(width/cells)),
10380                                         top: offset.top + i*(height/rows) + (o.options.mode == 'show' ? 0 : (i-Math.floor(rows/2))*(height/rows)),
10381                                         opacity: o.options.mode == 'show' ? 1 : 0
10382                                 }, o.duration || 500);
10383                 }
10384         }
10385
10386         // Set a timeout, to call the callback approx. when the other animations have finished
10387         setTimeout(function() {
10388
10389                 o.options.mode == 'show' ? el.css({ visibility: 'visible' }) : el.css({ visibility: 'visible' }).hide();
10390                                 if(o.callback) o.callback.apply(el[0]); // Callback
10391                                 el.dequeue();
10392
10393                                 $('div.ui-effects-explode').remove();
10394
10395         }, o.duration || 500);
10396
10397
10398         });
10399
10400 };
10401
10402 })(jQuery);
10403 /*
10404  * jQuery UI Effects Fold 1.8
10405  *
10406  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
10407  * Dual licensed under the MIT (MIT-LICENSE.txt)
10408  * and GPL (GPL-LICENSE.txt) licenses.
10409  *
10410  * http://docs.jquery.com/UI/Effects/Fold
10411  *
10412  * Depends:
10413  *      jquery.effects.core.js
10414  */
10415 (function($) {
10416
10417 $.effects.fold = function(o) {
10418
10419         return this.queue(function() {
10420
10421                 // Create element
10422                 var el = $(this), props = ['position','top','left'];
10423
10424                 // Set options
10425                 var mode = $.effects.setMode(el, o.options.mode || 'hide'); // Set Mode
10426                 var size = o.options.size || 15; // Default fold size
10427                 var horizFirst = !(!o.options.horizFirst); // Ensure a boolean value
10428                 var duration = o.duration ? o.duration / 2 : $.fx.speeds._default / 2;
10429
10430                 // Adjust
10431                 $.effects.save(el, props); el.show(); // Save & Show
10432                 var wrapper = $.effects.createWrapper(el).css({overflow:'hidden'}); // Create Wrapper
10433                 var widthFirst = ((mode == 'show') != horizFirst);
10434                 var ref = widthFirst ? ['width', 'height'] : ['height', 'width'];
10435                 var distance = widthFirst ? [wrapper.width(), wrapper.height()] : [wrapper.height(), wrapper.width()];
10436                 var percent = /([0-9]+)%/.exec(size);
10437                 if(percent) size = parseInt(percent[1],10) / 100 * distance[mode == 'hide' ? 0 : 1];
10438                 if(mode == 'show') wrapper.css(horizFirst ? {height: 0, width: size} : {height: size, width: 0}); // Shift
10439
10440                 // Animation
10441                 var animation1 = {}, animation2 = {};
10442                 animation1[ref[0]] = mode == 'show' ? distance[0] : size;
10443                 animation2[ref[1]] = mode == 'show' ? distance[1] : 0;
10444
10445                 // Animate
10446                 wrapper.animate(animation1, duration, o.options.easing)
10447                 .animate(animation2, duration, o.options.easing, function() {
10448                         if(mode == 'hide') el.hide(); // Hide
10449                         $.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
10450                         if(o.callback) o.callback.apply(el[0], arguments); // Callback
10451                         el.dequeue();
10452                 });
10453
10454         });
10455
10456 };
10457
10458 })(jQuery);
10459 /*
10460  * jQuery UI Effects Highlight 1.8
10461  *
10462  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
10463  * Dual licensed under the MIT (MIT-LICENSE.txt)
10464  * and GPL (GPL-LICENSE.txt) licenses.
10465  *
10466  * http://docs.jquery.com/UI/Effects/Highlight
10467  *
10468  * Depends:
10469  *      jquery.effects.core.js
10470  */
10471 (function($) {
10472
10473 $.effects.highlight = function(o) {
10474         return this.queue(function() {
10475                 var elem = $(this),
10476                         props = ['backgroundImage', 'backgroundColor', 'opacity'],
10477                         mode = $.effects.setMode(elem, o.options.mode || 'show'),
10478                         animation = {
10479                                 backgroundColor: elem.css('backgroundColor')
10480                         };
10481
10482                 if (mode == 'hide') {
10483                         animation.opacity = 0;
10484                 }
10485
10486                 $.effects.save(elem, props);
10487                 elem
10488                         .show()
10489                         .css({
10490                                 backgroundImage: 'none',
10491                                 backgroundColor: o.options.color || '#ffff99'
10492                         })
10493                         .animate(animation, {
10494                                 queue: false,
10495                                 duration: o.duration,
10496                                 easing: o.options.easing,
10497                                 complete: function() {
10498                                         (mode == 'hide' && elem.hide());
10499                                         $.effects.restore(elem, props);
10500                                         (mode == 'show' && !$.support.opacity && this.style.removeAttribute('filter'));
10501                                         (o.callback && o.callback.apply(this, arguments));
10502                                         elem.dequeue();
10503                                 }
10504                         });
10505         });
10506 };
10507
10508 })(jQuery);
10509 /*
10510  * jQuery UI Effects Pulsate 1.8
10511  *
10512  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
10513  * Dual licensed under the MIT (MIT-LICENSE.txt)
10514  * and GPL (GPL-LICENSE.txt) licenses.
10515  *
10516  * http://docs.jquery.com/UI/Effects/Pulsate
10517  *
10518  * Depends:
10519  *      jquery.effects.core.js
10520  */
10521 (function($) {
10522
10523 $.effects.pulsate = function(o) {
10524         return this.queue(function() {
10525                 var elem = $(this),
10526                         mode = $.effects.setMode(elem, o.options.mode || 'show');
10527                         times = ((o.options.times || 5) * 2) - 1;
10528                         duration = o.duration ? o.duration / 2 : $.fx.speeds._default / 2,
10529                         isVisible = elem.is(':visible'),
10530                         animateTo = 0;
10531
10532                 if (!isVisible) {
10533                         elem.css('opacity', 0).show();
10534                         animateTo = 1;
10535                 }
10536
10537                 if ((mode == 'hide' && isVisible) || (mode == 'show' && !isVisible)) {
10538                         times--;
10539                 }
10540
10541                 for (var i = 0; i < times; i++) {
10542                         elem.animate({ opacity: animateTo }, duration, o.options.easing);
10543                         animateTo = (animateTo + 1) % 2;
10544                 }
10545
10546                 elem.animate({ opacity: animateTo }, duration, o.options.easing, function() {
10547                         if (animateTo == 0) {
10548                                 elem.hide();
10549                         }
10550                         (o.callback && o.callback.apply(this, arguments));
10551                 });
10552
10553                 elem
10554                         .queue('fx', function() { elem.dequeue(); })
10555                         .dequeue();
10556         });
10557 };
10558
10559 })(jQuery);
10560 /*
10561  * jQuery UI Effects Scale 1.8
10562  *
10563  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
10564  * Dual licensed under the MIT (MIT-LICENSE.txt)
10565  * and GPL (GPL-LICENSE.txt) licenses.
10566  *
10567  * http://docs.jquery.com/UI/Effects/Scale
10568  *
10569  * Depends:
10570  *      jquery.effects.core.js
10571  */
10572 (function($) {
10573
10574 $.effects.puff = function(o) {
10575         return this.queue(function() {
10576                 var elem = $(this),
10577                         mode = $.effects.setMode(elem, o.options.mode || 'hide'),
10578                         percent = parseInt(o.options.percent, 10) || 150,
10579                         factor = percent / 100,
10580                         original = { height: elem.height(), width: elem.width() };
10581
10582                 $.extend(o.options, {
10583                         fade: true,
10584                         mode: mode,
10585                         percent: mode == 'hide' ? percent : 100,
10586                         from: mode == 'hide'
10587                                 ? original
10588                                 : {
10589                                         height: original.height * factor,
10590                                         width: original.width * factor
10591                                 }
10592                 });
10593
10594                 elem.effect('scale', o.options, o.duration, o.callback);
10595                 elem.dequeue();
10596         });
10597 };
10598
10599 $.effects.scale = function(o) {
10600
10601         return this.queue(function() {
10602
10603                 // Create element
10604                 var el = $(this);
10605
10606                 // Set options
10607                 var options = $.extend(true, {}, o.options);
10608                 var mode = $.effects.setMode(el, o.options.mode || 'effect'); // Set Mode
10609                 var percent = parseInt(o.options.percent,10) || (parseInt(o.options.percent,10) == 0 ? 0 : (mode == 'hide' ? 0 : 100)); // Set default scaling percent
10610                 var direction = o.options.direction || 'both'; // Set default axis
10611                 var origin = o.options.origin; // The origin of the scaling
10612                 if (mode != 'effect') { // Set default origin and restore for show/hide
10613                         options.origin = origin || ['middle','center'];
10614                         options.restore = true;
10615                 }
10616                 var original = {height: el.height(), width: el.width()}; // Save original
10617                 el.from = o.options.from || (mode == 'show' ? {height: 0, width: 0} : original); // Default from state
10618
10619                 // Adjust
10620                 var factor = { // Set scaling factor
10621                         y: direction != 'horizontal' ? (percent / 100) : 1,
10622                         x: direction != 'vertical' ? (percent / 100) : 1
10623                 };
10624                 el.to = {height: original.height * factor.y, width: original.width * factor.x}; // Set to state
10625
10626                 if (o.options.fade) { // Fade option to support puff
10627                         if (mode == 'show') {el.from.opacity = 0; el.to.opacity = 1;};
10628                         if (mode == 'hide') {el.from.opacity = 1; el.to.opacity = 0;};
10629                 };
10630
10631                 // Animation
10632                 options.from = el.from; options.to = el.to; options.mode = mode;
10633
10634                 // Animate
10635                 el.effect('size', options, o.duration, o.callback);
10636                 el.dequeue();
10637         });
10638
10639 };
10640
10641 $.effects.size = function(o) {
10642
10643         return this.queue(function() {
10644
10645                 // Create element
10646                 var el = $(this), props = ['position','top','left','width','height','overflow','opacity'];
10647                 var props1 = ['position','top','left','overflow','opacity']; // Always restore
10648                 var props2 = ['width','height','overflow']; // Copy for children
10649                 var cProps = ['fontSize'];
10650                 var vProps = ['borderTopWidth', 'borderBottomWidth', 'paddingTop', 'paddingBottom'];
10651                 var hProps = ['borderLeftWidth', 'borderRightWidth', 'paddingLeft', 'paddingRight'];
10652
10653                 // Set options
10654                 var mode = $.effects.setMode(el, o.options.mode || 'effect'); // Set Mode
10655                 var restore = o.options.restore || false; // Default restore
10656                 var scale = o.options.scale || 'both'; // Default scale mode
10657                 var origin = o.options.origin; // The origin of the sizing
10658                 var original = {height: el.height(), width: el.width()}; // Save original
10659                 el.from = o.options.from || original; // Default from state
10660                 el.to = o.options.to || original; // Default to state
10661                 // Adjust
10662                 if (origin) { // Calculate baseline shifts
10663                         var baseline = $.effects.getBaseline(origin, original);
10664                         el.from.top = (original.height - el.from.height) * baseline.y;
10665                         el.from.left = (original.width - el.from.width) * baseline.x;
10666                         el.to.top = (original.height - el.to.height) * baseline.y;
10667                         el.to.left = (original.width - el.to.width) * baseline.x;
10668                 };
10669                 var factor = { // Set scaling factor
10670                         from: {y: el.from.height / original.height, x: el.from.width / original.width},
10671                         to: {y: el.to.height / original.height, x: el.to.width / original.width}
10672                 };
10673                 if (scale == 'box' || scale == 'both') { // Scale the css box
10674                         if (factor.from.y != factor.to.y) { // Vertical props scaling
10675                                 props = props.concat(vProps);
10676                                 el.from = $.effects.setTransition(el, vProps, factor.from.y, el.from);
10677                                 el.to = $.effects.setTransition(el, vProps, factor.to.y, el.to);
10678                         };
10679                         if (factor.from.x != factor.to.x) { // Horizontal props scaling
10680                                 props = props.concat(hProps);
10681                                 el.from = $.effects.setTransition(el, hProps, factor.from.x, el.from);
10682                                 el.to = $.effects.setTransition(el, hProps, factor.to.x, el.to);
10683                         };
10684                 };
10685                 if (scale == 'content' || scale == 'both') { // Scale the content
10686                         if (factor.from.y != factor.to.y) { // Vertical props scaling
10687                                 props = props.concat(cProps);
10688                                 el.from = $.effects.setTransition(el, cProps, factor.from.y, el.from);
10689                                 el.to = $.effects.setTransition(el, cProps, factor.to.y, el.to);
10690                         };
10691                 };
10692                 $.effects.save(el, restore ? props : props1); el.show(); // Save & Show
10693                 $.effects.createWrapper(el); // Create Wrapper
10694                 el.css('overflow','hidden').css(el.from); // Shift
10695
10696                 // Animate
10697                 if (scale == 'content' || scale == 'both') { // Scale the children
10698                         vProps = vProps.concat(['marginTop','marginBottom']).concat(cProps); // Add margins/font-size
10699                         hProps = hProps.concat(['marginLeft','marginRight']); // Add margins
10700                         props2 = props.concat(vProps).concat(hProps); // Concat
10701                         el.find("*[width]").each(function(){
10702                                 child = $(this);
10703                                 if (restore) $.effects.save(child, props2);
10704                                 var c_original = {height: child.height(), width: child.width()}; // Save original
10705                                 child.from = {height: c_original.height * factor.from.y, width: c_original.width * factor.from.x};
10706                                 child.to = {height: c_original.height * factor.to.y, width: c_original.width * factor.to.x};
10707                                 if (factor.from.y != factor.to.y) { // Vertical props scaling
10708                                         child.from = $.effects.setTransition(child, vProps, factor.from.y, child.from);
10709                                         child.to = $.effects.setTransition(child, vProps, factor.to.y, child.to);
10710                                 };
10711                                 if (factor.from.x != factor.to.x) { // Horizontal props scaling
10712                                         child.from = $.effects.setTransition(child, hProps, factor.from.x, child.from);
10713                                         child.to = $.effects.setTransition(child, hProps, factor.to.x, child.to);
10714                                 };
10715                                 child.css(child.from); // Shift children
10716                                 child.animate(child.to, o.duration, o.options.easing, function(){
10717                                         if (restore) $.effects.restore(child, props2); // Restore children
10718                                 }); // Animate children
10719                         });
10720                 };
10721
10722                 // Animate
10723                 el.animate(el.to, { queue: false, duration: o.duration, easing: o.options.easing, complete: function() {
10724                         if (el.to.opacity === 0) {
10725                                 el.css('opacity', el.from.opacity);
10726                         }
10727                         if(mode == 'hide') el.hide(); // Hide
10728                         $.effects.restore(el, restore ? props : props1); $.effects.removeWrapper(el); // Restore
10729                         if(o.callback) o.callback.apply(this, arguments); // Callback
10730                         el.dequeue();
10731                 }});
10732
10733         });
10734
10735 };
10736
10737 })(jQuery);
10738 /*
10739  * jQuery UI Effects Shake 1.8
10740  *
10741  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
10742  * Dual licensed under the MIT (MIT-LICENSE.txt)
10743  * and GPL (GPL-LICENSE.txt) licenses.
10744  *
10745  * http://docs.jquery.com/UI/Effects/Shake
10746  *
10747  * Depends:
10748  *      jquery.effects.core.js
10749  */
10750 (function($) {
10751
10752 $.effects.shake = function(o) {
10753
10754         return this.queue(function() {
10755
10756                 // Create element
10757                 var el = $(this), props = ['position','top','left'];
10758
10759                 // Set options
10760                 var mode = $.effects.setMode(el, o.options.mode || 'effect'); // Set Mode
10761                 var direction = o.options.direction || 'left'; // Default direction
10762                 var distance = o.options.distance || 20; // Default distance
10763                 var times = o.options.times || 3; // Default # of times
10764                 var speed = o.duration || o.options.duration || 140; // Default speed per shake
10765
10766                 // Adjust
10767                 $.effects.save(el, props); el.show(); // Save & Show
10768                 $.effects.createWrapper(el); // Create Wrapper
10769                 var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
10770                 var motion = (direction == 'up' || direction == 'left') ? 'pos' : 'neg';
10771
10772                 // Animation
10773                 var animation = {}, animation1 = {}, animation2 = {};
10774                 animation[ref] = (motion == 'pos' ? '-=' : '+=')  + distance;
10775                 animation1[ref] = (motion == 'pos' ? '+=' : '-=')  + distance * 2;
10776                 animation2[ref] = (motion == 'pos' ? '-=' : '+=')  + distance * 2;
10777
10778                 // Animate
10779                 el.animate(animation, speed, o.options.easing);
10780                 for (var i = 1; i < times; i++) { // Shakes
10781                         el.animate(animation1, speed, o.options.easing).animate(animation2, speed, o.options.easing);
10782                 };
10783                 el.animate(animation1, speed, o.options.easing).
10784                 animate(animation, speed / 2, o.options.easing, function(){ // Last shake
10785                         $.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
10786                         if(o.callback) o.callback.apply(this, arguments); // Callback
10787                 });
10788                 el.queue('fx', function() { el.dequeue(); });
10789                 el.dequeue();
10790         });
10791
10792 };
10793
10794 })(jQuery);
10795 /*
10796  * jQuery UI Effects Slide 1.8
10797  *
10798  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
10799  * Dual licensed under the MIT (MIT-LICENSE.txt)
10800  * and GPL (GPL-LICENSE.txt) licenses.
10801  *
10802  * http://docs.jquery.com/UI/Effects/Slide
10803  *
10804  * Depends:
10805  *      jquery.effects.core.js
10806  */
10807 (function($) {
10808
10809 $.effects.slide = function(o) {
10810
10811         return this.queue(function() {
10812
10813                 // Create element
10814                 var el = $(this), props = ['position','top','left'];
10815
10816                 // Set options
10817                 var mode = $.effects.setMode(el, o.options.mode || 'show'); // Set Mode
10818                 var direction = o.options.direction || 'left'; // Default Direction
10819
10820                 // Adjust
10821                 $.effects.save(el, props); el.show(); // Save & Show
10822                 $.effects.createWrapper(el).css({overflow:'hidden'}); // Create Wrapper
10823                 var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
10824                 var motion = (direction == 'up' || direction == 'left') ? 'pos' : 'neg';
10825                 var distance = o.options.distance || (ref == 'top' ? el.outerHeight({margin:true}) : el.outerWidth({margin:true}));
10826                 if (mode == 'show') el.css(ref, motion == 'pos' ? -distance : distance); // Shift
10827
10828                 // Animation
10829                 var animation = {};
10830                 animation[ref] = (mode == 'show' ? (motion == 'pos' ? '+=' : '-=') : (motion == 'pos' ? '-=' : '+=')) + distance;
10831
10832                 // Animate
10833                 el.animate(animation, { queue: false, duration: o.duration, easing: o.options.easing, complete: function() {
10834                         if(mode == 'hide') el.hide(); // Hide
10835                         $.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
10836                         if(o.callback) o.callback.apply(this, arguments); // Callback
10837                         el.dequeue();
10838                 }});
10839
10840         });
10841
10842 };
10843
10844 })(jQuery);
10845 /*
10846  * jQuery UI Effects Transfer 1.8
10847  *
10848  * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)
10849  * Dual licensed under the MIT (MIT-LICENSE.txt)
10850  * and GPL (GPL-LICENSE.txt) licenses.
10851  *
10852  * http://docs.jquery.com/UI/Effects/Transfer
10853  *
10854  * Depends:
10855  *      jquery.effects.core.js
10856  */
10857 (function($) {
10858
10859 $.effects.transfer = function(o) {
10860         return this.queue(function() {
10861                 var elem = $(this),
10862                         target = $(o.options.to),
10863                         endPosition = target.offset(),
10864                         animation = {
10865                                 top: endPosition.top,
10866                                 left: endPosition.left,
10867                                 height: target.innerHeight(),
10868                                 width: target.innerWidth()
10869                         },
10870                         startPosition = elem.offset(),
10871                         transfer = $('<div class="ui-effects-transfer"></div>')
10872                                 .appendTo(document.body)
10873                                 .addClass(o.options.className)
10874                                 .css({
10875                                         top: startPosition.top,
10876                                         left: startPosition.left,
10877                                         height: elem.innerHeight(),
10878                                         width: elem.innerWidth(),
10879                                         position: 'absolute'
10880                                 })
10881                                 .animate(animation, o.duration, o.options.easing, function() {
10882                                         transfer.remove();
10883                                         (o.callback && o.callback.apply(elem[0], arguments));
10884                                         elem.dequeue();
10885                                 });
10886         });
10887 };
10888
10889 })(jQuery);