source: admin/js/jquery/jquery-ui.custom.js @ 1048:a23c948b7ab2

/*! jQuery UI - v1.9.2 - 2012-11-29
* http://jqueryui.com
* Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.sortable.js, jquery.ui.accordion.js
* Copyright (c) 2012 jQuery Foundation and other contributors Licensed MIT */

(function( $, undefined ) {

var uuid = 0,
     runiqueId = /^ui-id-\d+$/;

// prevent duplicate loading
// this is only a problem because we proxy existing functions
// and we don't want to double proxy them
$.ui = $.ui || {};
if ( $.ui.version ) {
     return;
}

$.extend( $.ui, {
     version: "1.9.2",

     keyCode: {
          BACKSPACE: 8,
          COMMA: 188,
          DELETE: 46,
          DOWN: 40,
          END: 35,
          ENTER: 13,
          ESCAPE: 27,
          HOME: 36,
          LEFT: 37,
          NUMPAD_ADD: 107,
          NUMPAD_DECIMAL: 110,
          NUMPAD_DIVIDE: 111,
          NUMPAD_ENTER: 108,
          NUMPAD_MULTIPLY: 106,
          NUMPAD_SUBTRACT: 109,
          PAGE_DOWN: 34,
          PAGE_UP: 33,
          PERIOD: 190,
          RIGHT: 39,
          SPACE: 32,
          TAB: 9,
          UP: 38
     }
});

// plugins
$.fn.extend({
     _focus: $.fn.focus,
     focus: function( delay, fn ) {
          return typeof delay === "number" ?
               this.each(function() {
                    var elem = this;
                    setTimeout(function() {
                         $( elem ).focus();
                         if ( fn ) {
                              fn.call( elem );
                         }
                    }, delay );
               }) :
               this._focus.apply( this, arguments );
     },

     scrollParent: function() {
          var scrollParent;
          if (($.ui.ie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {
               scrollParent = this.parents().filter(function() {
                    return (/(relative|absolute|fixed)/).test($.css(this,'position')) && (/(auto|scroll)/).test($.css(this,'overflow')+$.css(this,'overflow-y')+$.css(this,'overflow-x'));
               }).eq(0);
          } else {
               scrollParent = this.parents().filter(function() {
                    return (/(auto|scroll)/).test($.css(this,'overflow')+$.css(this,'overflow-y')+$.css(this,'overflow-x'));
               }).eq(0);
          }

          return (/fixed/).test(this.css('position')) || !scrollParent.length ? $(document) : scrollParent;
     },

     zIndex: function( zIndex ) {
          if ( zIndex !== undefined ) {
               return this.css( "zIndex", zIndex );
          }

          if ( this.length ) {
               var elem = $( this[ 0 ] ), position, value;
               while ( elem.length && elem[ 0 ] !== document ) {
                    // Ignore z-index if position is set to a value where z-index is ignored by the browser
                    // This makes behavior of this function consistent across browsers
                    // WebKit always returns auto if the element is positioned
                    position = elem.css( "position" );
                    if ( position === "absolute" || position === "relative" || position === "fixed" ) {
                         // IE returns 0 when zIndex is not specified
                         // other browsers return a string
                         // we ignore the case of nested elements with an explicit value of 0
                         // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
                         value = parseInt( elem.css( "zIndex" ), 10 );
                         if ( !isNaN( value ) && value !== 0 ) {
                              return value;
                         }
                    }
                    elem = elem.parent();
               }
          }

          return 0;
     },

     uniqueId: function() {
          return this.each(function() {
               if ( !this.id ) {
                    this.id = "ui-id-" + (++uuid);
               }
          });
     },

     removeUniqueId: function() {
          return this.each(function() {
               if ( runiqueId.test( this.id ) ) {
                    $( this ).removeAttr( "id" );
               }
          });
     }
});

// selectors
function focusable( element, isTabIndexNotNaN ) {
     var map, mapName, img,
          nodeName = element.nodeName.toLowerCase();
     if ( "area" === nodeName ) {
          map = element.parentNode;
          mapName = map.name;
          if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
               return false;
          }
          img = $( "img[usemap=#" + mapName + "]" )[0];
          return !!img && visible( img );
     }
     return ( /input|select|textarea|button|object/.test( nodeName ) ?
          !element.disabled :
          "a" === nodeName ?
               element.href || isTabIndexNotNaN :
               isTabIndexNotNaN) &&
          // the element and all of its ancestors must be visible
          visible( element );
}

function visible( element ) {
     return $.expr.filters.visible( element ) &&
          !$( element ).parents().andSelf().filter(function() {
               return $.css( this, "visibility" ) === "hidden";
          }).length;
}

$.extend( $.expr[ ":" ], {
     data: $.expr.createPseudo ?
          $.expr.createPseudo(function( dataName ) {
               return function( elem ) {
                    return !!$.data( elem, dataName );
               };
          }) :
          // support: jQuery <1.8
          function( elem, i, match ) {
               return !!$.data( elem, match[ 3 ] );
          },

     focusable: function( element ) {
          return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
     },

     tabbable: function( element ) {
          var tabIndex = $.attr( element, "tabindex" ),
               isTabIndexNaN = isNaN( tabIndex );
          return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
     }
});

// support
$(function() {
     var body = document.body,
          div = body.appendChild( div = document.createElement( "div" ) );

     // access offsetHeight before setting the style to prevent a layout bug
     // in IE 9 which causes the element to continue to take up space even
     // after it is removed from the DOM (#8026)
     div.offsetHeight;

     $.extend( div.style, {
          minHeight: "100px",
          height: "auto",
          padding: 0,
          borderWidth: 0
     });

     $.support.minHeight = div.offsetHeight === 100;
     $.support.selectstart = "onselectstart" in div;

     // set display to none to avoid a layout bug in IE
     // http://dev.jquery.com/ticket/4014
     body.removeChild( div ).style.display = "none";
});

// support: jQuery <1.8
if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
     $.each( [ "Width", "Height" ], function( i, name ) {
          var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
               type = name.toLowerCase(),
               orig = {
                    innerWidth: $.fn.innerWidth,
                    innerHeight: $.fn.innerHeight,
                    outerWidth: $.fn.outerWidth,
                    outerHeight: $.fn.outerHeight
               };

          function reduce( elem, size, border, margin ) {
               $.each( side, function() {
                    size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
                    if ( border ) {
                         size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
                    }
                    if ( margin ) {
                         size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
                    }
               });
               return size;
          }

          $.fn[ "inner" + name ] = function( size ) {
               if ( size === undefined ) {
                    return orig[ "inner" + name ].call( this );
               }

               return this.each(function() {
                    $( this ).css( type, reduce( this, size ) + "px" );
               });
          };

          $.fn[ "outer" + name] = function( size, margin ) {
               if ( typeof size !== "number" ) {
                    return orig[ "outer" + name ].call( this, size );
               }

               return this.each(function() {
                    $( this).css( type, reduce( this, size, true, margin ) + "px" );
               });
          };
     });
}

// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
     $.fn.removeData = (function( removeData ) {
          return function( key ) {
               if ( arguments.length ) {
                    return removeData.call( this, $.camelCase( key ) );
               } else {
                    return removeData.call( this );
               }
          };
     })( $.fn.removeData );
}





// deprecated

(function() {
     var uaMatch = /msie ([\w.]+)/.exec( navigator.userAgent.toLowerCase() ) || [];
     $.ui.ie = uaMatch.length ? true : false;
     $.ui.ie6 = parseFloat( uaMatch[ 1 ], 10 ) === 6;
})();

$.fn.extend({
     disableSelection: function() {
          return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
               ".ui-disableSelection", function( event ) {
                    event.preventDefault();
               });
     },

     enableSelection: function() {
          return this.unbind( ".ui-disableSelection" );
     }
});

$.extend( $.ui, {
     // $.ui.plugin is deprecated.  Use the proxy pattern instead.
     plugin: {
          add: function( module, option, set ) {
               var i,
                    proto = $.ui[ module ].prototype;
               for ( i in set ) {
                    proto.plugins[ i ] = proto.plugins[ i ] || [];
                    proto.plugins[ i ].push( [ option, set[ i ] ] );
               }
          },
          call: function( instance, name, args ) {
               var i,
                    set = instance.plugins[ name ];
               if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
                    return;
               }

               for ( i = 0; i < set.length; i++ ) {
                    if ( instance.options[ set[ i ][ 0 ] ] ) {
                         set[ i ][ 1 ].apply( instance.element, args );
                    }
               }
          }
     },

     contains: $.contains,

     // only used by resizable
     hasScroll: function( el, a ) {

          //If overflow is hidden, the element might have extra content, but the user wants to hide it
          if ( $( el ).css( "overflow" ) === "hidden") {
               return false;
          }

          var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
               has = false;

          if ( el[ scroll ] > 0 ) {
               return true;
          }

          // TODO: determine which cases actually cause this to happen
          // if the element doesn't have the scroll set, see if it's possible to
          // set the scroll
          el[ scroll ] = 1;
          has = ( el[ scroll ] > 0 );
          el[ scroll ] = 0;
          return has;
     },

     // these are odd functions, fix the API or move into individual plugins
     isOverAxis: function( x, reference, size ) {
          //Determines when x coordinate is over "b" element axis
          return ( x > reference ) && ( x < ( reference + size ) );
     },
     isOver: function( y, x, top, left, height, width ) {
          //Determines when x, y coordinates is over "b" element
          return $.ui.isOverAxis( y, top, height ) && $.ui.isOverAxis( x, left, width );
     }
});

})( jQuery );
(function( $, undefined ) {

var uuid = 0,
     slice = Array.prototype.slice,
     _cleanData = $.cleanData;
$.cleanData = function( elems ) {
     for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
          try {
               $( elem ).triggerHandler( "remove" );
          // http://bugs.jquery.com/ticket/8235
          } catch( e ) {}
     }
     _cleanData( elems );
};

$.widget = function( name, base, prototype ) {
     var fullName, existingConstructor, constructor, basePrototype,
          namespace = name.split( "." )[ 0 ];

     name = name.split( "." )[ 1 ];
     fullName = namespace + "-" + name;

     if ( !prototype ) {
          prototype = base;
          base = $.Widget;
     }

     // create selector for plugin
     $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
          return !!$.data( elem, fullName );
     };

     $[ namespace ] = $[ namespace ] || {};
     existingConstructor = $[ namespace ][ name ];
     constructor = $[ namespace ][ name ] = function( options, element ) {
          // allow instantiation without "new" keyword
          if ( !this._createWidget ) {
               return new constructor( options, element );
          }

          // allow instantiation without initializing for simple inheritance
          // must use "new" keyword (the code above always passes args)
          if ( arguments.length ) {
               this._createWidget( options, element );
          }
     };
     // extend with the existing constructor to carry over any static properties
     $.extend( constructor, existingConstructor, {
          version: prototype.version,
          // copy the object used to create the prototype in case we need to
          // redefine the widget later
          _proto: $.extend( {}, prototype ),
          // track widgets that inherit from this widget in case this widget is
          // redefined after a widget inherits from it
          _childConstructors: []
     });

     basePrototype = new base();
     // we need to make the options hash a property directly on the new instance
     // otherwise we'll modify the options hash on the prototype that we're
     // inheriting from
     basePrototype.options = $.widget.extend( {}, basePrototype.options );
     $.each( prototype, function( prop, value ) {
          if ( $.isFunction( value ) ) {
               prototype[ prop ] = (function() {
                    var _super = function() {
                              return base.prototype[ prop ].apply( this, arguments );
                         },
                         _superApply = function( args ) {
                              return base.prototype[ prop ].apply( this, args );
                         };
                    return function() {
                         var __super = this._super,
                              __superApply = this._superApply,
                              returnValue;

                         this._super = _super;
                         this._superApply = _superApply;

                         returnValue = value.apply( this, arguments );

                         this._super = __super;
                         this._superApply = __superApply;

                         return returnValue;
                    };
               })();
          }
     });
     constructor.prototype = $.widget.extend( basePrototype, {
          // TODO: remove support for widgetEventPrefix
          // always use the name + a colon as the prefix, e.g., draggable:start
          // don't prefix for widgets that aren't DOM-based
          widgetEventPrefix: existingConstructor ? basePrototype.widgetEventPrefix : name
     }, prototype, {
          constructor: constructor,
          namespace: namespace,
          widgetName: name,
          // TODO remove widgetBaseClass, see #8155
          widgetBaseClass: fullName,
          widgetFullName: fullName
     });

     // If this widget is being redefined then we need to find all widgets that
     // are inheriting from it and redefine all of them so that they inherit from
     // the new version of this widget. We're essentially trying to replace one
     // level in the prototype chain.
     if ( existingConstructor ) {
          $.each( existingConstructor._childConstructors, function( i, child ) {
               var childPrototype = child.prototype;

               // redefine the child widget using the same prototype that was
               // originally used, but inherit from the new version of the base
               $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
          });
          // remove the list of existing child constructors from the old constructor
          // so the old child constructors can be garbage collected
          delete existingConstructor._childConstructors;
     } else {
          base._childConstructors.push( constructor );
     }

     $.widget.bridge( name, constructor );
};

$.widget.extend = function( target ) {
     var input = slice.call( arguments, 1 ),
          inputIndex = 0,
          inputLength = input.length,
          key,
          value;
     for ( ; inputIndex < inputLength; inputIndex++ ) {
          for ( key in input[ inputIndex ] ) {
               value = input[ inputIndex ][ key ];
               if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
                    // Clone objects
                    if ( $.isPlainObject( value ) ) {
                         target[ key ] = $.isPlainObject( target[ key ] ) ?
                              $.widget.extend( {}, target[ key ], value ) :
                              // Don't extend strings, arrays, etc. with objects
                              $.widget.extend( {}, value );
                    // Copy everything else by reference
                    } else {
                         target[ key ] = value;
                    }
               }
          }
     }
     return target;
};

$.widget.bridge = function( name, object ) {
     var fullName = object.prototype.widgetFullName || name;
     $.fn[ name ] = function( options ) {
          var isMethodCall = typeof options === "string",
               args = slice.call( arguments, 1 ),
               returnValue = this;

          // allow multiple hashes to be passed on init
          options = !isMethodCall && args.length ?
               $.widget.extend.apply( null, [ options ].concat(args) ) :
               options;

          if ( isMethodCall ) {
               this.each(function() {
                    var methodValue,
                         instance = $.data( this, fullName );
                    if ( !instance ) {
                         return $.error( "cannot call methods on " + name + " prior to initialization; " +
                              "attempted to call method '" + options + "'" );
                    }
                    if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
                         return $.error( "no such method '" + options + "' for " + name + " widget instance" );
                    }
                    methodValue = instance[ options ].apply( instance, args );
                    if ( methodValue !== instance && methodValue !== undefined ) {
                         returnValue = methodValue && methodValue.jquery ?
                              returnValue.pushStack( methodValue.get() ) :
                              methodValue;
                         return false;
                    }
               });
          } else {
               this.each(function() {
                    var instance = $.data( this, fullName );
                    if ( instance ) {
                         instance.option( options || {} )._init();
                    } else {
                         $.data( this, fullName, new object( options, this ) );
                    }
               });
          }

          return returnValue;
     };
};

$.Widget = function( /* options, element */ ) {};
$.Widget._childConstructors = [];

$.Widget.prototype = {
     widgetName: "widget",
     widgetEventPrefix: "",
     defaultElement: "<div>",
     options: {
          disabled: false,

          // callbacks
          create: null
     },
     _createWidget: function( options, element ) {
          element = $( element || this.defaultElement || this )[ 0 ];
          this.element = $( element );
          this.uuid = uuid++;
          this.eventNamespace = "." + this.widgetName + this.uuid;
          this.options = $.widget.extend( {},
               this.options,
               this._getCreateOptions(),
               options );

          this.bindings = $();
          this.hoverable = $();
          this.focusable = $();

          if ( element !== this ) {
               // 1.9 BC for #7810
               // TODO remove dual storage
               $.data( element, this.widgetName, this );
               $.data( element, this.widgetFullName, this );
               this._on( true, this.element, {
                    remove: function( event ) {
                         if ( event.target === element ) {
                              this.destroy();
                         }
                    }
               });
               this.document = $( element.style ?
                    // element within the document
                    element.ownerDocument :
                    // element is window or document
                    element.document || element );
               this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
          }

          this._create();
          this._trigger( "create", null, this._getCreateEventData() );
          this._init();
     },
     _getCreateOptions: $.noop,
     _getCreateEventData: $.noop,
     _create: $.noop,
     _init: $.noop,

     destroy: function() {
          this._destroy();
          // we can probably remove the unbind calls in 2.0
          // all event bindings should go through this._on()
          this.element
               .unbind( this.eventNamespace )
               // 1.9 BC for #7810
               // TODO remove dual storage
               .removeData( this.widgetName )
               .removeData( this.widgetFullName )
               // support: jquery <1.6.3
               // http://bugs.jquery.com/ticket/9413
               .removeData( $.camelCase( this.widgetFullName ) );
          this.widget()
               .unbind( this.eventNamespace )
               .removeAttr( "aria-disabled" )
               .removeClass(
                    this.widgetFullName + "-disabled " +
                    "ui-state-disabled" );

          // clean up events and states
          this.bindings.unbind( this.eventNamespace );
          this.hoverable.removeClass( "ui-state-hover" );
          this.focusable.removeClass( "ui-state-focus" );
     },
     _destroy: $.noop,

     widget: function() {
          return this.element;
     },

     option: function( key, value ) {
          var options = key,
               parts,
               curOption,
               i;

          if ( arguments.length === 0 ) {
               // don't return a reference to the internal hash
               return $.widget.extend( {}, this.options );
          }

          if ( typeof key === "string" ) {
               // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
               options = {};
               parts = key.split( "." );
               key = parts.shift();
               if ( parts.length ) {
                    curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
                    for ( i = 0; i < parts.length - 1; i++ ) {
                         curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
                         curOption = curOption[ parts[ i ] ];
                    }
                    key = parts.pop();
                    if ( value === undefined ) {
                         return curOption[ key ] === undefined ? null : curOption[ key ];
                    }
                    curOption[ key ] = value;
               } else {
                    if ( value === undefined ) {
                         return this.options[ key ] === undefined ? null : this.options[ key ];
                    }
                    options[ key ] = value;
               }
          }

          this._setOptions( options );

          return this;
     },
     _setOptions: function( options ) {
          var key;

          for ( key in options ) {
               this._setOption( key, options[ key ] );
          }

          return this;
     },
     _setOption: function( key, value ) {
          this.options[ key ] = value;

          if ( key === "disabled" ) {
               this.widget()
                    .toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
                    .attr( "aria-disabled", value );
               this.hoverable.removeClass( "ui-state-hover" );
               this.focusable.removeClass( "ui-state-focus" );
          }

          return this;
     },

     enable: function() {
          return this._setOption( "disabled", false );
     },
     disable: function() {
          return this._setOption( "disabled", true );
     },

     _on: function( suppressDisabledCheck, element, handlers ) {
          var delegateElement,
               instance = this;

          // no suppressDisabledCheck flag, shuffle arguments
          if ( typeof suppressDisabledCheck !== "boolean" ) {
               handlers = element;
               element = suppressDisabledCheck;
               suppressDisabledCheck = false;
          }

          // no element argument, shuffle and use this.element
          if ( !handlers ) {
               handlers = element;
               element = this.element;
               delegateElement = this.widget();
          } else {
               // accept selectors, DOM elements
               element = delegateElement = $( element );
               this.bindings = this.bindings.add( element );
          }

          $.each( handlers, function( event, handler ) {
               function handlerProxy() {
                    // allow widgets to customize the disabled handling
                    // - disabled as an array instead of boolean
                    // - disabled class as method for disabling individual parts
                    if ( !suppressDisabledCheck &&
                              ( instance.options.disabled === true ||
                                   $( this ).hasClass( "ui-state-disabled" ) ) ) {
                         return;
                    }
                    return ( typeof handler === "string" ? instance[ handler ] : handler )
                         .apply( instance, arguments );
               }

               // copy the guid so direct unbinding works
               if ( typeof handler !== "string" ) {
                    handlerProxy.guid = handler.guid =
                         handler.guid || handlerProxy.guid || $.guid++;
               }

               var match = event.match( /^(\w+)\s*(.*)$/ ),
                    eventName = match[1] + instance.eventNamespace,
                    selector = match[2];
               if ( selector ) {
                    delegateElement.delegate( selector, eventName, handlerProxy );
               } else {
                    element.bind( eventName, handlerProxy );
               }
          });
     },

     _off: function( element, eventName ) {
          eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
          element.unbind( eventName ).undelegate( eventName );
     },

     _delay: function( handler, delay ) {
          function handlerProxy() {
               return ( typeof handler === "string" ? instance[ handler ] : handler )
                    .apply( instance, arguments );
          }
          var instance = this;
          return setTimeout( handlerProxy, delay || 0 );
     },

     _hoverable: function( element ) {
          this.hoverable = this.hoverable.add( element );
          this._on( element, {
               mouseenter: function( event ) {
                    $( event.currentTarget ).addClass( "ui-state-hover" );
               },
               mouseleave: function( event ) {
                    $( event.currentTarget ).removeClass( "ui-state-hover" );
               }
          });
     },

     _focusable: function( element ) {
          this.focusable = this.focusable.add( element );
          this._on( element, {
               focusin: function( event ) {
                    $( event.currentTarget ).addClass( "ui-state-focus" );
               },
               focusout: function( event ) {
                    $( event.currentTarget ).removeClass( "ui-state-focus" );
               }
          });
     },

     _trigger: function( type, event, data ) {
          var prop, orig,
               callback = this.options[ type ];

          data = data || {};
          event = $.Event( event );
          event.type = ( type === this.widgetEventPrefix ?
               type :
               this.widgetEventPrefix + type ).toLowerCase();
          // the original event may come from any element
          // so we need to reset the target on the new event
          event.target = this.element[ 0 ];

          // copy original event properties over to the new event
          orig = event.originalEvent;
          if ( orig ) {
               for ( prop in orig ) {
                    if ( !( prop in event ) ) {
                         event[ prop ] = orig[ prop ];
                    }
               }
          }

          this.element.trigger( event, data );
          return !( $.isFunction( callback ) &&
               callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
               event.isDefaultPrevented() );
     }
};

$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
     $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
          if ( typeof options === "string" ) {
               options = { effect: options };
          }
          var hasOptions,
               effectName = !options ?
                    method :
                    options === true || typeof options === "number" ?
                         defaultEffect :
                         options.effect || defaultEffect;
          options = options || {};
          if ( typeof options === "number" ) {
               options = { duration: options };
          }
          hasOptions = !$.isEmptyObject( options );
          options.complete = callback;
          if ( options.delay ) {
               element.delay( options.delay );
          }
          if ( hasOptions && $.effects && ( $.effects.effect[ effectName ] || $.uiBackCompat !== false && $.effects[ effectName ] ) ) {
               element[ method ]( options );
          } else if ( effectName !== method && element[ effectName ] ) {
               element[ effectName ]( options.duration, options.easing, callback );
          } else {
               element.queue(function( next ) {
                    $( this )[ method ]();
                    if ( callback ) {
                         callback.call( element[ 0 ] );
                    }
                    next();
               });
          }
     };
});

// DEPRECATED
if ( $.uiBackCompat !== false ) {
     $.Widget.prototype._getCreateOptions = function() {
          return $.metadata && $.metadata.get( this.element[0] )[ this.widgetName ];
     };
}

})( jQuery );
(function( $, undefined ) {

var mouseHandled = false;
$( document ).mouseup( function( e ) {
     mouseHandled = false;
});

$.widget("ui.mouse", {
     version: "1.9.2",
     options: {
          cancel: 'input,textarea,button,select,option',
          distance: 1,
          delay: 0
     },
     _mouseInit: function() {
          var that = this;

          this.element
               .bind('mousedown.'+this.widgetName, function(event) {
                    return that._mouseDown(event);
               })
               .bind('click.'+this.widgetName, function(event) {
                    if (true === $.data(event.target, that.widgetName + '.preventClickEvent')) {
                         $.removeData(event.target, that.widgetName + '.preventClickEvent');
                         event.stopImmediatePropagation();
                         return false;
                    }
               });

          this.started = false;
     },

     // TODO: make sure destroying one instance of mouse doesn't mess with
     // other instances of mouse
     _mouseDestroy: function() {
          this.element.unbind('.'+this.widgetName);
          if ( this._mouseMoveDelegate ) {
               $(document)
                    .unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
                    .unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);
          }
     },

     _mouseDown: function(event) {
          // don't let more than one widget handle mouseStart
          if( mouseHandled ) { return; }

          // we may have missed mouseup (out of window)
          (this._mouseStarted && this._mouseUp(event));

          this._mouseDownEvent = event;

          var that = this,
               btnIsLeft = (event.which === 1),
               // event.target.nodeName works around a bug in IE 8 with
               // disabled inputs (#7620)
               elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
          if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
               return true;
          }

          this.mouseDelayMet = !this.options.delay;
          if (!this.mouseDelayMet) {
               this._mouseDelayTimer = setTimeout(function() {
                    that.mouseDelayMet = true;
               }, this.options.delay);
          }

          if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
               this._mouseStarted = (this._mouseStart(event) !== false);
               if (!this._mouseStarted) {
                    event.preventDefault();
                    return true;
               }
          }

          // Click event may never have fired (Gecko & Opera)
          if (true === $.data(event.target, this.widgetName + '.preventClickEvent')) {
               $.removeData(event.target, this.widgetName + '.preventClickEvent');
          }

          // these delegates are required to keep context
          this._mouseMoveDelegate = function(event) {
               return that._mouseMove(event);
          };
          this._mouseUpDelegate = function(event) {
               return that._mouseUp(event);
          };
          $(document)
               .bind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
               .bind('mouseup.'+this.widgetName, this._mouseUpDelegate);

          event.preventDefault();

          mouseHandled = true;
          return true;
     },

     _mouseMove: function(event) {
          // IE mouseup check - mouseup happened when mouse was out of window
          if ($.ui.ie && !(document.documentMode >= 9) && !event.button) {
               return this._mouseUp(event);
          }

          if (this._mouseStarted) {
               this._mouseDrag(event);
               return event.preventDefault();
          }

          if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
               this._mouseStarted =
                    (this._mouseStart(this._mouseDownEvent, event) !== false);
               (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
          }

          return !this._mouseStarted;
     },

     _mouseUp: function(event) {
          $(document)
               .unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
               .unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);

          if (this._mouseStarted) {
               this._mouseStarted = false;

               if (event.target === this._mouseDownEvent.target) {
                    $.data(event.target, this.widgetName + '.preventClickEvent', true);
               }

               this._mouseStop(event);
          }

          return false;
     },

     _mouseDistanceMet: function(event) {
          return (Math.max(
                    Math.abs(this._mouseDownEvent.pageX - event.pageX),
                    Math.abs(this._mouseDownEvent.pageY - event.pageY)
               ) >= this.options.distance
          );
     },

     _mouseDelayMet: function(event) {
          return this.mouseDelayMet;
     },

     // These are placeholder methods, to be overriden by extending plugin
     _mouseStart: function(event) {},
     _mouseDrag: function(event) {},
     _mouseStop: function(event) {},
     _mouseCapture: function(event) { return true; }
});

})(jQuery);
(function( $, undefined ) {

$.widget("ui.sortable", $.ui.mouse, {
     version: "1.9.2",
     widgetEventPrefix: "sort",
     ready: false,
     options: {
          appendTo: "parent",
          axis: false,
          connectWith: false,
          containment: false,
          cursor: 'auto',
          cursorAt: false,
          dropOnEmpty: true,
          forcePlaceholderSize: false,
          forceHelperSize: false,
          grid: false,
          handle: false,
          helper: "original",
          items: '> *',
          opacity: false,
          placeholder: false,
          revert: false,
          scroll: true,
          scrollSensitivity: 20,
          scrollSpeed: 20,
          scope: "default",
          tolerance: "intersect",
          zIndex: 1000
     },
     _create: function() {

          var o = this.options;
          this.containerCache = {};
          this.element.addClass("ui-sortable");

          //Get the items
          this.refresh();

          //Let's determine if the items are being displayed horizontally
          this.floating = this.items.length ? o.axis === 'x' || (/left|right/).test(this.items[0].item.css('float')) || (/inline|table-cell/).test(this.items[0].item.css('display')) : false;

          //Let's determine the parent's offset
          this.offset = this.element.offset();

          //Initialize mouse events for interaction
          this._mouseInit();

          //We're ready to go
          this.ready = true

     },

     _destroy: function() {
          this.element
               .removeClass("ui-sortable ui-sortable-disabled");
          this._mouseDestroy();

          for ( var i = this.items.length - 1; i >= 0; i-- )
               this.items[i].item.removeData(this.widgetName + "-item");

          return this;
     },

     _setOption: function(key, value){
          if ( key === "disabled" ) {
               this.options[ key ] = value;

               this.widget().toggleClass( "ui-sortable-disabled", !!value );
          } else {
               // Don't call widget base _setOption for disable as it adds ui-state-disabled class
               $.Widget.prototype._setOption.apply(this, arguments);
          }
     },

     _mouseCapture: function(event, overrideHandle) {
          var that = this;

          if (this.reverting) {
               return false;
          }

          if(this.options.disabled || this.options.type == 'static') return false;

          //We have to refresh the items data once first
          this._refreshItems(event);

          //Find out if the clicked node (or one of its parents) is a actual item in this.items
          var currentItem = null, nodes = $(event.target).parents().each(function() {
               if($.data(this, that.widgetName + '-item') == that) {
                    currentItem = $(this);
                    return false;
               }
          });
          if($.data(event.target, that.widgetName + '-item') == that) currentItem = $(event.target);

          if(!currentItem) return false;
          if(this.options.handle && !overrideHandle) {
               var validHandle = false;

               $(this.options.handle, currentItem).find("*").andSelf().each(function() { if(this == event.target) validHandle = true; });
               if(!validHandle) return false;
          }

          this.currentItem = currentItem;
          this._removeCurrentsFromItems();
          return true;

     },

     _mouseStart: function(event, overrideHandle, noActivation) {

          var o = this.options;
          this.currentContainer = this;

          //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
          this.refreshPositions();

          //Create and append the visible helper
          this.helper = this._createHelper(event);

          //Cache the helper size
          this._cacheHelperProportions();

          /*
           * - Position generation -
           * This block generates everything position related - it's the core of draggables.
           */

          //Cache the margins of the original element
          this._cacheMargins();

          //Get the next scrolling parent
          this.scrollParent = this.helper.scrollParent();

          //The element's absolute position on the page minus margins
          this.offset = this.currentItem.offset();
          this.offset = {
               top: this.offset.top - this.margins.top,
               left: this.offset.left - this.margins.left
          };

          $.extend(this.offset, {
               click: { //Where the click happened, relative to the element
                    left: event.pageX - this.offset.left,
                    top: event.pageY - this.offset.top
               },
               parent: this._getParentOffset(),
               relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
          });

          // Only after we got the offset, we can change the helper's position to absolute
          // TODO: Still need to figure out a way to make relative sorting possible
          this.helper.css("position", "absolute");
          this.cssPosition = this.helper.css("position");

          //Generate the original position
          this.originalPosition = this._generatePosition(event);
          this.originalPageX = event.pageX;
          this.originalPageY = event.pageY;

          //Adjust the mouse offset relative to the helper if 'cursorAt' is supplied
          (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));

          //Cache the former DOM position
          this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };

          //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
          if(this.helper[0] != this.currentItem[0]) {
               this.currentItem.hide();
          }

          //Create the placeholder
          this._createPlaceholder();

          //Set a containment if given in the options
          if(o.containment)
               this._setContainment();

          if(o.cursor) { // cursor option
               if ($('body').css("cursor")) this._storedCursor = $('body').css("cursor");
               $('body').css("cursor", o.cursor);
          }

          if(o.opacity) { // opacity option
               if (this.helper.css("opacity")) this._storedOpacity = this.helper.css("opacity");
               this.helper.css("opacity", o.opacity);
          }

          if(o.zIndex) { // zIndex option
               if (this.helper.css("zIndex")) this._storedZIndex = this.helper.css("zIndex");
               this.helper.css("zIndex", o.zIndex);
          }

          //Prepare scrolling
          if(this.scrollParent[0] != document && this.scrollParent[0].tagName != 'HTML')
               this.overflowOffset = this.scrollParent.offset();

          //Call callbacks
          this._trigger("start", event, this._uiHash());

          //Recache the helper size
          if(!this._preserveHelperProportions)
               this._cacheHelperProportions();


          //Post 'activate' events to possible containers
          if(!noActivation) {
                for (var i = this.containers.length - 1; i >= 0; i--) { this.containers[i]._trigger("activate", event, this._uiHash(this)); }
          }

          //Prepare possible droppables
          if($.ui.ddmanager)
               $.ui.ddmanager.current = this;

          if ($.ui.ddmanager && !o.dropBehaviour)
               $.ui.ddmanager.prepareOffsets(this, event);

          this.dragging = true;

          this.helper.addClass("ui-sortable-helper");
          this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
          return true;

     },

     _mouseDrag: function(event) {

          //Compute the helpers position
          this.position = this._generatePosition(event);
          this.positionAbs = this._convertPositionTo("absolute");

          if (!this.lastPositionAbs) {
               this.lastPositionAbs = this.positionAbs;
          }

          //Do scrolling
          if(this.options.scroll) {
               var o = this.options, scrolled = false;
               if(this.scrollParent[0] != document && this.scrollParent[0].tagName != 'HTML') {

                    if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity)
                         this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
                    else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity)
                         this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;

                    if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity)
                         this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
                    else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity)
                         this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;

               } else {

                    if(event.pageY - $(document).scrollTop() < o.scrollSensitivity)
                         scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
                    else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity)
                         scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);

                    if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity)
                         scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
                    else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
                         scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);

               }

               if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour)
                    $.ui.ddmanager.prepareOffsets(this, event);
          }

          //Regenerate the absolute position used for position checks
          this.positionAbs = this._convertPositionTo("absolute");

          //Set the helper position
          if(!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left+'px';
          if(!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top+'px';

          //Rearrange
          for (var i = this.items.length - 1; i >= 0; i--) {

               //Cache variables and intersection, continue if no intersection
               var item = this.items[i], itemElement = item.item[0], intersection = this._intersectsWithPointer(item);
               if (!intersection) continue;

               // Only put the placeholder inside the current Container, skip all
               // items form other containers. This works because when moving
               // an item from one container to another the
               // currentContainer is switched before the placeholder is moved.
               //
               // Without this moving items in "sub-sortables" can cause the placeholder to jitter
               // beetween the outer and inner container.
               if (item.instance !== this.currentContainer) continue;

               if (itemElement != this.currentItem[0] //cannot intersect with itself
                    &&   this.placeholder[intersection == 1 ? "next" : "prev"]()[0] != itemElement //no useless actions that have been done before
                    &&   !$.contains(this.placeholder[0], itemElement) //no action if the item moved is the parent of the item checked
                    && (this.options.type == 'semi-dynamic' ? !$.contains(this.element[0], itemElement) : true)
                    //&& itemElement.parentNode == this.placeholder[0].parentNode // only rearrange items within the same container
               ) {

                    this.direction = intersection == 1 ? "down" : "up";

                    if (this.options.tolerance == "pointer" || this._intersectsWithSides(item)) {
                         this._rearrange(event, item);
                    } else {
                         break;
                    }

                    this._trigger("change", event, this._uiHash());
                    break;
               }
          }

          //Post events to containers
          this._contactContainers(event);

          //Interconnect with droppables
          if($.ui.ddmanager) $.ui.ddmanager.drag(this, event);

          //Call callbacks
          this._trigger('sort', event, this._uiHash());

          this.lastPositionAbs = this.positionAbs;
          return false;

     },

     _mouseStop: function(event, noPropagation) {

          if(!event) return;

          //If we are using droppables, inform the manager about the drop
          if ($.ui.ddmanager && !this.options.dropBehaviour)
               $.ui.ddmanager.drop(this, event);

          if(this.options.revert) {
               var that = this;
               var cur = this.placeholder.offset();

               this.reverting = true;

               $(this.helper).animate({
                    left: cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollLeft),
                    top: cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollTop)
               }, parseInt(this.options.revert, 10) || 500, function() {
                    that._clear(event);
               });
          } else {
               this._clear(event, noPropagation);
          }

          return false;

     },

     cancel: function() {

          if(this.dragging) {

               this._mouseUp({ target: null });

               if(this.options.helper == "original")
                    this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
               else
                    this.currentItem.show();

               //Post deactivating events to containers
               for (var i = this.containers.length - 1; i >= 0; i--){
                    this.containers[i]._trigger("deactivate", null, this._uiHash(this));
                    if(this.containers[i].containerCache.over) {
                         this.containers[i]._trigger("out", null, this._uiHash(this));
                         this.containers[i].containerCache.over = 0;
                    }
               }

          }

          if (this.placeholder) {
               //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
               if(this.placeholder[0].parentNode) this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
               if(this.options.helper != "original" && this.helper && this.helper[0].parentNode) this.helper.remove();

               $.extend(this, {
                    helper: null,
                    dragging: false,
                    reverting: false,
                    _noFinalSort: null
               });

               if(this.domPosition.prev) {
                    $(this.domPosition.prev).after(this.currentItem);
               } else {
                    $(this.domPosition.parent).prepend(this.currentItem);
               }
          }

          return this;

     },

     serialize: function(o) {

          var items = this._getItemsAsjQuery(o && o.connected);
          var str = []; o = o || {};

          $(items).each(function() {
               var res = ($(o.item || this).attr(o.attribute || 'id') || '').match(o.expression || (/(.+)[-=_](.+)/));
               if(res) str.push((o.key || res[1]+'[]')+'='+(o.key && o.expression ? res[1] : res[2]));
          });

          if(!str.length && o.key) {
               str.push(o.key + '=');
          }

          return str.join('&');

     },

     toArray: function(o) {

          var items = this._getItemsAsjQuery(o && o.connected);
          var ret = []; o = o || {};

          items.each(function() { ret.push($(o.item || this).attr(o.attribute || 'id') || ''); });
          return ret;

     },

     /* Be careful with the following core functions */
     _intersectsWith: function(item) {

          var x1 = this.positionAbs.left,
               x2 = x1 + this.helperProportions.width,
               y1 = this.positionAbs.top,
               y2 = y1 + this.helperProportions.height;

          var l = item.left,
               r = l + item.width,
               t = item.top,
               b = t + item.height;

          var dyClick = this.offset.click.top,
               dxClick = this.offset.click.left;

          var isOverElement = (y1 + dyClick) > t && (y1 + dyClick) < b && (x1 + dxClick) > l && (x1 + dxClick) < r;

          if(     this.options.tolerance == "pointer"
               || this.options.forcePointerForContainers
               || (this.options.tolerance != "pointer" && this.helperProportions[this.floating ? 'width' : 'height'] > item[this.floating ? 'width' : 'height'])
          ) {
               return isOverElement;
          } else {

               return (l < x1 + (this.helperProportions.width / 2) // Right Half
                    && x2 - (this.helperProportions.width / 2) < r // Left Half
                    && t < y1 + (this.helperProportions.height / 2) // Bottom Half
                    && y2 - (this.helperProportions.height / 2) < b ); // Top Half

          }
     },

     _intersectsWithPointer: function(item) {

          var isOverElementHeight = (this.options.axis === 'x') || $.ui.isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
               isOverElementWidth = (this.options.axis === 'y') || $.ui.isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
               isOverElement = isOverElementHeight && isOverElementWidth,
               verticalDirection = this._getDragVerticalDirection(),
               horizontalDirection = this._getDragHorizontalDirection();

          if (!isOverElement)
               return false;

          return this.floating ?
               ( ((horizontalDirection && horizontalDirection == "right") || verticalDirection == "down") ? 2 : 1 )
               : ( verticalDirection && (verticalDirection == "down" ? 2 : 1) );

     },

     _intersectsWithSides: function(item) {

          var isOverBottomHalf = $.ui.isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
               isOverRightHalf = $.ui.isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
               verticalDirection = this._getDragVerticalDirection(),
               horizontalDirection = this._getDragHorizontalDirection();

          if (this.floating && horizontalDirection) {
               return ((horizontalDirection == "right" && isOverRightHalf) || (horizontalDirection == "left" && !isOverRightHalf));
          } else {
               return verticalDirection && ((verticalDirection == "down" && isOverBottomHalf) || (verticalDirection == "up" && !isOverBottomHalf));
          }

     },

     _getDragVerticalDirection: function() {
          var delta = this.positionAbs.top - this.lastPositionAbs.top;
          return delta != 0 && (delta > 0 ? "down" : "up");
     },

     _getDragHorizontalDirection: function() {
          var delta = this.positionAbs.left - this.lastPositionAbs.left;
          return delta != 0 && (delta > 0 ? "right" : "left");
     },

     refresh: function(event) {
          this._refreshItems(event);
          this.refreshPositions();
          return this;
     },

     _connectWith: function() {
          var options = this.options;
          return options.connectWith.constructor == String
               ? [options.connectWith]
               : options.connectWith;
     },

     _getItemsAsjQuery: function(connected) {

          var items = [];
          var queries = [];
          var connectWith = this._connectWith();

          if(connectWith && connected) {
               for (var i = connectWith.length - 1; i >= 0; i--){
                    var cur = $(connectWith[i]);
                    for (var j = cur.length - 1; j >= 0; j--){
                         var inst = $.data(cur[j], this.widgetName);
                         if(inst && inst != this && !inst.options.disabled) {
                              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]);
                         }
                    };
               };
          }

          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]);

          for (var i = queries.length - 1; i >= 0; i--){
               queries[i][0].each(function() {
                    items.push(this);
               });
          };

          return $(items);

     },

     _removeCurrentsFromItems: function() {

          var list = this.currentItem.find(":data(" + this.widgetName + "-item)");

          this.items = $.grep(this.items, function (item) {
               for (var j=0; j < list.length; j++) {
                    if(list[j] == item.item[0])
                         return false;
               };
               return true;
          });

     },

     _refreshItems: function(event) {

          this.items = [];
          this.containers = [this];
          var items = this.items;
          var queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]];
          var connectWith = this._connectWith();

          if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
               for (var i = connectWith.length - 1; i >= 0; i--){
                    var cur = $(connectWith[i]);
                    for (var j = cur.length - 1; j >= 0; j--){
                         var inst = $.data(cur[j], this.widgetName);
                         if(inst && inst != this && !inst.options.disabled) {
                              queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
                              this.containers.push(inst);
                         }
                    };
               };
          }

          for (var i = queries.length - 1; i >= 0; i--) {
               var targetData = queries[i][1];
               var _queries = queries[i][0];

               for (var j=0, queriesLength = _queries.length; j < queriesLength; j++) {
                    var item = $(_queries[j]);

                    item.data(this.widgetName + '-item', targetData); // Data for target checking (mouse manager)

                    items.push({
                         item: item,
                         instance: targetData,
                         width: 0, height: 0,
                         left: 0, top: 0
                    });
               };
          };

     },

     refreshPositions: function(fast) {

          //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
          if(this.offsetParent && this.helper) {
               this.offset.parent = this._getParentOffset();
          }

          for (var i = this.items.length - 1; i >= 0; i--){
               var item = this.items[i];

               //We ignore calculating positions of all connected containers when we're not over them
               if(item.instance != this.currentContainer && this.currentContainer && item.item[0] != this.currentItem[0])
                    continue;

               var t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;

               if (!fast) {
                    item.width = t.outerWidth();
                    item.height = t.outerHeight();
               }

               var p = t.offset();
               item.left = p.left;
               item.top = p.top;
          };

          if(this.options.custom && this.options.custom.refreshContainers) {
               this.options.custom.refreshContainers.call(this);
          } else {
               for (var i = this.containers.length - 1; i >= 0; i--){
                    var p = this.containers[i].element.offset();
                    this.containers[i].containerCache.left = p.left;
                    this.containers[i].containerCache.top = p.top;
                    this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
                    this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
               };
          }

          return this;
     },

     _createPlaceholder: function(that) {
          that = that || this;
          var o = that.options;

          if(!o.placeholder || o.placeholder.constructor == String) {
               var className = o.placeholder;
               o.placeholder = {
                    element: function() {

                         var el = $(document.createElement(that.currentItem[0].nodeName))
                              .addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
                              .removeClass("ui-sortable-helper")[0];

                         if(!className)
                              el.style.visibility = "hidden";

                         return el;
                    },
                    update: function(container, p) {

                         // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
                         // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
                         if(className && !o.forcePlaceholderSize) return;

                         //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
                         if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css('paddingTop')||0, 10) - parseInt(that.currentItem.css('paddingBottom')||0, 10)); };
                         if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css('paddingLeft')||0, 10) - parseInt(that.currentItem.css('paddingRight')||0, 10)); };
                    }
               };
          }

          //Create the placeholder
          that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));

          //Append it after the actual current item
          that.currentItem.after(that.placeholder);

          //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
          o.placeholder.update(that, that.placeholder);

     },

     _contactContainers: function(event) {

          // get innermost container that intersects with item
          var innermostContainer = null, innermostIndex = null;


          for (var i = this.containers.length - 1; i >= 0; i--){

               // never consider a container that's located within the item itself
               if($.contains(this.currentItem[0], this.containers[i].element[0]))
                    continue;

               if(this._intersectsWith(this.containers[i].containerCache)) {

                    // if we've already found a container and it's more "inner" than this, then continue
                    if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0]))
                         continue;

                    innermostContainer = this.containers[i];
                    innermostIndex = i;

               } else {
                    // container doesn't intersect. trigger "out" event if necessary
                    if(this.containers[i].containerCache.over) {
                         this.containers[i]._trigger("out", event, this._uiHash(this));
                         this.containers[i].containerCache.over = 0;
                    }
               }

          }

          // if no intersecting containers found, return
          if(!innermostContainer) return;

          // move the item into the container if it's not there already
          if(this.containers.length === 1) {
               this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
               this.containers[innermostIndex].containerCache.over = 1;
          } else {

               //When entering a new container, we will find the item with the least distance and append our item near it
               var dist = 10000; var itemWithLeastDistance = null;
               var posProperty = this.containers[innermostIndex].floating ? 'left' : 'top';
               var sizeProperty = this.containers[innermostIndex].floating ? 'width' : 'height';
               var base = this.positionAbs[posProperty] + this.offset.click[posProperty];
               for (var j = this.items.length - 1; j >= 0; j--) {
                    if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) continue;
                    if(this.items[j].item[0] == this.currentItem[0]) continue;
                    var cur = this.items[j].item.offset()[posProperty];
                    var nearBottom = false;
                    if(Math.abs(cur - base) > Math.abs(cur + this.items[j][sizeProperty] - base)){
                         nearBottom = true;
                         cur += this.items[j][sizeProperty];
                    }

                    if(Math.abs(cur - base) < dist) {
                         dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
                         this.direction = nearBottom ? "up": "down";
                    }
               }

               if(!itemWithLeastDistance && !this.options.dropOnEmpty) //Check if dropOnEmpty is enabled
                    return;

               this.currentContainer = this.containers[innermostIndex];
               itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
               this._trigger("change", event, this._uiHash());
               this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));

               //Update the placeholder
               this.options.placeholder.update(this.currentContainer, this.placeholder);

               this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
               this.containers[innermostIndex].containerCache.over = 1;
          }


     },

     _createHelper: function(event) {

          var o = this.options;
          var helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper == 'clone' ? this.currentItem.clone() : this.currentItem);

          if(!helper.parents('body').length) //Add the helper to the DOM if that didn't happen already
               $(o.appendTo != 'parent' ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);

          if(helper[0] == this.currentItem[0])
               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") };

          if(helper[0].style.width == '' || o.forceHelperSize) helper.width(this.currentItem.width());
          if(helper[0].style.height == '' || o.forceHelperSize) helper.height(this.currentItem.height());

          return helper;

     },

     _adjustOffsetFromHelper: function(obj) {
          if (typeof obj == 'string') {
               obj = obj.split(' ');
          }
          if ($.isArray(obj)) {
               obj = {left: +obj[0], top: +obj[1] || 0};
          }
          if ('left' in obj) {
               this.offset.click.left = obj.left + this.margins.left;
          }
          if ('right' in obj) {
               this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
          }
          if ('top' in obj) {
               this.offset.click.top = obj.top + this.margins.top;
          }
          if ('bottom' in obj) {
               this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
          }
     },

     _getParentOffset: function() {


          //Get the offsetParent and cache its position
          this.offsetParent = this.helper.offsetParent();
          var po = this.offsetParent.offset();

          // This is a special case where we need to modify a offset calculated on start, since the following happened:
          // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
          // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
          //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
          if(this.cssPosition == 'absolute' && this.scrollParent[0] != document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
               po.left += this.scrollParent.scrollLeft();
               po.top += this.scrollParent.scrollTop();
          }

          if((this.offsetParent[0] == document.body) //This needs to be actually done for all browsers, since pageX/pageY includes this information
          || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.ui.ie)) //Ugly IE fix
               po = { top: 0, left: 0 };

          return {
               top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
               left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
          };

     },

     _getRelativeOffset: function() {

          if(this.cssPosition == "relative") {
               var p = this.currentItem.position();
               return {
                    top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
                    left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
               };
          } else {
               return { top: 0, left: 0 };
          }

     },

     _cacheMargins: function() {
          this.margins = {
               left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
               top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
          };
     },

     _cacheHelperProportions: function() {
          this.helperProportions = {
               width: this.helper.outerWidth(),
               height: this.helper.outerHeight()
          };
     },

     _setContainment: function() {

          var o = this.options;
          if(o.containment == 'parent') o.containment = this.helper[0].parentNode;
          if(o.containment == 'document' || o.containment == 'window') this.containment = [
               0 - this.offset.relative.left - this.offset.parent.left,
               0 - this.offset.relative.top - this.offset.parent.top,
               $(o.containment == 'document' ? document : window).width() - this.helperProportions.width - this.margins.left,
               ($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
          ];

          if(!(/^(document|window|parent)$/).test(o.containment)) {
               var ce = $(o.containment)[0];
               var co = $(o.containment).offset();
               var over = ($(ce).css("overflow") != 'hidden');

               this.containment = [
                    co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
                    co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
                    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,
                    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
               ];
          }

     },

     _convertPositionTo: function(d, pos) {

          if(!pos) pos = this.position;
          var mod = d == "absolute" ? 1 : -1;
          var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);

          return {
               top: (
                    pos.top                                                                                   // The absolute mouse position
                    + this.offset.relative.top * mod                                                // Only for relative positioned nodes: Relative offset from element to offset parent
                    + this.offset.parent.top * mod                                                       // The offsetParent's offset without borders (offset + border)
                    - ( ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
               ),
               left: (
                    pos.left                                                                             // The absolute mouse position
                    + this.offset.relative.left * mod                                               // Only for relative positioned nodes: Relative offset from element to offset parent
                    + this.offset.parent.left * mod                                                      // The offsetParent's offset without borders (offset + border)
                    - ( ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
               )
          };

     },

     _generatePosition: function(event) {

          var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);

          // This is another very weird special case that only happens for relative elements:
          // 1. If the css position is relative
          // 2. and the scroll parent is the document or similar to the offset parent
          // we have to refresh the relative offset during the scroll so there are no jumps
          if(this.cssPosition == 'relative' && !(this.scrollParent[0] != document && this.scrollParent[0] != this.offsetParent[0])) {
               this.offset.relative = this._getRelativeOffset();
          }

          var pageX = event.pageX;
          var pageY = event.pageY;

          /*
           * - Position constraining -
           * Constrain the position to a mix of grid, containment.
           */

          if(this.originalPosition) { //If we are not dragging yet, we won't check for options

               if(this.containment) {
                    if(event.pageX - this.offset.click.left < this.containment[0]) pageX = this.containment[0] + this.offset.click.left;
                    if(event.pageY - this.offset.click.top < this.containment[1]) pageY = this.containment[1] + this.offset.click.top;
                    if(event.pageX - this.offset.click.left > this.containment[2]) pageX = this.containment[2] + this.offset.click.left;
                    if(event.pageY - this.offset.click.top > this.containment[3]) pageY = this.containment[3] + this.offset.click.top;
               }

               if(o.grid) {
                    var top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
                    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;

                    var left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
                    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;
               }

          }

          return {
               top: (
                    pageY                                                                                // The absolute mouse position
                    - this.offset.click.top                                                              // Click offset (relative to the element)
                    - this.offset.relative.top                                                           // Only for relative positioned nodes: Relative offset from element to offset parent
                    - this.offset.parent.top                                                        // The offsetParent's offset without borders (offset + border)
                    + ( ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
               ),
               left: (
                    pageX                                                                                // The absolute mouse position
                    - this.offset.click.left                                                        // Click offset (relative to the element)
                    - this.offset.relative.left                                                          // Only for relative positioned nodes: Relative offset from element to offset parent
                    - this.offset.parent.left                                                            // The offsetParent's offset without borders (offset + border)
                    + ( ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
               )
          };

     },

     _rearrange: function(event, i, a, hardRefresh) {

          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));

          //Various things done here to improve the performance:
          // 1. we create a setTimeout, that calls refreshPositions
          // 2. on the instance, we have a counter variable, that get's higher after every append
          // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
          // 4. this lets only the last addition to the timeout stack through
          this.counter = this.counter ? ++this.counter : 1;
          var counter = this.counter;

          this._delay(function() {
               if(counter == this.counter) this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
          });

     },

     _clear: function(event, noPropagation) {

          this.reverting = false;
          // We delay all events that have to be triggered to after the point where the placeholder has been removed and
          // everything else normalized again
          var delayedTriggers = [];

          // We first have to update the dom position of the actual currentItem
          // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
          if(!this._noFinalSort && this.currentItem.parent().length) this.placeholder.before(this.currentItem);
          this._noFinalSort = null;

          if(this.helper[0] == this.currentItem[0]) {
               for(var i in this._storedCSS) {
                    if(this._storedCSS[i] == 'auto' || this._storedCSS[i] == 'static') this._storedCSS[i] = '';
               }
               this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
          } else {
               this.currentItem.show();
          }

          if(this.fromOutside && !noPropagation) delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
          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

          // Check if the items Container has Changed and trigger appropriate
          // events.
          if (this !== this.currentContainer) {
               if(!noPropagation) {
                    delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
                    delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); };  }).call(this, this.currentContainer));
                    delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this));  }; }).call(this, this.currentContainer));
               }
          }


          //Post events to containers
          for (var i = this.containers.length - 1; i >= 0; i--){
               if(!noPropagation) delayedTriggers.push((function(c) { return function(event) { c._trigger("deactivate", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
               if(this.containers[i].containerCache.over) {
                    delayedTriggers.push((function(c) { return function(event) { c._trigger("out", event, this._uiHash(this)); };  }).call(this, this.containers[i]));
                    this.containers[i].containerCache.over = 0;
               }
          }

          //Do what was originally in plugins
          if(this._storedCursor) $('body').css("cursor", this._storedCursor); //Reset cursor
          if(this._storedOpacity) this.helper.css("opacity", this._storedOpacity); //Reset opacity
          if(this._storedZIndex) this.helper.css("zIndex", this._storedZIndex == 'auto' ? '' : this._storedZIndex); //Reset z-index

          this.dragging = false;
          if(this.cancelHelperRemoval) {
               if(!noPropagation) {
                    this._trigger("beforeStop", event, this._uiHash());
                    for (var i=0; i < delayedTriggers.length; i++) { delayedTriggers[i].call(this, event); }; //Trigger all delayed events
                    this._trigger("stop", event, this._uiHash());
               }

               this.fromOutside = false;
               return false;
          }

          if(!noPropagation) this._trigger("beforeStop", event, this._uiHash());

          //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
          this.placeholder[0].parentNode.removeChild(this.placeholder[0]);

          if(this.helper[0] != this.currentItem[0]) this.helper.remove(); this.helper = null;

          if(!noPropagation) {
               for (var i=0; i < delayedTriggers.length; i++) { delayedTriggers[i].call(this, event); }; //Trigger all delayed events
               this._trigger("stop", event, this._uiHash());
          }

          this.fromOutside = false;
          return true;

     },

     _trigger: function() {
          if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
               this.cancel();
          }
     },

     _uiHash: function(_inst) {
          var inst = _inst || this;
          return {
               helper: inst.helper,
               placeholder: inst.placeholder || $([]),
               position: inst.position,
               originalPosition: inst.originalPosition,
               offset: inst.positionAbs,
               item: inst.currentItem,
               sender: _inst ? _inst.element : null
          };
     }

});

})(jQuery);
(function( $, undefined ) {

var uid = 0,
     hideProps = {},
     showProps = {};

hideProps.height = hideProps.paddingTop = hideProps.paddingBottom =
     hideProps.borderTopWidth = hideProps.borderBottomWidth = "hide";
showProps.height = showProps.paddingTop = showProps.paddingBottom =
     showProps.borderTopWidth = showProps.borderBottomWidth = "show";

$.widget( "ui.accordion", {
     version: "1.9.2",
     options: {
          active: 0,
          animate: {},
          collapsible: false,
          event: "click",
          header: "> li > :first-child,> :not(li):even",
          heightStyle: "auto",
          icons: {
               activeHeader: "ui-icon-triangle-1-s",
               header: "ui-icon-triangle-1-e"
          },

          // callbacks
          activate: null,
          beforeActivate: null
     },

     _create: function() {
          var accordionId = this.accordionId = "ui-accordion-" +
                    (this.element.attr( "id" ) || ++uid),
               options = this.options;

          this.prevShow = this.prevHide = $();
          this.element.addClass( "ui-accordion ui-widget ui-helper-reset" );

          this.headers = this.element.find( options.header )
               .addClass( "ui-accordion-header ui-helper-reset ui-state-default ui-corner-all" );
          this._hoverable( this.headers );
          this._focusable( this.headers );

          this.headers.next()
               .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
               .hide();

          // don't allow collapsible: false and active: false / null
          if ( !options.collapsible && (options.active === false || options.active == null) ) {
               options.active = 0;
          }
          // handle negative values
          if ( options.active < 0 ) {
               options.active += this.headers.length;
          }
          this.active = this._findActive( options.active )
               .addClass( "ui-accordion-header-active ui-state-active" )
               .toggleClass( "ui-corner-all ui-corner-top" );
          this.active.next()
               .addClass( "ui-accordion-content-active" )
               .show();

          this._createIcons();
          this.refresh();

          // ARIA
          this.element.attr( "role", "tablist" );

          this.headers
               .attr( "role", "tab" )
               .each(function( i ) {
                    var header = $( this ),
                         headerId = header.attr( "id" ),
                         panel = header.next(),
                         panelId = panel.attr( "id" );
                    if ( !headerId ) {
                         headerId = accordionId + "-header-" + i;
                         header.attr( "id", headerId );
                    }
                    if ( !panelId ) {
                         panelId = accordionId + "-panel-" + i;
                         panel.attr( "id", panelId );
                    }
                    header.attr( "aria-controls", panelId );
                    panel.attr( "aria-labelledby", headerId );
               })
               .next()
                    .attr( "role", "tabpanel" );

          this.headers
               .not( this.active )
               .attr({
                    "aria-selected": "false",
                    tabIndex: -1
               })
               .next()
                    .attr({
                         "aria-expanded": "false",
                         "aria-hidden": "true"
                    })
                    .hide();

          // make sure at least one header is in the tab order
          if ( !this.active.length ) {
               this.headers.eq( 0 ).attr( "tabIndex", 0 );
          } else {
               this.active.attr({
                    "aria-selected": "true",
                    tabIndex: 0
               })
               .next()
                    .attr({
                         "aria-expanded": "true",
                         "aria-hidden": "false"
                    });
          }

          this._on( this.headers, { keydown: "_keydown" });
          this._on( this.headers.next(), { keydown: "_panelKeyDown" });
          this._setupEvents( options.event );
     },

     _getCreateEventData: function() {
          return {
               header: this.active,
               content: !this.active.length ? $() : this.active.next()
          };
     },

     _createIcons: function() {
          var icons = this.options.icons;
          if ( icons ) {
               $( "<span>" )
                    .addClass( "ui-accordion-header-icon ui-icon " + icons.header )
                    .prependTo( this.headers );
               this.active.children( ".ui-accordion-header-icon" )
                    .removeClass( icons.header )
                    .addClass( icons.activeHeader );
               this.headers.addClass( "ui-accordion-icons" );
          }
     },

     _destroyIcons: function() {
          this.headers
               .removeClass( "ui-accordion-icons" )
               .children( ".ui-accordion-header-icon" )
                    .remove();
     },

     _destroy: function() {
          var contents;

          // clean up main element
          this.element
               .removeClass( "ui-accordion ui-widget ui-helper-reset" )
               .removeAttr( "role" );

          // clean up headers
          this.headers
               .removeClass( "ui-accordion-header ui-accordion-header-active ui-helper-reset ui-state-default ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
               .removeAttr( "role" )
               .removeAttr( "aria-selected" )
               .removeAttr( "aria-controls" )
               .removeAttr( "tabIndex" )
               .each(function() {
                    if ( /^ui-accordion/.test( this.id ) ) {
                         this.removeAttribute( "id" );
                    }
               });
          this._destroyIcons();

          // clean up content panels
          contents = this.headers.next()
               .css( "display", "" )
               .removeAttr( "role" )
               .removeAttr( "aria-expanded" )
               .removeAttr( "aria-hidden" )
               .removeAttr( "aria-labelledby" )
               .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active ui-state-disabled" )
               .each(function() {
                    if ( /^ui-accordion/.test( this.id ) ) {
                         this.removeAttribute( "id" );
                    }
               });
          if ( this.options.heightStyle !== "content" ) {
               contents.css( "height", "" );
          }
     },

     _setOption: function( key, value ) {
          if ( key === "active" ) {
               // _activate() will handle invalid values and update this.options
               this._activate( value );
               return;
          }

          if ( key === "event" ) {
               if ( this.options.event ) {
                    this._off( this.headers, this.options.event );
               }
               this._setupEvents( value );
          }

          this._super( key, value );

          // setting collapsible: false while collapsed; open first panel
          if ( key === "collapsible" && !value && this.options.active === false ) {
               this._activate( 0 );
          }

          if ( key === "icons" ) {
               this._destroyIcons();
               if ( value ) {
                    this._createIcons();
               }
          }

          // #5332 - opacity doesn't cascade to positioned elements in IE
          // so we need to add the disabled class to the headers and panels
          if ( key === "disabled" ) {
               this.headers.add( this.headers.next() )
                    .toggleClass( "ui-state-disabled", !!value );
          }
     },

     _keydown: function( event ) {
          if ( event.altKey || event.ctrlKey ) {
               return;
          }

          var keyCode = $.ui.keyCode,
               length = this.headers.length,
               currentIndex = this.headers.index( event.target ),
               toFocus = false;

          switch ( event.keyCode ) {
               case keyCode.RIGHT:
               case keyCode.DOWN:
                    toFocus = this.headers[ ( currentIndex + 1 ) % length ];
                    break;
               case keyCode.LEFT:
               case keyCode.UP:
                    toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
                    break;
               case keyCode.SPACE:
               case keyCode.ENTER:
                    this._eventHandler( event );
                    break;
               case keyCode.HOME:
                    toFocus = this.headers[ 0 ];
                    break;
               case keyCode.END:
                    toFocus = this.headers[ length - 1 ];
                    break;
          }

          if ( toFocus ) {
               $( event.target ).attr( "tabIndex", -1 );
               $( toFocus ).attr( "tabIndex", 0 );
               toFocus.focus();
               event.preventDefault();
          }
     },

     _panelKeyDown : function( event ) {
          if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
               $( event.currentTarget ).prev().focus();
          }
     },

     refresh: function() {
          var maxHeight, overflow,
               heightStyle = this.options.heightStyle,
               parent = this.element.parent();


          if ( heightStyle === "fill" ) {
               // IE 6 treats height like minHeight, so we need to turn off overflow
               // in order to get a reliable height
               // we use the minHeight support test because we assume that only
               // browsers that don't support minHeight will treat height as minHeight
               if ( !$.support.minHeight ) {
                    overflow = parent.css( "overflow" );
                    parent.css( "overflow", "hidden");
               }
               maxHeight = parent.height();
               this.element.siblings( ":visible" ).each(function() {
                    var elem = $( this ),
                         position = elem.css( "position" );

                    if ( position === "absolute" || position === "fixed" ) {
                         return;
                    }
                    maxHeight -= elem.outerHeight( true );
               });
               if ( overflow ) {
                    parent.css( "overflow", overflow );
               }

               this.headers.each(function() {
                    maxHeight -= $( this ).outerHeight( true );
               });

               this.headers.next()
                    .each(function() {
                         $( this ).height( Math.max( 0, maxHeight -
                              $( this ).innerHeight() + $( this ).height() ) );
                    })
                    .css( "overflow", "auto" );
          } else if ( heightStyle === "auto" ) {
               maxHeight = 0;
               this.headers.next()
                    .each(function() {
                         maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
                    })
                    .height( maxHeight );
          }
     },

     _activate: function( index ) {
          var active = this._findActive( index )[ 0 ];

          // trying to activate the already active panel
          if ( active === this.active[ 0 ] ) {
               return;
          }

          // trying to collapse, simulate a click on the currently active header
          active = active || this.active[ 0 ];

          this._eventHandler({
               target: active,
               currentTarget: active,
               preventDefault: $.noop
          });
     },

     _findActive: function( selector ) {
          return typeof selector === "number" ? this.headers.eq( selector ) : $();
     },

     _setupEvents: function( event ) {
          var events = {};
          if ( !event ) {
               return;
          }
          $.each( event.split(" "), function( index, eventName ) {
               events[ eventName ] = "_eventHandler";
          });
          this._on( this.headers, events );
     },

     _eventHandler: function( event ) {
          var options = this.options,
               active = this.active,
               clicked = $( event.currentTarget ),
               clickedIsActive = clicked[ 0 ] === active[ 0 ],
               collapsing = clickedIsActive && options.collapsible,
               toShow = collapsing ? $() : clicked.next(),
               toHide = active.next(),
               eventData = {
                    oldHeader: active,
                    oldPanel: toHide,
                    newHeader: collapsing ? $() : clicked,
                    newPanel: toShow
               };

          event.preventDefault();

          if (
                    // click on active header, but not collapsible
                    ( clickedIsActive && !options.collapsible ) ||
                    // allow canceling activation
                    ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
               return;
          }

          options.active = collapsing ? false : this.headers.index( clicked );

          // when the call to ._toggle() comes after the class changes
          // it causes a very odd bug in IE 8 (see #6720)
          this.active = clickedIsActive ? $() : clicked;
          this._toggle( eventData );

          // switch classes
          // corner classes on the previously active header stay after the animation
          active.removeClass( "ui-accordion-header-active ui-state-active" );
          if ( options.icons ) {
               active.children( ".ui-accordion-header-icon" )
                    .removeClass( options.icons.activeHeader )
                    .addClass( options.icons.header );
          }

          if ( !clickedIsActive ) {
               clicked
                    .removeClass( "ui-corner-all" )
                    .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
               if ( options.icons ) {
                    clicked.children( ".ui-accordion-header-icon" )
                         .removeClass( options.icons.header )
                         .addClass( options.icons.activeHeader );
               }

               clicked
                    .next()
                    .addClass( "ui-accordion-content-active" );
          }
     },

     _toggle: function( data ) {
          var toShow = data.newPanel,
               toHide = this.prevShow.length ? this.prevShow : data.oldPanel;

          // handle activating a panel during the animation for another activation
          this.prevShow.add( this.prevHide ).stop( true, true );
          this.prevShow = toShow;
          this.prevHide = toHide;

          if ( this.options.animate ) {
               this._animate( toShow, toHide, data );
          } else {
               toHide.hide();
               toShow.show();
               this._toggleComplete( data );
          }

          toHide.attr({
               "aria-expanded": "false",
               "aria-hidden": "true"
          });
          toHide.prev().attr( "aria-selected", "false" );
          // if we're switching panels, remove the old header from the tab order
          // if we're opening from collapsed state, remove the previous header from the tab order
          // if we're collapsing, then keep the collapsing header in the tab order
          if ( toShow.length && toHide.length ) {
               toHide.prev().attr( "tabIndex", -1 );
          } else if ( toShow.length ) {
               this.headers.filter(function() {
                    return $( this ).attr( "tabIndex" ) === 0;
               })
               .attr( "tabIndex", -1 );
          }

          toShow
               .attr({
                    "aria-expanded": "true",
                    "aria-hidden": "false"
               })
               .prev()
                    .attr({
                         "aria-selected": "true",
                         tabIndex: 0
                    });
     },

     _animate: function( toShow, toHide, data ) {
          var total, easing, duration,
               that = this,
               adjust = 0,
               down = toShow.length &&
                    ( !toHide.length || ( toShow.index() < toHide.index() ) ),
               animate = this.options.animate || {},
               options = down && animate.down || animate,
               complete = function() {
                    that._toggleComplete( data );
               };

          if ( typeof options === "number" ) {
               duration = options;
          }
          if ( typeof options === "string" ) {
               easing = options;
          }
          // fall back from options to animation in case of partial down settings
          easing = easing || options.easing || animate.easing;
          duration = duration || options.duration || animate.duration;

          if ( !toHide.length ) {
               return toShow.animate( showProps, duration, easing, complete );
          }
          if ( !toShow.length ) {
               return toHide.animate( hideProps, duration, easing, complete );
          }

          total = toShow.show().outerHeight();
          toHide.animate( hideProps, {
               duration: duration,
               easing: easing,
               step: function( now, fx ) {
                    fx.now = Math.round( now );
               }
          });
          toShow
               .hide()
               .animate( showProps, {
                    duration: duration,
                    easing: easing,
                    complete: complete,
                    step: function( now, fx ) {
                         fx.now = Math.round( now );
                         if ( fx.prop !== "height" ) {
                              adjust += fx.now;
                         } else if ( that.options.heightStyle !== "content" ) {
                              fx.now = Math.round( total - toHide.outerHeight() - adjust );
                              adjust = 0;
                         }
                    }
               });
     },

     _toggleComplete: function( data ) {
          var toHide = data.oldPanel;

          toHide
               .removeClass( "ui-accordion-content-active" )
               .prev()
                    .removeClass( "ui-corner-top" )
                    .addClass( "ui-corner-all" );

          // Work around for rendering bug in IE (#5421)
          if ( toHide.length ) {
               toHide.parent()[0].className = toHide.parent()[0].className;
          }

          this._trigger( "activate", null, data );
     }
});



// DEPRECATED
if ( $.uiBackCompat !== false ) {
     // navigation options
     (function( $, prototype ) {
          $.extend( prototype.options, {
               navigation: false,
               navigationFilter: function() {
                    return this.href.toLowerCase() === location.href.toLowerCase();
               }
          });

          var _create = prototype._create;
          prototype._create = function() {
               if ( this.options.navigation ) {
                    var that = this,
                         headers = this.element.find( this.options.header ),
                         content = headers.next(),
                         current = headers.add( content )
                              .find( "a" )
                              .filter( this.options.navigationFilter )
                              [ 0 ];
                    if ( current ) {
                         headers.add( content ).each( function( index ) {
                              if ( $.contains( this, current ) ) {
                                   that.options.active = Math.floor( index / 2 );
                                   return false;
                              }
                         });
                    }
               }
               _create.call( this );
          };
     }( jQuery, jQuery.ui.accordion.prototype ) );

     // height options
     (function( $, prototype ) {
          $.extend( prototype.options, {
               heightStyle: null, // remove default so we fall back to old values
               autoHeight: true, // use heightStyle: "auto"
               clearStyle: false, // use heightStyle: "content"
               fillSpace: false // use heightStyle: "fill"
          });

          var _create = prototype._create,
               _setOption = prototype._setOption;

          $.extend( prototype, {
               _create: function() {
                    this.options.heightStyle = this.options.heightStyle ||
                         this._mergeHeightStyle();

                    _create.call( this );
               },

               _setOption: function( key ) {
                    if ( key === "autoHeight" || key === "clearStyle" || key === "fillSpace" ) {
                         this.options.heightStyle = this._mergeHeightStyle();
                    }
                    _setOption.apply( this, arguments );
               },

               _mergeHeightStyle: function() {
                    var options = this.options;

                    if ( options.fillSpace ) {
                         return "fill";
                    }

                    if ( options.clearStyle ) {
                         return "content";
                    }

                    if ( options.autoHeight ) {
                         return "auto";
                    }
               }
          });
     }( jQuery, jQuery.ui.accordion.prototype ) );

     // icon options
     (function( $, prototype ) {
          $.extend( prototype.options.icons, {
               activeHeader: null, // remove default so we fall back to old values
               headerSelected: "ui-icon-triangle-1-s"
          });

          var _createIcons = prototype._createIcons;
          prototype._createIcons = function() {
               if ( this.options.icons ) {
                    this.options.icons.activeHeader = this.options.icons.activeHeader ||
                         this.options.icons.headerSelected;
               }
               _createIcons.call( this );
          };
     }( jQuery, jQuery.ui.accordion.prototype ) );

     // expanded active option, activate method
     (function( $, prototype ) {
          prototype.activate = prototype._activate;

          var _findActive = prototype._findActive;
          prototype._findActive = function( index ) {
               if ( index === -1 ) {
                    index = false;
               }
               if ( index && typeof index !== "number" ) {
                    index = this.headers.index( this.headers.filter( index ) );
                    if ( index === -1 ) {
                         index = false;
                    }
               }
               return _findActive.call( this, index );
          };
     }( jQuery, jQuery.ui.accordion.prototype ) );

     // resize method
     jQuery.ui.accordion.prototype.resize = jQuery.ui.accordion.prototype.refresh;

     // change events
     (function( $, prototype ) {
          $.extend( prototype.options, {
               change: null,
               changestart: null
          });

          var _trigger = prototype._trigger;
          prototype._trigger = function( type, event, data ) {
               var ret = _trigger.apply( this, arguments );
               if ( !ret ) {
                    return false;
               }

               if ( type === "beforeActivate" ) {
                    ret = _trigger.call( this, "changestart", event, {
                         oldHeader: data.oldHeader,
                         oldContent: data.oldPanel,
                         newHeader: data.newHeader,
                         newContent: data.newPanel
                    });
               } else if ( type === "activate" ) {
                    ret = _trigger.call( this, "change", event, {
                         oldHeader: data.oldHeader,
                         oldContent: data.oldPanel,
                         newHeader: data.newHeader,
                         newContent: data.newPanel
                    });
               }
               return ret;
          };
     }( jQuery, jQuery.ui.accordion.prototype ) );

     // animated option
     // NOTE: this only provides support for "slide", "bounceslide", and easings
     // not the full $.ui.accordion.animations API
     (function( $, prototype ) {
          $.extend( prototype.options, {
               animate: null,
               animated: "slide"
          });

          var _create = prototype._create;
          prototype._create = function() {
               var options = this.options;
               if ( options.animate === null ) {
                    if ( !options.animated ) {
                         options.animate = false;
                    } else if ( options.animated === "slide" ) {
                         options.animate = 300;
                    } else if ( options.animated === "bounceslide" ) {
                         options.animate = {
                              duration: 200,
                              down: {
                                   easing: "easeOutBounce",
                                   duration: 1000
                              }
                         };
                    } else {
                         options.animate = options.animated;
                    }
               }

               _create.call( this );
          };
     }( jQuery, jQuery.ui.accordion.prototype ) );
}

})( jQuery );