/* NUGET: BEGIN LICENSE TEXT

*
* Microsoft grants you the right to use these script files for the sole
* purpose of either: (i) interacting through your browser with the Microsoft
* website or online service, subject to the applicable licensing or use
* terms; or (ii) using the files as included with a Microsoft product subject
* to that product's license terms. Microsoft reserves all other rights to the
* files not expressly granted by Microsoft, whether by implication, estoppel
* or otherwise. Insofar as a script file is dual licensed under GPL,
* Microsoft neither took the code under GPL nor distributes it thereunder but
* under the terms set out in this paragraph. All notices and licenses
* below are for informational purposes only.
*
* jQuery UI; Copyright (c) 2012 Paul Bakaus; [Link]
*
* Includes jQuery Easing v1.3; Copyright 2008 George McGinley Smith;
[Link]
*
* NUGET: END LICENSE TEXT */
/*! jQuery UI - v1.8.24 - 2012-09-28
* [Link]
* Includes: [Link], [Link], [Link],
[Link], [Link], [Link],
[Link], [Link], [Link],
[Link], [Link], [Link],
[Link], [Link], [Link],
[Link], [Link], [Link],
[Link], [Link], [Link],
[Link], [Link], [Link],
[Link], [Link], [Link],
[Link], [Link], [Link],
[Link]
* Copyright (c) 2012 [Link]; Licensed MIT */

(function( $, undefined ) {

// 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 ( $.[Link] ) {
return;
}

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

keyCode: {
ALT: 18,
BACKSPACE: 8,
CAPS_LOCK: 20,
COMMA: 188,
COMMAND: 91,
COMMAND_LEFT: 91, // COMMAND
COMMAND_RIGHT: 93,
CONTROL: 17,
DELETE: 46,
DOWN: 40,
END: 35,
 ENTER: 13,
ESCAPE: 27,
HOME: 36,
INSERT: 45,
LEFT: 37,
MENU: 93, // COMMAND_RIGHT
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,
SHIFT: 16,
SPACE: 32,
TAB: 9,
UP: 38,
WINDOWS: 91 // COMMAND
}
});

// plugins
$.[Link]({
propAttr: $.[Link] || $.[Link],

_focus: $.[Link],
focus: function( delay, fn ) {
return typeof delay === "number" ?
[Link](function() {
var elem = this;
setTimeout(function() {
$( elem ).focus();
if ( fn ) {
[Link]( elem );
}
}, delay );
}) :
this._focus.apply( this, arguments );
},

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

return (/fixed/).test([Link]('position')) || ![Link] ? $

(document) : scrollParent;
},

zIndex: function( zIndex ) {

if ( zIndex !== undefined ) {
return [Link]( "zIndex", zIndex );
}

if ( [Link] ) {
var elem = $( this[ 0 ] ), position, value;
while ( [Link] && 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 = [Link]( "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( [Link]( "zIndex" ), 10 );
if ( !isNaN( value ) && value !== 0 ) {
return value;
}
}
elem = [Link]();
}
}

return 0;
},

disableSelection: function() {
return [Link]( ( $.[Link] ? "selectstart" : "mousedown"
) +
".ui-disableSelection", function( event ) {
[Link]();
});
},

enableSelection: function() {
return [Link]( ".ui-disableSelection" );
}
});

// support: jQuery <1.8

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

function reduce( elem, size, border, margin ) {

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

$.fn[ "inner" + name ] = function( size ) {

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

return [Link](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 [Link](function() {
$( this).css( type, reduce( this, size, true, margin ) +
"px" );
});
};
});
}

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

function visible( element ) {

return !$( element ).parents().andSelf().filter(function() {
return $.curCSS( this, "visibility" ) === "hidden" ||
$.[Link]( this );
}).length;
}

$.extend( $.expr[ ":" ], {

data: $.[Link] ?
$.[Link](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 = [Link],
div = [Link]( div = [Link]( "div" ) );

// access offsetHeight before setting the style to prevent a layout bug

// in IE 9 which causes the elemnt to continue to take up space even
// after it is removed from the DOM (#8026)
[Link];

$.extend( [Link], {
minHeight: "100px",
height: "auto",
padding: 0,
borderWidth: 0
});

$.[Link] = [Link] === 100;

 $.[Link] = "onselectstart" in div;

// set display to none to avoid a layout bug in IE

// [Link]
[Link]( div ).[Link] = "none";
});

// jQuery <1.4.3 uses curCSS, in 1.4.3 - 1.7.2 curCSS = css, 1.8+ only has css
if ( !$.curCSS ) {
$.curCSS = $.css;
}

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

for ( var i = 0; i < [Link]; i++ ) {

if ( [Link][ set[ i ][ 0 ] ] ) {
set[ i ][ 1 ].apply( [Link], args );
}
}
}
},

// will be deprecated when we switch to jQuery 1.4 - use [Link]()

contains: function( a, b ) {
return [Link] ?
[Link]( b ) & 16 :
a !== b && [Link]( b );
},

// 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 $.[Link]( y, top, height ) && $.[Link]( x, left,
width );
}
});

})( jQuery );

(function( $, undefined ) {

// jQuery 1.4+
if ( $.cleanData ) {
var _cleanData = $.cleanData;
$.cleanData = function( elems ) {
for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
try {
$( elem ).triggerHandler( "remove" );
// [Link]
} catch( e ) {}
}
_cleanData( elems );
};
} else {
var _remove = $.[Link];
$.[Link] = function( selector, keepData ) {
return [Link](function() {
if ( !keepData ) {
if ( !selector || $.filter( selector, [ this ] ).length ) {
$( "*", this ).add( [ this ] ).each(function() {
try {
$( this ).triggerHandler( "remove" );
// [Link]
} catch( e ) {}
});
}
}
return _remove.call( $(this), selector, keepData );
});
};
}

$.widget = function( name, base, prototype ) {

var namespace = [Link]( "." )[ 0 ],
fullName;
name = [Link]( "." )[ 1 ];
fullName = namespace + "-" + name;

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

// create selector for plugin

$.expr[ ":" ][ fullName ] = function( elem ) {
return !!$.data( elem, name );
};

$[ namespace ] = $[ namespace ] || {};

$[ namespace ][ name ] = function( options, element ) {
// allow instantiation without initializing for simple inheritance
if ( [Link] ) {
this._createWidget( options, element );
}
};

var 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
// $.each( basePrototype, function( key, val ) {
// if ( $.isPlainObject(val) ) {
// basePrototype[ key ] = $.extend( {}, val );
// }
// });
[Link] = $.extend( true, {}, [Link] );
$[ namespace ][ name ].prototype = $.extend( true, basePrototype, {
namespace: namespace,
widgetName: name,
widgetEventPrefix: $[ namespace ][ name ].[Link]
|| name,
widgetBaseClass: fullName
}, prototype );

$.[Link]( name, $[ namespace ][ name ] );

};

$.[Link] = function( name, object ) {

$.fn[ name ] = function( options ) {
var isMethodCall = typeof options === "string",
args = [Link]( arguments, 1 ),
returnValue = this;

// allow multiple hashes to be passed on init

options = !isMethodCall && [Link] ?
$.[Link]( null, [ true, options ].concat(args) ) :
options;

// prevent calls to internal methods

 if ( isMethodCall && [Link]( 0 ) === "_" ) {
return returnValue;
}

if ( isMethodCall ) {
[Link](function() {
var instance = $.data( this, name ),
methodValue = instance &&
$.isFunction( instance[options] ) ?
instance[ options ].apply( instance, args ) :
instance;
// TODO: add this back in 1.9 and use $.error() (see #5972)
// if ( !instance ) {
// throw "cannot call methods on " + name + " prior to
initialization; " +
// "attempted to call method '" + options + "'";
// }
// if ( !$.isFunction( instance[options] ) ) {
// throw "no such method '" + options + "' for " + name
+ " widget instance";
// }
// var methodValue = instance[ options ].apply( instance, args
);
if ( methodValue !== instance && methodValue !==
undefined ) {
returnValue = methodValue;
return false;
}
});
} else {
[Link](function() {
var instance = $.data( this, name );
if ( instance ) {
[Link]( options || {} )._init();
} else {
$.data( this, name, new object( options, this ) );
}
});
}

return returnValue;
};
};

$.Widget = function( options, element ) {

// allow instantiation without initializing for simple inheritance
if ( [Link] ) {
this._createWidget( options, element );
}
};

$.[Link] = {
widgetName: "widget",
widgetEventPrefix: "",
options: {
disabled: false
},
_createWidget: function( options, element ) {
// $.[Link] stores the plugin instance, but we do it anyway
 // so that it's stored even before the _create function runs
$.data( element, [Link], this );
[Link] = $( element );
[Link] = $.extend( true, {},
[Link],
this._getCreateOptions(),
options );

var self = this;

[Link]( "remove." + [Link], function() {
[Link]();
});

this._create();
this._trigger( "create" );
this._init();
},
_getCreateOptions: function() {
return $.metadata && $.[Link]( [Link][0] )[ [Link]
];
},
_create: function() {},
_init: function() {},

destroy: function() {
[Link]
.unbind( "." + [Link] )
.removeData( [Link] );
[Link]()
.unbind( "." + [Link] )
.removeAttr( "aria-disabled" )
.removeClass(
[Link] + "-disabled " +
"ui-state-disabled" );
},

widget: function() {
return [Link];
},

option: function( key, value ) {

var options = key;

if ( [Link] === 0 ) {
// don't return a reference to the internal hash
return $.extend( {}, [Link] );
}

if (typeof key === "string" ) {

if ( value === undefined ) {
return [Link][ key ];
}
options = {};
options[ key ] = value;
}

this._setOptions( options );

return this;
},
_setOptions: function( options ) {
var self = this;
$.each( options, function( key, value ) {
self._setOption( key, value );
});

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

if ( key === "disabled" ) {

[Link]()
[ value ? "addClass" : "removeClass"](
[Link] + "-disabled" + " " +
"ui-state-disabled" )
.attr( "aria-disabled", value );
}

return this;
},

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

_trigger: function( type, event, data ) {

var prop, orig,
callback = [Link][ type ];

data = data || {};

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

// copy original event properties over to the new event

orig = [Link];
if ( orig ) {
for ( prop in orig ) {
if ( !( prop in event ) ) {
event[ prop ] = orig[ prop ];
}
}
}

[Link]( event, data );

return !( $.isFunction(callback) &&

[Link]( [Link][0], event, data ) === false ||
[Link]() );
}
};

})( jQuery );

(function( $, undefined ) {

var mouseHandled = false;

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

$.widget("[Link]", {
options: {
cancel: ':input,option',
distance: 1,
delay: 0
},
_mouseInit: function() {
var self = this;

[Link]
.bind('mousedown.'+[Link], function(event) {
return self._mouseDown(event);
})
.bind('click.'+[Link], function(event) {
if (true === $.data([Link], [Link] +
'.preventClickEvent')) {
$.removeData([Link], [Link] +
'.preventClickEvent');
[Link]();
return false;
}
});

[Link] = false;
},

// TODO: make sure destroying one instance of mouse doesn't mess with
// other instances of mouse
_mouseDestroy: function() {
[Link]('.'+[Link]);
if ( this._mouseMoveDelegate ) {
$(document)
.unbind('mousemove.'+[Link],
this._mouseMoveDelegate)
.unbind('mouseup.'+[Link], 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 self = this,

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

[Link] = ![Link];
if (![Link]) {
this._mouseDelayTimer = setTimeout(function() {
[Link] = true;
}, [Link]);
}

if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {

this._mouseStarted = (this._mouseStart(event) !== false);
if (!this._mouseStarted) {
[Link]();
return true;
}
}

// Click event may never have fired (Gecko & Opera)

if (true === $.data([Link], [Link] +
'.preventClickEvent')) {
$.removeData([Link], [Link] +
'.preventClickEvent');
}

// these delegates are required to keep context

this._mouseMoveDelegate = function(event) {
return self._mouseMove(event);
};
this._mouseUpDelegate = function(event) {
return self._mouseUp(event);
};
$(document)
.bind('mousemove.'+[Link], this._mouseMoveDelegate)
.bind('mouseup.'+[Link], this._mouseUpDelegate);

[Link]();

mouseHandled = true;
return true;
},

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

if (this._mouseStarted) {
this._mouseDrag(event);
return [Link]();
}
 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.'+[Link], this._mouseMoveDelegate)
.unbind('mouseup.'+[Link], this._mouseUpDelegate);

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

if ([Link] == this._mouseDownEvent.target) {
$.data([Link], [Link] + '.preventClickEvent',
true);
}

this._mouseStop(event);
}

return false;
},

_mouseDistanceMet: function(event) {
return ([Link](
[Link](this._mouseDownEvent.pageX - [Link]),
[Link](this._mouseDownEvent.pageY - [Link])
) >= [Link]
);
},

_mouseDelayMet: function(event) {
return [Link];
},

// 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("[Link]", $.[Link], {
widgetEventPrefix: "drag",
options: {
addClasses: true,
appendTo: "parent",
axis: false,
 connectToSortable: false,
containment: false,
cursor: "auto",
cursorAt: false,
grid: false,
handle: false,
helper: "original",
iframeFix: false,
opacity: false,
refreshPositions: false,
revert: false,
revertDuration: 500,
scope: "default",
scroll: true,
scrollSensitivity: 20,
scrollSpeed: 20,
snap: false,
snapMode: "both",
snapTolerance: 20,
stack: false,
zIndex: false
},
_create: function() {

if ([Link] == 'original' && !(/^(?:r|a|

f)/).test([Link]("position")))
[Link][0].[Link] = 'relative';

([Link] && [Link]("ui-draggable"));

([Link] && [Link]("ui-draggable-
disabled"));

this._mouseInit();

},

destroy: function() {
if() return;
[Link]
.removeData("draggable")
.unbind(".draggable")
.removeClass("ui-draggable"
+ " ui-draggable-dragging"
+ " ui-draggable-disabled");
this._mouseDestroy();

return this;
},

_mouseCapture: function(event) {

var o = [Link];

// among others, prevent a drag on a resizable-handle

if ([Link] || [Link] || $([Link]).is('.ui-resizable-
handle'))
return false;

//Quit if we're not on a valid handle

 [Link] = this._getHandle(event);
if (![Link])
return false;

if ( [Link] ) {
$([Link] === true ? "iframe" : [Link]).each(function()
{
$('<div class="ui-draggable-iframeFix" style="background:
#fff;"></div>')
.css({
width: [Link]+"px", height:
[Link]+"px",
position: "absolute", opacity: "0.001", zIndex: 1000
})
.css($(this).offset())
.appendTo("body");
});
}

return true;

},

_mouseStart: function(event) {

var o = [Link];

//Create and append the visible helper

[Link] = this._createHelper(event);

[Link]("ui-draggable-dragging");

//Cache the helper size

this._cacheHelperProportions();

//If ddmanager is used for droppables, set the global draggable

if($.[Link])
$.[Link] = this;

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

//Cache the margins of the original element

this._cacheMargins();

//Store the helper's css position

[Link] = [Link]("position");
[Link] = [Link]();

//The element's absolute position on the page minus margins

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

//Generate the original position

[Link] = [Link] = this._generatePosition(event);
[Link] = [Link];
[Link] = [Link];

//Adjust the mouse offset relative to the helper if 'cursorAt' is

supplied
([Link] && this._adjustOffsetFromHelper([Link]));

//Set a containment if given in the options

if([Link])
this._setContainment();

//Trigger event + callbacks

if(this._trigger("start", event) === false) {
this._clear();
return false;
}

//Recache the helper size

this._cacheHelperProportions();

//Prepare the droppable offsets

if ($.[Link] && ![Link])
$.[Link](this, event);

this._mouseDrag(event, true); //Execute the drag once - this causes the

helper not to be visible before getting its correct position

//If the ddmanager is used for droppables, inform the manager that
dragging has started (see #5003)
if ( $.[Link] ) $.[Link](this, event);

return true;
},

_mouseDrag: function(event, noPropagation) {

//Compute the helpers position

[Link] = this._generatePosition(event);
[Link] = this._convertPositionTo("absolute");

//Call plugins and callbacks and use the resulting position if

something is returned
if (!noPropagation) {
var ui = this._uiHash();
if(this._trigger('drag', event, ui) === false) {
 this._mouseUp({});
return false;
}
[Link] = [Link];
}

if(![Link] || [Link] != "y")

[Link][0].[Link] = [Link]+'px';
if(![Link] || [Link] != "x")
[Link][0].[Link] = [Link]+'px';
if($.[Link]) $.[Link](this, event);

return false;
},

_mouseStop: function(event) {

//If we are using droppables, inform the manager about the drop
var dropped = false;
if ($.[Link] && ![Link])
dropped = $.[Link](this, event);

//if a drop comes from outside (a sortable)

if([Link]) {
dropped = [Link];
[Link] = false;
}

//if the original element is no longer in the DOM don't bother to

continue (see #8269)
var element = [Link][0], elementInDom = false;
while ( element && (element = [Link]) ) {
if (element == document ) {
elementInDom = true;
}
}
if ( !elementInDom && [Link] === "original" )
return false;

if(([Link] == "invalid" && !dropped) ||

([Link] == "valid" && dropped) || [Link] === true ||
($.isFunction([Link]) && [Link]([Link],
dropped))) {
var self = this;
$([Link]).animate([Link],
parseInt([Link], 10), function() {
if(self._trigger("stop", event) !== false) {
self._clear();
}
});
} else {
if(this._trigger("stop", event) !== false) {
this._clear();
}
}

return false;
},
 _mouseUp: function(event) {
//Remove frame helpers
$("[Link]-draggable-iframeFix").each(function() {
[Link](this);
});

//If the ddmanager is used for droppables, inform the manager that
dragging has stopped (see #5003)
if( $.[Link] ) $.[Link](this, event);

return $.[Link]._mouseUp.call(this, event);

},

cancel: function() {

if([Link](".ui-draggable-dragging")) {
this._mouseUp({});
} else {
this._clear();
}

return this;

},

_getHandle: function(event) {

var handle = ![Link] || !$([Link],

[Link]).length ? true : false;
$([Link], [Link])
.find("*")
.andSelf()
.each(function() {
if(this == [Link]) handle = true;
});

return handle;

},

_createHelper: function(event) {

var o = [Link];
var helper = $.isFunction([Link]) ? $([Link]([Link][0],
[event])) : ([Link] == 'clone' ? [Link]().removeAttr('id') :
[Link]);

if(.length)
[Link](([Link] == 'parent' ?
[Link][0].parentNode : [Link]));

if(helper[0] != [Link][0] && !(/(fixed|

absolute)/).test([Link]("position")))
[Link]("position", "absolute");

return helper;

},
 _adjustOffsetFromHelper: function(obj) {
if (typeof obj == 'string') {
obj = [Link](' ');
}
if ($.isArray(obj)) {
obj = {left: +obj[0], top: +obj[1] || 0};
}
if ('left' in obj) {
[Link] = [Link] + [Link];
}
if ('right' in obj) {
[Link] = [Link] - [Link]
+ [Link];
}
if ('top' in obj) {
[Link] = [Link] + [Link];
}
if ('bottom' in obj) {
[Link] = [Link] -
[Link] + [Link];
}
},

_getParentOffset: function() {

//Get the offsetParent and cache its position

[Link] = [Link]();
var po = [Link]();

// 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([Link] == 'absolute' && [Link][0] != document
&& $.[Link]([Link][0], [Link][0])) {
[Link] += [Link]();
[Link] += [Link]();
}

if(([Link][0] == [Link]) //This needs to be actually

done for all browsers, since pageX/pageY includes this information
|| ([Link][0].tagName &&
[Link][0].[Link]() == 'html' && $.[Link])) //Ugly IE
fix
po = { top: 0, left: 0 };

return {
top: [Link] +
(parseInt([Link]("borderTopWidth"),10) || 0),
left: [Link] +
(parseInt([Link]("borderLeftWidth"),10) || 0)
};

},
 _getRelativeOffset: function() {

if([Link] == "relative") {
var p = [Link]();
return {
top: [Link] - (parseInt([Link]("top"),10) || 0) +
[Link](),
left: [Link] - (parseInt([Link]("left"),10) || 0)
+ [Link]()
};
} else {
return { top: 0, left: 0 };
}

},

_cacheMargins: function() {
[Link] = {
left: (parseInt([Link]("marginLeft"),10) || 0),
top: (parseInt([Link]("marginTop"),10) || 0),
right: (parseInt([Link]("marginRight"),10) || 0),
bottom: (parseInt([Link]("marginBottom"),10) || 0)
};
},

_cacheHelperProportions: function() {
[Link] = {
width: [Link](),
height: [Link]()
};
},

_setContainment: function() {

var o = [Link];
if([Link] == 'parent') [Link] =
[Link][0].parentNode;
if([Link] == 'document' || [Link] == 'window')
[Link] = [
[Link] == 'document' ? 0 : $(window).scrollLeft() -
[Link] - [Link],
[Link] == 'document' ? 0 : $(window).scrollTop() -
[Link] - [Link],
([Link] == 'document' ? 0 : $(window).scrollLeft()) + $
([Link] == 'document' ? document : window).width() -
[Link] - [Link],
([Link] == 'document' ? 0 : $(window).scrollTop()) + ($
([Link] == 'document' ? document : window).height() ||
[Link]) - [Link] -
[Link]
];

if(!(/^(document|window|parent)$/).test([Link]) &&
[Link] != Array) {
var c = $([Link]);
var ce = c[0]; if(!ce) return;
var co = [Link]();
var over = ($(ce).css("overflow") != 'hidden');
 [Link] = [
(parseInt($(ce).css("borderLeftWidth"),10) || 0) +
(parseInt($(ce).css("paddingLeft"),10) || 0),
(parseInt($(ce).css("borderTopWidth"),10) || 0) +
(parseInt($(ce).css("paddingTop"),10) || 0),
(over ? [Link]([Link],[Link]) :
[Link]) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($
(ce).css("paddingRight"),10) || 0) - [Link] -
[Link] - [Link],
(over ? [Link]([Link],[Link]) :
[Link]) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($
(ce).css("paddingBottom"),10) || 0) - [Link] -
[Link] - [Link]
];
this.relative_container = c;

} else if([Link] == Array) {

[Link] = [Link];
}

},

_convertPositionTo: function(d, pos) {

if(!pos) pos = [Link];

var mod = d == "absolute" ? 1 : -1;
var o = [Link], scroll = [Link] == 'absolute' && !
([Link][0] != document && $.[Link]([Link][0],
[Link][0])) ? [Link] : [Link], scrollIsRootNode =
(/(html|body)/i).test(scroll[0].tagName);

return {
top: (
[Link]
// The absolute mouse position
+ [Link] * mod
// Only for relative positioned nodes: Relative
offset from element to offset parent
+ [Link] * mod
// The offsetParent's offset without borders
(offset + border)
- ($.[Link] && $.[Link] < 526 &&
[Link] == 'fixed' ? 0 : ( [Link] == 'fixed' ? -
[Link]() : ( scrollIsRootNode ? 0 : [Link]() ) ) *
mod)
),
left: (
[Link]
// The absolute mouse position
+ [Link] * mod
// Only for relative positioned nodes: Relative
offset from element to offset parent
+ [Link] * mod
// The offsetParent's offset without borders
(offset + border)
- ($.[Link] && $.[Link] < 526 &&
[Link] == 'fixed' ? 0 : ( [Link] == 'fixed' ? -
[Link]() : scrollIsRootNode ? 0 : [Link]() ) *
mod)
 )
};

},

_generatePosition: function(event) {

var o = [Link], scroll = [Link] == 'absolute' && !

([Link][0] != document && $.[Link]([Link][0],
[Link][0])) ? [Link] : [Link], scrollIsRootNode =
(/(html|body)/i).test(scroll[0].tagName);
var pageX = [Link];
var pageY = [Link];

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

if([Link]) { //If we are not dragging yet, we won't

check for options
var containment;
if([Link]) {
if (this.relative_container){
var co = this.relative_container.offset();
containment = [ [Link][0] + [Link],
[Link][1] + [Link],
[Link][2] + [Link],
[Link][3] + [Link] ];
}
else {
containment = [Link];
}

if([Link] - [Link] < containment[0])

pageX = containment[0] + [Link];
if([Link] - [Link] < containment[1])
pageY = containment[1] + [Link];
if([Link] - [Link] > containment[2])
pageX = containment[2] + [Link];
if([Link] - [Link] > containment[3])
pageY = containment[3] + [Link];
}

if([Link]) {
//Check for grid elements set to 0 to prevent divide by 0
error causing invalid argument errors in IE (see ticket #6950)
var top = [Link][1] ? [Link] +
[Link]((pageY - [Link]) / [Link][1]) * [Link][1] :
[Link];
pageY = containment ? (!(top - [Link] <
containment[1] || top - [Link] > containment[3]) ? top : (!(top -
[Link] < containment[1]) ? top - [Link][1] : top + [Link][1])) :
top;

var left = [Link][0] ? [Link] +

[Link]((pageX - [Link]) / [Link][0]) * [Link][0] :
[Link];
pageX = containment ? (!(left - [Link] <
containment[0] || left - [Link] > containment[2]) ? left : (!(left
- [Link] < containment[0]) ? left - [Link][0] : left +
[Link][0])) : left;
}

return {
top: (
pageY
// The absolute mouse position
- [Link]
// Click offset (relative to the element)
- [Link]
// Only for relative positioned nodes: Relative
offset from element to offset parent
- [Link]
// The offsetParent's offset without borders
(offset + border)
+ ($.[Link] && $.[Link] < 526 &&
[Link] == 'fixed' ? 0 : ( [Link] == 'fixed' ? -
[Link]() : ( scrollIsRootNode ? 0 : [Link]() ) ))
),
left: (
pageX
// The absolute mouse position
- [Link]
// Click offset (relative to the element)
- [Link]
// Only for relative positioned nodes: Relative
offset from element to offset parent
- [Link]
// The offsetParent's offset without borders
(offset + border)
+ ($.[Link] && $.[Link] < 526 &&
[Link] == 'fixed' ? 0 : ( [Link] == 'fixed' ? -
[Link]() : scrollIsRootNode ? 0 : [Link]() ))
)
};

},

_clear: function() {
[Link]("ui-draggable-dragging");
if([Link][0] != [Link][0] && ![Link])
[Link]();
//if($.[Link]) $.[Link] = null;
[Link] = null;
[Link] = false;
},

// From now on bulk stuff - mainly helpers

_trigger: function(type, event, ui) {

ui = ui || this._uiHash();
$.[Link](this, type, [event, ui]);
if(type == "drag") [Link] =
this._convertPositionTo("absolute"); //The absolute position has to be recalculated
after plugins
 return $.[Link]._trigger.call(this, type, event, ui);
},

plugins: {},

_uiHash: function(event) {
return {
helper: [Link],
position: [Link],
originalPosition: [Link],
offset: [Link]
};
}

});

$.extend($.[Link], {
version: "1.8.24"
});

$.[Link]("draggable", "connectToSortable", {
start: function(event, ui) {

var inst = $(this).data("draggable"), o = [Link],

uiSortable = $.extend({}, ui, { item: [Link] });
[Link] = [];
$([Link]).each(function() {
var sortable = $.data(this, 'sortable');
if (sortable && ![Link]) {
[Link]({
instance: sortable,
shouldRevert: [Link]
});
[Link](); // Call the sortable's
refreshPositions at drag start to refresh the containerCache since the sortable
container cache is used in drag and needs to be up to date (this will ensure it's
initialised as well as being kept in step with any changes that might have happened
on the page).
sortable._trigger("activate", event, uiSortable);
}
});

},
stop: function(event, ui) {

//If we are still over the sortable, we fake the stop event of the
sortable, but also remove helper
var inst = $(this).data("draggable"),
uiSortable = $.extend({}, ui, { item: [Link] });

$.each([Link], function() {
if([Link]) {

[Link] = 0;

[Link] = true; //Don't remove the helper

in the draggable instance
[Link] = false; //Remove it in
the sortable instance (so sortable plugins like revert still work)
 //The sortable revert is supported, and we have to set a
temporary dropped variable on the draggable to support revert: 'valid/invalid'
if([Link]) [Link] = true;

//Trigger the stop of the sortable

[Link]._mouseStop(event);

[Link] =
[Link]._helper;

//If the helper has been the original item, restore

properties in the sortable
if([Link] == 'original')
[Link]({ top: 'auto', left:
'auto' });

} else {
[Link] = false; //Remove the
helper in the sortable instance
[Link]._trigger("deactivate", event, uiSortable);
}

});

},
drag: function(event, ui) {

var inst = $(this).data("draggable"), self = this;

var checkPos = function(o) {

var dyClick = [Link], dxClick =
[Link];
var helperTop = [Link], helperLeft =
[Link];
var itemHeight = [Link], itemWidth = [Link];
var itemTop = [Link], itemLeft = [Link];

return $.[Link](helperTop + dyClick, helperLeft + dxClick,

itemTop, itemLeft, itemHeight, itemWidth);
};

$.each([Link], function(i) {

//Copy over some variables to allow calling the sortable's native

_intersectsWith
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];

if([Link]._intersectsWith([Link])) {

//If it intersects, we use a little isOver variable and set

it once, so our move-in stuff gets fired only once
if(![Link]) {

[Link] = 1;
//Now we fake the start of dragging for the sortable
instance,
 //by cloning the list group item, appending it to the
sortable and using it as [Link]
//We can then fire the start event of the sortable
with our passed browser event, and our own helper (so it doesn't create a new one)
[Link] = $
(self).clone().removeAttr('id').appendTo([Link]).data("sortable-
item", true);
[Link]._helper =
[Link]; //Store helper option to later restore it
[Link] = function() { return
[Link][0]; };

[Link] = [Link][0];
[Link]._mouseCapture(event, true);
[Link]._mouseStart(event, true, true);

//Because the browser event is way off the new

appended portlet, we modify a couple of variables to reflect the changes
[Link] =
[Link];
[Link] =
[Link];
[Link] -=
[Link] - [Link];
[Link] -=
[Link] - [Link];

inst._trigger("toSortable", event);
[Link] = [Link]; //draggable
revert needs that
//hack so receive/update callbacks work (mostly)
[Link] = [Link];
[Link] = inst;

//Provided we did all the previous steps, we can fire the

drag event of the sortable on every draggable drag, when it intersects with the
sortable
if([Link])
[Link]._mouseDrag(event);

} else {

//If it doesn't intersect with the sortable, and it

intersected before,
//we fake the drag stop of the sortable, but make sure it
doesn't remove the helper by using cancelHelperRemoval
if([Link]) {

[Link] = 0;
[Link] = true;

//Prevent reverting on this forced stop

[Link] = false;

// The out event needs to be triggered independently

[Link]._trigger('out', event,
[Link]._uiHash([Link]));
 [Link]._mouseStop(event, true);
[Link] =
[Link]._helper;

//Now we remove our currentItem, the list group clone

again, and the placeholder, and animate the helper back to it's original size
[Link]();
if([Link])
[Link]();

inst._trigger("fromSortable", event);
[Link] = false; //draggable revert needs that
}

};

});

}
});

$.[Link]("draggable", "cursor", {
start: function(event, ui) {
var t = $('body'), o = $(this).data('draggable').options;
if ([Link]("cursor")) o._cursor = [Link]("cursor");
[Link]("cursor", [Link]);
},
stop: function(event, ui) {
var o = $(this).data('draggable').options;
if (o._cursor) $('body').css("cursor", o._cursor);
}
});

$.[Link]("draggable", "opacity", {
start: function(event, ui) {
var t = $([Link]), o = $(this).data('draggable').options;
if([Link]("opacity")) o._opacity = [Link]("opacity");
[Link]('opacity', [Link]);
},
stop: function(event, ui) {
var o = $(this).data('draggable').options;
if(o._opacity) $([Link]).css('opacity', o._opacity);
}
});

$.[Link]("draggable", "scroll", {
start: function(event, ui) {
var i = $(this).data("draggable");
if([Link][0] != document && [Link][0].tagName !=
'HTML') [Link] = [Link]();
},
drag: function(event, ui) {

var i = $(this).data("draggable"), o = [Link], scrolled = false;

if([Link][0] != document && [Link][0].tagName !=

'HTML') {
 if(![Link] || [Link] != 'x') {
if(([Link] + [Link][0].offsetHeight)
- [Link] < [Link])
[Link][0].scrollTop = scrolled =
[Link][0].scrollTop + [Link];
else if([Link] - [Link] <
[Link])
[Link][0].scrollTop = scrolled =
[Link][0].scrollTop - [Link];
}

if(![Link] || [Link] != 'y') {

if(([Link] + [Link][0].offsetWidth)
- [Link] < [Link])
[Link][0].scrollLeft = scrolled =
[Link][0].scrollLeft + [Link];
else if([Link] - [Link] <
[Link])
[Link][0].scrollLeft = scrolled =
[Link][0].scrollLeft - [Link];
}

} else {

if(![Link] || [Link] != 'x') {

if([Link] - $(document).scrollTop() <
[Link])
scrolled = $(document).scrollTop($
(document).scrollTop() - [Link]);
else if($(window).height() - ([Link] - $
(document).scrollTop()) < [Link])
scrolled = $(document).scrollTop($
(document).scrollTop() + [Link]);
}

if(![Link] || [Link] != 'y') {

if([Link] - $(document).scrollLeft() <
[Link])
scrolled = $(document).scrollLeft($
(document).scrollLeft() - [Link]);
else if($(window).width() - ([Link] - $
(document).scrollLeft()) < [Link])
scrolled = $(document).scrollLeft($
(document).scrollLeft() + [Link]);
}

if(scrolled !== false && $.[Link] && ![Link])

$.[Link](i, event);

}
});

$.[Link]("draggable", "snap", {
start: function(event, ui) {

var i = $(this).data("draggable"), o = [Link];

[Link] = [];
 $([Link] != String ? ( [Link] || ':data(draggable)' )
: [Link]).each(function() {
var $t = $(this); var $o = $[Link]();
if(this != [Link][0]) [Link]({
item: this,
width: $[Link](), height: $[Link](),
top: $[Link], left: $[Link]
});
});

},
drag: function(event, ui) {

var inst = $(this).data("draggable"), o = [Link];

var d = [Link];

var x1 = [Link], x2 = x1 + [Link],

y1 = [Link], y2 = y1 + [Link];

for (var i = [Link] - 1; i >= 0; i--){

var l = [Link][i].left, r = l +
[Link][i].width,
t = [Link][i].top, b = t +
[Link][i].height;

//Yes, I know, this is insane ;)

if(!((l-d < x1 && x1 < r+d && t-d < y1 && y1 < b+d) || (l-d < x1
&& x1 < r+d && t-d < y2 && y2 < b+d) || (l-d < x2 && x2 < r+d && t-d < y1 && y1 <
b+d) || (l-d < x2 && x2 < r+d && t-d < y2 && y2 < b+d))) {
if([Link][i].snapping)
([Link] && [Link]([Link], event,
$.extend(inst._uiHash(), { snapItem: [Link][i].item })));
[Link][i].snapping = false;
continue;
}

if([Link] != 'inner') {
var ts = [Link](t - y2) <= d;
var bs = [Link](b - y1) <= d;
var ls = [Link](l - x2) <= d;
var rs = [Link](r - x1) <= d;
if(ts) [Link] =
inst._convertPositionTo("relative", { top: t - [Link], left:
0 }).top - [Link];
if(bs) [Link] =
inst._convertPositionTo("relative", { top: b, left: 0 }).top - [Link];
if(ls) [Link] =
inst._convertPositionTo("relative", { top: 0, left: l -
[Link] }).left - [Link];
if(rs) [Link] =
inst._convertPositionTo("relative", { top: 0, left: r }).left - [Link];
}

var first = (ts || bs || ls || rs);

if([Link] != 'outer') {
var ts = [Link](t - y1) <= d;
 var bs = [Link](b - y2) <= d;
var ls = [Link](l - x1) <= d;
var rs = [Link](r - x2) <= d;
if(ts) [Link] =
inst._convertPositionTo("relative", { top: t, left: 0 }).top - [Link];
if(bs) [Link] =
inst._convertPositionTo("relative", { top: b - [Link], left:
0 }).top - [Link];
if(ls) [Link] =
inst._convertPositionTo("relative", { top: 0, left: l }).left - [Link];
if(rs) [Link] =
inst._convertPositionTo("relative", { top: 0, left: r -
[Link] }).left - [Link];
}

if(![Link][i].snapping && (ts || bs || ls || rs ||

first))
([Link] &&
[Link]([Link], event, $.extend(inst._uiHash(),
{ snapItem: [Link][i].item })));
[Link][i].snapping = (ts || bs || ls || rs || first);

};

}
});

$.[Link]("draggable", "stack", {
start: function(event, ui) {

var o = $(this).data("draggable").options;

var group = $.makeArray($([Link])).sort(function(a,b) {

return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($
(b).css("zIndex"),10) || 0);
});
if (![Link]) { return; }

var min = parseInt(group[0].[Link]) || 0;

$(group).each(function(i) {
[Link] = min + i;
});

this[0].[Link] = min + [Link];

}
});

$.[Link]("draggable", "zIndex", {
start: function(event, ui) {
var t = $([Link]), o = $(this).data("draggable").options;
if([Link]("zIndex")) o._zIndex = [Link]("zIndex");
[Link]('zIndex', [Link]);
},
stop: function(event, ui) {
var o = $(this).data("draggable").options;
if(o._zIndex) $([Link]).css('zIndex', o._zIndex);
}
});
})(jQuery);

(function( $, undefined ) {

$.widget("[Link]", {
widgetEventPrefix: "drop",
options: {
accept: '*',
activeClass: false,
addClasses: true,
greedy: false,
hoverClass: false,
scope: 'default',
tolerance: 'intersect'
},
_create: function() {

var o = [Link], accept = [Link];

[Link] = 0; [Link] = 1;

[Link] = $.isFunction(accept) ? accept : function(d) {

return [Link](accept);
};

//Store the droppable's proportions

[Link] = { width: [Link][0].offsetWidth, height:
[Link][0].offsetHeight };

// Add the reference and positions to the manager

$.[Link][[Link]] = $.[Link][[Link]]
|| [];
$.[Link][[Link]].push(this);

([Link] && [Link]("ui-droppable"));

},

destroy: function() {
var drop = $.[Link][[Link]];
for ( var i = 0; i < [Link]; i++ )
if ( drop[i] == this )
[Link](i, 1);

[Link]
.removeClass("ui-droppable ui-droppable-disabled")
.removeData("droppable")
.unbind(".droppable");

return this;
},

_setOption: function(key, value) {

if(key == 'accept') {
[Link] = $.isFunction(value) ? value : function(d) {
return [Link](value);
};
}
 $.[Link]._setOption.apply(this, arguments);
},

_activate: function(event) {
var draggable = $.[Link];
if([Link])
[Link]([Link]);
(draggable && this._trigger('activate', event, [Link](draggable)));
},

_deactivate: function(event) {
var draggable = $.[Link];
if([Link])
[Link]([Link]);
(draggable && this._trigger('deactivate', event, [Link](draggable)));
},

_over: function(event) {

var draggable = $.[Link];

if (!draggable || ([Link] || [Link])[0] ==
[Link][0]) return; // Bail if draggable and droppable are same element

if ([Link]([Link][0],([Link] ||
[Link]))) {
if([Link])
[Link]([Link]);
this._trigger('over', event, [Link](draggable));
}

},

_out: function(event) {

var draggable = $.[Link];

if (!draggable || ([Link] || [Link])[0] ==
[Link][0]) return; // Bail if draggable and droppable are same element

if ([Link]([Link][0],([Link] ||
[Link]))) {
if([Link])
[Link]([Link]);
this._trigger('out', event, [Link](draggable));
}

},

_drop: function(event,custom) {

var draggable = custom || $.[Link];

if (!draggable || ([Link] || [Link])[0] ==
[Link][0]) return false; // Bail if draggable and droppable are same element

var childrenIntersection = false;

[Link](":data(droppable)").not(".ui-draggable-
dragging").each(function() {
var inst = $.data(this, 'droppable');
if(
[Link]
 && ![Link]
&& [Link] == [Link]
&& [Link]([Link][0], ([Link]
|| [Link]))
&& $.[Link](draggable, $.extend(inst, { offset:
[Link]() }), [Link])
) { childrenIntersection = true; return false; }
});
if(childrenIntersection) return false;

if([Link]([Link][0],([Link] ||
[Link]))) {
if([Link])
[Link]([Link]);
if([Link])
[Link]([Link]);
this._trigger('drop', event, [Link](draggable));
return [Link];
}

return false;

},

ui: function(c) {
return {
draggable: ([Link] || [Link]),
helper: [Link],
position: [Link],
offset: [Link]
};
}

});

$.extend($.[Link], {
version: "1.8.24"
});

$.[Link] = function(draggable, droppable, toleranceMode) {

if (![Link]) return false;

var x1 = ([Link] || [Link]).left, x2 = x1

+ [Link],
y1 = ([Link] || [Link]).top, y2 =
y1 + [Link];
var l = [Link], r = l + [Link],
t = [Link], b = t + [Link];

switch (toleranceMode) {
case 'fit':
return (l <= x1 && x2 <= r
&& t <= y1 && y2 <= b);
break;
case 'intersect':
return (l < x1 + ([Link] / 2) // Right
Half
&& x2 - ([Link] / 2) < r // Left
Half
&& t < y1 + ([Link] / 2) //
Bottom Half
&& y2 - ([Link] / 2) < b ); //
Top Half
break;
case 'pointer':
var draggableLeft = (([Link] ||
[Link]).left + ([Link] ||
[Link]).left),
draggableTop = (([Link] ||
[Link]).top + ([Link] ||
[Link]).top),
isOver = $.[Link](draggableTop, draggableLeft, t, l,
[Link], [Link]);
return isOver;
break;
case 'touch':
return (
(y1 >= t && y1 <= b) || // Top edge touching
(y2 >= t && y2 <= b) || // Bottom edge touching
(y1 < t && y2 > b) // Surrounded vertically
) && (
(x1 >= l && x1 <= r) || // Left edge touching
(x2 >= l && x2 <= r) || // Right edge touching
(x1 < l && x2 > r) // Surrounded
horizontally
);
break;
default:
return false;
break;
}

};

/*
This manager tracks offsets of draggables and droppables
*/
$.[Link] = {
current: null,
droppables: { 'default': [] },
prepareOffsets: function(t, event) {

var m = $.[Link][[Link]] || [];

var type = event ? [Link] : null; // workaround for #2317
var list = ([Link] ||
[Link]).find(":data(droppable)").andSelf();

droppablesLoop: for (var i = 0; i < [Link]; i++) {

if(m[i].[Link] || (t && !
m[i].[Link](m[i].element[0],([Link] || [Link])))) continue; //No
disabled and non-accepted
for (var j=0; j < [Link]; j++) { if(list[j] ==
m[i].element[0]) { m[i].[Link] = 0; continue droppablesLoop; } };
//Filter out elements in the current dragged item
m[i].visible = m[i].[Link]("display") != "none"; if(!
m[i].visible) continue; //If
the element is not visible, continue

if(type == "mousedown") m[i]._activate.call(m[i], event);

//Activate the droppable if used directly from draggables

m[i].offset = m[i].[Link]();
m[i].proportions = { width: m[i].element[0].offsetWidth, height:
m[i].element[0].offsetHeight };

},
drop: function(draggable, event) {

var dropped = false;

$.each($.[Link][[Link]] || [],
function() {

if(![Link]) return;
if (![Link] && [Link] &&
$.[Link](draggable, this, [Link]))
dropped = this._drop.call(this, event) || dropped;

if (![Link] && [Link] &&

[Link]([Link][0],([Link] || [Link]))) {
[Link] = 1; [Link] = 0;
this._deactivate.call(this, event);
}

});
return dropped;

},
dragStart: function( draggable, event ) {
//Listen for scrolling so that if the dragging causes scrolling the
position of the droppables can be recalculated (see #5003)

[Link]( ":not(body,html)" ).bind( "[Link]",

function() {
if( ![Link] )
$.[Link]( draggable, event );
});
},
drag: function(draggable, event) {

//If you have a highly dynamic page, you might try this option. It
renders positions every time you move the mouse.
if([Link])
$.[Link](draggable, event);

//Run through all droppables and check their positions based on

specific tolerance options
$.each($.[Link][[Link]] || [],
function() {

if([Link] || [Link] || ![Link])

return;
var intersects = $.[Link](draggable, this,
[Link]);
 var c = !intersects && [Link] == 1 ? 'isout' : (intersects
&& [Link] == 0 ? 'isover' : null);
if(!c) return;

var parentInstance;
if ([Link]) {
// find droppable parents with same scope
var scope = [Link];
var parent =
[Link](':data(droppable)').filter(function () {
return $.data(this, 'droppable').[Link] ===
scope;
});

if ([Link]) {
parentInstance = $.data(parent[0], 'droppable');
[Link] = (c == 'isover' ? 1 : 0);
}
}

// we just moved into a greedy child

if (parentInstance && c == 'isover') {
parentInstance['isover'] = 0;
parentInstance['isout'] = 1;
parentInstance._out.call(parentInstance, event);
}

this[c] = 1; this[c == 'isout' ? 'isover' : 'isout'] = 0;

this[c == "isover" ? "_over" : "_out"].call(this, event);

// we just moved out of a greedy child

if (parentInstance && c == 'isout') {
parentInstance['isout'] = 0;
parentInstance['isover'] = 1;
parentInstance._over.call(parentInstance, event);
}
});

},
dragStop: function( draggable, event ) {

[Link]( ":not(body,html)" ).unbind( "[Link]" );

//Call prepareOffsets one final time since IE does not fire return
scroll events when overflow was caused by drag (see #5003)
if( ![Link] )
$.[Link]( draggable, event );
}
};

})(jQuery);

(function( $, undefined ) {

$.widget("[Link]", $.[Link], {
widgetEventPrefix: "resize",
options: {
alsoResize: false,
animate: false,
 animateDuration: "slow",
animateEasing: "swing",
aspectRatio: false,
autoHide: false,
containment: false,
ghost: false,
grid: false,
handles: "e,s,se",
helper: false,
maxHeight: null,
maxWidth: null,
minHeight: 10,
minWidth: 10,
zIndex: 1000
},
_create: function() {

var self = this, o = [Link];

[Link]("ui-resizable");

$.extend(this, {
_aspectRatio: !!([Link]),
aspectRatio: [Link],
originalElement: [Link],
_proportionallyResizeElements: [],
_helper: [Link] || [Link] || [Link] ? [Link] || 'ui-
resizable-helper' : null
});

//Wrap the element if it cannot hold child nodes

if([Link][0].[Link](/canvas|textarea|input|select|button|
img/i)) {

//Create a wrapper element and set the wrapper to the new current
internal element
[Link](
$('<div class="ui-wrapper" style="overflow:
hidden;"></div>').css({
position: [Link]('position'),
width: [Link](),
height: [Link](),
top: [Link]('top'),
left: [Link]('left')
})
);

//Overwrite the original [Link]

[Link] = [Link]().data(
"resizable", [Link]('resizable')
);

[Link] = true;

//Move margins to the wrapper

[Link]({ marginLeft:
[Link]("marginLeft"), marginTop:
[Link]("marginTop"), marginRight:
[Link]("marginRight"), marginBottom:
[Link]("marginBottom") });
 [Link]({ marginLeft: 0, marginTop: 0,
marginRight: 0, marginBottom: 0});

//Prevent Safari textarea resize

[Link] = [Link]('resize');
[Link]('resize', 'none');

//Push the actual element to our proportionallyResize internal

array

this._proportionallyResizeElements.push([Link]({ position:
'static', zoom: 1, display: 'block' }));

// avoid IE jump (hard set the margin)

[Link]({ margin:
[Link]('margin') });

// fix handlers offset

this._proportionallyResize();

[Link] = [Link] || (!$('.ui-resizable-handle',

[Link]).length ? "e,s,se" : { n: '.ui-resizable-n', e: '.ui-resizable-e', s:
'.ui-resizable-s', w: '.ui-resizable-w', se: '.ui-resizable-se', sw: '.ui-
resizable-sw', ne: '.ui-resizable-ne', nw: '.ui-resizable-nw' });
if([Link] == String) {

if([Link] == 'all') [Link] = 'n,e,s,w,se,sw,ne,nw';

var n = [Link](","); [Link] = {};

for(var i = 0; i < [Link]; i++) {

var handle = $.trim(n[i]), hname = 'ui-resizable-'+handle;

var axis = $('<div class="ui-resizable-handle ' + hname +
'"></div>');

// Apply zIndex to all handles - see #7960

[Link]({ zIndex: [Link] });

//TODO : What's going on here?

if ('se' == handle) {
[Link]('ui-icon ui-icon-gripsmall-diagonal-
se');
};

//Insert into internal handles object and append to element

[Link][handle] = '.ui-resizable-'+handle;
[Link](axis);
}

this._renderAxis = function(target) {

target = target || [Link];

for(var i in [Link]) {
 if([Link][i].constructor == String)
[Link][i] = $([Link][i],
[Link]).show();

//Apply pad to wrapper element, needed to fix axis position

(textarea, inputs, scrolls)
if ([Link] &&
[Link][0].[Link](/textarea|input|select|button/i)) {

var axis = $([Link][i], [Link]),

padWrapper = 0;

//Checking the correct pad and border

padWrapper = /sw|ne|nw|se|n|s/.test(i) ?
[Link]() : [Link]();

//The padding type i have to apply...

var padPos = [ 'padding',
/ne|nw|n/.test(i) ? 'Top' :
/se|sw|s/.test(i) ? 'Bottom' :
/^e$/.test(i) ? 'Right' : 'Left' ].join("");

[Link](padPos, padWrapper);

this._proportionallyResize();

//TODO: What's that good for? There's not anything to be

executed left
if(!$([Link][i]).length)
continue;

}
};

//TODO: make renderAxis a prototype function

this._renderAxis([Link]);

this._handles = $('.ui-resizable-handle', [Link])

.disableSelection();

//Matching axis name

this._handles.mouseover(function() {
if (![Link]) {
if ([Link])
var axis = [Link](/ui-resizable-(se|sw|
ne|nw|n|e|s|w)/i);
//Axis, default = se
[Link] = axis && axis[1] ? axis[1] : 'se';
}
});

//If we want to auto hide the elements

if ([Link]) {
this._handles.hide();
$([Link])
.addClass("ui-resizable-autohide")
.hover(function() {
 if ([Link]) return;
$(this).removeClass("ui-resizable-autohide");
self._handles.show();
},
function(){
if ([Link]) return;
if (![Link]) {
$(this).addClass("ui-resizable-autohide");
self._handles.hide();
}
});
}

//Initialize the mouse interaction

this._mouseInit();

},

destroy: function() {

this._mouseDestroy();

var _destroy = function(exp) {

$(exp).removeClass("ui-resizable ui-resizable-disabled ui-
resizable-resizing")
.removeData("resizable").unbind(".resizable").find('.ui-
resizable-handle').remove();
};

//TODO: Unwrap at same DOM position

if ([Link]) {
_destroy([Link]);
var wrapper = [Link];
[Link](
[Link]({
position: [Link]('position'),
width: [Link](),
height: [Link](),
top: [Link]('top'),
left: [Link]('left')
})
).remove();
}

[Link]('resize', [Link]);
_destroy([Link]);

return this;
},

_mouseCapture: function(event) {
var handle = false;
for (var i in [Link]) {
if ($([Link][i])[0] == [Link]) {
handle = true;
}
}

return ![Link] && handle;

 },

_mouseStart: function(event) {

var o = [Link], iniPos = [Link](), el =

[Link];

[Link] = true;
[Link] = { top: $(document).scrollTop(), left: $
(document).scrollLeft() };

// bugfix for [Link]

if ([Link]('.ui-draggable') || (/absolute/).test([Link]('position'))) {
[Link]({ position: 'absolute', top: [Link], left: [Link]
});
}

this._renderProxy();

var curleft = num([Link]('left')), curtop =

num([Link]('top'));

if ([Link]) {
curleft += $([Link]).scrollLeft() || 0;
curtop += $([Link]).scrollTop() || 0;
}

//Store needed variables

[Link] = [Link]();
[Link] = { left: curleft, top: curtop };
[Link] = this._helper ? { width: [Link](), height:
[Link]() } : { width: [Link](), height: [Link]() };
[Link] = this._helper ? { width: [Link](), height:
[Link]() } : { width: [Link](), height: [Link]() };
[Link] = { left: curleft, top: curtop };
[Link] = { width: [Link]() - [Link](), height:
[Link]() - [Link]() };
[Link] = { left: [Link], top: [Link] };

//Aspect Ratio
[Link] = (typeof [Link] == 'number') ? [Link] :
(([Link] / [Link]) || 1);

var cursor = $('.ui-resizable-' + [Link]).css('cursor');

$('body').css('cursor', cursor == 'auto' ? [Link] + '-resize' :
cursor);

[Link]("ui-resizable-resizing");
this._propagate("start", event);
return true;
},

_mouseDrag: function(event) {

//Increase performance, avoid regex

var el = [Link], o = [Link], props = {},
self = this, smp = [Link], a = [Link];

var dx = ([Link])||0, dy = ([Link])||0;

 var trigger = this._change[a];
if (!trigger) return false;

// Calculate the attrs that will be change

var data = [Link](this, [event, dx, dy]), ie6 = $.[Link]
&& $.[Link] < 7, csdif = [Link];

// Put this in the mouseDrag handler since the user can start pressing
shift while resizing
this._updateVirtualBoundaries([Link]);
if (this._aspectRatio || [Link])
data = this._updateRatio(data, event);

data = this._respectSize(data, event);

// plugins callbacks need to be called first

this._propagate("resize", event);

[Link]({
top: [Link] + "px", left: [Link] + "px",
width: [Link] + "px", height: [Link] + "px"
});

if (!this._helper && this._proportionallyResizeElements.length)

this._proportionallyResize();

this._updateCache(data);

// calling the user callback at the end

this._trigger('resize', event, [Link]());

return false;
},

_mouseStop: function(event) {

[Link] = false;
var o = [Link], self = this;

if(this._helper) {
var pr = this._proportionallyResizeElements, ista = [Link] &&
(/textarea/i).test(pr[0].nodeName),
soffseth = ista && $.[Link](pr[0], 'left') /* TODO -
jump height */ ? 0 : [Link],
soffsetw = ista ? 0 : [Link];

var s = { width: ([Link]() - soffsetw), height:

([Link]() - soffseth) },
left = (parseInt([Link]('left'), 10) +
([Link] - [Link])) || null,
top = (parseInt([Link]('top'), 10) +
([Link] - [Link])) || null;

if (![Link])
[Link]($.extend(s, { top: top, left: left }));

[Link]([Link]);
[Link]([Link]);
 if (this._helper && ![Link]) this._proportionallyResize();
}

$('body').css('cursor', 'auto');

[Link]("ui-resizable-resizing");

this._propagate("stop", event);

if (this._helper) [Link]();
return false;

},

_updateVirtualBoundaries: function(forceAspectRatio) {
var o = [Link], pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b;

b = {
minWidth: isNumber([Link]) ? [Link] : 0,
maxWidth: isNumber([Link]) ? [Link] : Infinity,
minHeight: isNumber([Link]) ? [Link] : 0,
maxHeight: isNumber([Link]) ? [Link] : Infinity
};

if(this._aspectRatio || forceAspectRatio) {
// We want to create an enclosing box whose aspect ration is the
requested one
// First, compute the "projected" size for each dimension based on the
aspect ratio and other dimension
pMinWidth = [Link] * [Link];
pMinHeight = [Link] / [Link];
pMaxWidth = [Link] * [Link];
pMaxHeight = [Link] / [Link];

if(pMinWidth > [Link]) [Link] = pMinWidth;

if(pMinHeight > [Link]) [Link] = pMinHeight;
if(pMaxWidth < [Link]) [Link] = pMaxWidth;
if(pMaxHeight < [Link]) [Link] = pMaxHeight;
}
this._vBoundaries = b;
},

_updateCache: function(data) {
var o = [Link];
[Link] = [Link]();
if (isNumber([Link])) [Link] = [Link];
if (isNumber([Link])) [Link] = [Link];
if (isNumber([Link])) [Link] = [Link];
if (isNumber([Link])) [Link] = [Link];
},

_updateRatio: function(data, event) {

var o = [Link], cpos = [Link], csize = [Link], a =

[Link];

if (isNumber([Link])) [Link] = ([Link] *

[Link]);
else if (isNumber([Link])) [Link] = ([Link] /
[Link]);

if (a == 'sw') {
[Link] = [Link] + ([Link] - [Link]);
[Link] = null;
}
if (a == 'nw') {
[Link] = [Link] + ([Link] - [Link]);
[Link] = [Link] + ([Link] - [Link]);
}

return data;
},

_respectSize: function(data, event) {

var el = [Link], o = this._vBoundaries, pRatio = this._aspectRatio

|| [Link], a = [Link],
ismaxw = isNumber([Link]) && [Link] && ([Link]
< [Link]), ismaxh = isNumber([Link]) && [Link] && ([Link] <
[Link]),
isminw = isNumber([Link]) && [Link] &&
([Link] > [Link]), isminh = isNumber([Link]) && [Link] &&
([Link] > [Link]);

if (isminw) [Link] = [Link];

if (isminh) [Link] = [Link];
if (ismaxw) [Link] = [Link];
if (ismaxh) [Link] = [Link];

var dw = [Link] + [Link], dh =

[Link] + [Link];
var cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);

if (isminw && cw) [Link] = dw - [Link];

if (ismaxw && cw) [Link] = dw - [Link];
if (isminh && ch) [Link] = dh - [Link];
if (ismaxh && ch) [Link] = dh - [Link];

// fixing jump error on top/left - bug #2330

var isNotwh = ![Link] && ![Link];
if (isNotwh && ![Link] && [Link]) [Link] = null;
else if (isNotwh && ![Link] && [Link]) [Link] = null;

return data;
},

_proportionallyResize: function() {

var o = [Link];
if (!this._proportionallyResizeElements.length) return;
var element = [Link] || [Link];

for (var i=0; i < this._proportionallyResizeElements.length; i++) {

var prel = this._proportionallyResizeElements[i];

if (![Link]) {
var b = [[Link]('borderTopWidth'),
[Link]('borderRightWidth'), [Link]('borderBottomWidth'),
[Link]('borderLeftWidth')],
p = [[Link]('paddingTop'),
[Link]('paddingRight'), [Link]('paddingBottom'), [Link]('paddingLeft')];

[Link] = $.map(b, function(v, i) {

var border = parseInt(v,10)||0, padding =
parseInt(p[i],10)||0;
return border + padding;
});
}

if ($.[Link] && !(!($(element).is(':hidden') || $

(element).parents(':hidden').length)))
continue;

[Link]({
height: ([Link]() - [Link][0] -
[Link][2]) || 0,
width: ([Link]() - [Link][1] -
[Link][3]) || 0
});

};

},

_renderProxy: function() {

var el = [Link], o = [Link];

[Link] = [Link]();

if(this._helper) {

[Link] = [Link] || $('<div

style="overflow:hidden;"></div>');

// fix ie6 offset TODO: This seems broken

var ie6 = $.[Link] && $.[Link] < 7, ie6offset =
(ie6 ? 1 : 0),
pxyoffset = ( ie6 ? 2 : -1 );

[Link](this._helper).css({
width: [Link]() + pxyoffset,
height: [Link]() + pxyoffset,
position: 'absolute',
left: [Link] - ie6offset +'px',
top: [Link] - ie6offset +'px',
zIndex: ++[Link] //TODO: Don't modify option
});

[Link]
.appendTo("body")
.disableSelection();

} else {
[Link] = [Link];
}
 },

_change: {
e: function(event, dx, dy) {
return { width: [Link] + dx };
},
w: function(event, dx, dy) {
var o = [Link], cs = [Link], sp =
[Link];
return { left: [Link] + dx, width: [Link] - dx };
},
n: function(event, dx, dy) {
var o = [Link], cs = [Link], sp =
[Link];
return { top: [Link] + dy, height: [Link] - dy };
},
s: function(event, dx, dy) {
return { height: [Link] + dy };
},
se: function(event, dx, dy) {
return $.extend(this._change.[Link](this, arguments),
this._change.[Link](this, [event, dx, dy]));
},
sw: function(event, dx, dy) {
return $.extend(this._change.[Link](this, arguments),
this._change.[Link](this, [event, dx, dy]));
},
ne: function(event, dx, dy) {
return $.extend(this._change.[Link](this, arguments),
this._change.[Link](this, [event, dx, dy]));
},
nw: function(event, dx, dy) {
return $.extend(this._change.[Link](this, arguments),
this._change.[Link](this, [event, dx, dy]));
}
},

_propagate: function(n, event) {

$.[Link](this, n, [event, [Link]()]);
(n != "resize" && this._trigger(n, event, [Link]()));
},

plugins: {},

ui: function() {
return {
originalElement: [Link],
element: [Link],
helper: [Link],
position: [Link],
size: [Link],
originalSize: [Link],
originalPosition: [Link]
};
}

});

$.extend($.[Link], {
 version: "1.8.24"
});

/*
* Resizable Extensions
*/

$.[Link]("resizable", "alsoResize", {

start: function (event, ui) {

var self = $(this).data("resizable"), o = [Link];

var _store = function (exp) {

$(exp).each(function() {
var el = $(this);
[Link]("resizable-alsoresize", {
width: parseInt([Link](), 10), height:
parseInt([Link](), 10),
left: parseInt([Link]('left'), 10), top:
parseInt([Link]('top'), 10)
});
});
};

if (typeof([Link]) == 'object' && ![Link]) {

if ([Link]) { [Link] = [Link][0];
_store([Link]); }
else { $.each([Link], function (exp) { _store(exp); }); }
}else{
_store([Link]);
}
},

resize: function (event, ui) {

var self = $(this).data("resizable"), o = [Link], os =
[Link], op = [Link];

var delta = {
height: ([Link] - [Link]) || 0, width:
([Link] - [Link]) || 0,
top: ([Link] - [Link]) || 0, left: ([Link]
- [Link]) || 0
},

_alsoResize = function (exp, c) {

$(exp).each(function() {
var el = $(this), start = $(this).data("resizable-
alsoresize"), style = {},
css = c && [Link] ? c :
[Link]([Link][0]).length ? ['width', 'height'] : ['width',
'height', 'top', 'left'];

$.each(css, function (i, prop) {

var sum = (start[prop]||0) + (delta[prop]||0);
if (sum && sum >= 0)
style[prop] = sum || null;
});

[Link](style);
 });
};

if (typeof([Link]) == 'object' && ![Link]) {

$.each([Link], function (exp, c) { _alsoResize(exp, c); });
}else{
_alsoResize([Link]);
}
},

stop: function (event, ui) {

$(this).removeData("resizable-alsoresize");
}
});

$.[Link]("resizable", "animate", {

stop: function(event, ui) {

var self = $(this).data("resizable"), o = [Link];

var pr = self._proportionallyResizeElements, ista = [Link] &&

(/textarea/i).test(pr[0].nodeName),
soffseth = ista && $.[Link](pr[0], 'left') /*
TODO - jump height */ ? 0 : [Link],
soffsetw = ista ? 0 : [Link];

var style = { width: ([Link] - soffsetw), height:

([Link] - soffseth) },
left = (parseInt([Link]('left'), 10) +
([Link] - [Link])) || null,
top = (parseInt([Link]('top'), 10) +
([Link] - [Link])) || null;

[Link](
$.extend(style, top && left ? { top: top, left: left } : {}), {
duration: [Link],
easing: [Link],
step: function() {

var data = {
width: parseInt([Link]('width'), 10),
height: parseInt([Link]('height'),
10),
top: parseInt([Link]('top'), 10),
left: parseInt([Link]('left'), 10)
};

if (pr && [Link]) $(pr[0]).css({ width:

[Link], height: [Link] });

// propagating resize, and updating values for each

animation step
self._updateCache(data);
self._propagate("resize", event);

}
}
);
}
});

$.[Link]("resizable", "containment", {

start: function(event, ui) {

var self = $(this).data("resizable"), o = [Link], el =
[Link];
var oc = [Link], ce = (oc instanceof $) ? [Link](0) :
(/parent/.test(oc)) ? [Link]().get(0) : oc;
if (!ce) return;

[Link] = $(ce);

if (/document/.test(oc) || oc == document) {
[Link] = { left: 0, top: 0 };
[Link] = { left: 0, top: 0 };

[Link] = {
element: $(document), left: 0, top: 0,
width: $(document).width(), height: $(document).height() ||
[Link]
};
}

// i'm a node, so compute top, left, right, bottom

else {
var element = $(ce), p = [];
$([ "Top", "Right", "Left", "Bottom" ]).each(function(i, name)
{ p[i] = num([Link]("padding" + name)); });

[Link] = [Link]();
[Link] = [Link]();
[Link] = { height: ([Link]() - p[3]),
width: ([Link]() - p[1]) };

var co = [Link], ch = [Link],

cw = [Link],
width = ($.[Link](ce, "left") ?
[Link] : cw ), height = ($.[Link](ce) ? [Link] : ch);

[Link] = {
element: ce, left: [Link], top: [Link], width: width,
height: height
};
}
},

resize: function(event, ui) {

var self = $(this).data("resizable"), o = [Link],
ps = [Link], co = [Link], cs =
[Link], cp = [Link],
pRatio = self._aspectRatio || [Link], cop =
{ top:0, left:0 }, ce = [Link];

if (ce[0] != document && (/static/).test([Link]('position'))) cop = co;

if ([Link] < (self._helper ? [Link] : 0)) {

[Link] = [Link] + (self._helper ?
([Link] - [Link]) : ([Link] - [Link]));
if (pRatio) [Link] = [Link] /
[Link];
[Link] = [Link] ? [Link] : 0;
}

if ([Link] < (self._helper ? [Link] : 0)) {

[Link] = [Link] + (self._helper ?
([Link] - [Link]) : [Link]);
if (pRatio) [Link] = [Link] *
[Link];
[Link] = self._helper ? [Link] : 0;
}

[Link] = [Link]+[Link];
[Link] = [Link]+[Link];

var woset = [Link]( (self._helper ? [Link] - [Link] :

([Link] - [Link])) + [Link] ),
hoset = [Link]( (self._helper ? [Link] -
[Link] : ([Link] - [Link])) + [Link] );

var isParent = [Link](0) ==

[Link]().get(0),
isOffsetRelative = /relative|
absolute/.test([Link]('position'));

if(isParent && isOffsetRelative) woset -= [Link];

if (woset + [Link] >= [Link]) {

[Link] = [Link] - woset;
if (pRatio) [Link] = [Link] /
[Link];
}

if (hoset + [Link] >= [Link]) {

[Link] = [Link] - hoset;
if (pRatio) [Link] = [Link] *
[Link];
}
},

stop: function(event, ui){

var self = $(this).data("resizable"), o = [Link], cp =
[Link],
co = [Link], cop = [Link], ce
= [Link];

var helper = $([Link]), ho = [Link](), w =

[Link]() - [Link], h = [Link]() -
[Link];

if (self._helper && ![Link] &&

(/relative/).test([Link]('position')))
$(this).css({ left: [Link] - [Link] - [Link], width: w,
height: h });

if (self._helper && ![Link] && (/static/).test([Link]('position')))

$(this).css({ left: [Link] - [Link] - [Link], width: w,
height: h });

}
});

$.[Link]("resizable", "ghost", {

start: function(event, ui) {

var self = $(this).data("resizable"), o = [Link], cs = [Link];

[Link] = [Link]();
[Link]
.css({ opacity: .25, display: 'block', position: 'relative',
height: [Link], width: [Link], margin: 0, left: 0, top: 0 })
.addClass('ui-resizable-ghost')
.addClass(typeof [Link] == 'string' ? [Link] : '');

[Link]([Link]);

},

resize: function(event, ui){

var self = $(this).data("resizable"), o = [Link];
if ([Link]) [Link]({ position: 'relative', height:
[Link], width: [Link] });
},

stop: function(event, ui){

var self = $(this).data("resizable"), o = [Link];
if ([Link] && [Link])
[Link](0).removeChild([Link](0));
}

});

$.[Link]("resizable", "grid", {

resize: function(event, ui) {

var self = $(this).data("resizable"), o = [Link], cs = [Link],
os = [Link], op = [Link], a = [Link], ratio =
o._aspectRatio || [Link];
[Link] = typeof [Link] == "number" ? [[Link], [Link]] : [Link];
var ox = [Link](([Link] - [Link]) / ([Link][0]||1)) *
([Link][0]||1), oy = [Link](([Link] - [Link]) / ([Link][1]||1)) *
([Link][1]||1);

if (/^(se|s|e)$/.test(a)) {
[Link] = [Link] + ox;
[Link] = [Link] + oy;
}
else if (/^(ne)$/.test(a)) {
[Link] = [Link] + ox;
[Link] = [Link] + oy;
[Link] = [Link] - oy;
}
else if (/^(sw)$/.test(a)) {
[Link] = [Link] + ox;
[Link] = [Link] + oy;
 [Link] = [Link] - ox;
}
else {
[Link] = [Link] + ox;
[Link] = [Link] + oy;
[Link] = [Link] - oy;
[Link] = [Link] - ox;
}
}

});

var num = function(v) {

return parseInt(v, 10) || 0;
};

var isNumber = function(value) {

return !isNaN(parseInt(value, 10));
};

})(jQuery);

(function( $, undefined ) {

$.widget("[Link]", $.[Link], {
options: {
appendTo: 'body',
autoRefresh: true,
distance: 0,
filter: '*',
tolerance: 'touch'
},
_create: function() {
var self = this;

[Link]("ui-selectable");

[Link] = false;

// cache selectee children based on filter

var selectees;
[Link] = function() {
selectees = $([Link], [Link][0]);
[Link]("ui-selectee");
[Link](function() {
var $this = $(this);
var pos = $[Link]();
$.data(this, "selectable-item", {
element: this,
$element: $this,
left: [Link],
top: [Link],
right: [Link] + $[Link](),
bottom: [Link] + $[Link](),
startselected: false,
selected: $[Link]('ui-selected'),
selecting: $[Link]('ui-selecting'),
unselecting: $[Link]('ui-unselecting')
});
 });
};
[Link]();

[Link] = [Link]("ui-selectee");

this._mouseInit();

[Link] = $("<div class='ui-selectable-helper'></div>");

},

destroy: function() {
[Link]
.removeClass("ui-selectee")
.removeData("selectable-item");
[Link]
.removeClass("ui-selectable ui-selectable-disabled")
.removeData("selectable")
.unbind(".selectable");
this._mouseDestroy();

return this;
},

_mouseStart: function(event) {
var self = this;

[Link] = [[Link], [Link]];

if ([Link])
return;

var options = [Link];

[Link] = $([Link], [Link][0]);

this._trigger("start", event);

$([Link]).append([Link]);
// position helper (lasso)
[Link]({
"left": [Link],
"top": [Link],
"width": 0,
"height": 0
});

if ([Link]) {
[Link]();
}

[Link]('.ui-selected').each(function() {
var selectee = $.data(this, "selectable-item");
[Link] = true;
if (![Link] && ![Link]) {
selectee.$[Link]('ui-selected');
[Link] = false;
selectee.$[Link]('ui-unselecting');
[Link] = true;
 // selectable UNSELECTING callback
self._trigger("unselecting", event, {
unselecting: [Link]
});
}
});

$([Link]).parents().andSelf().each(function() {
var selectee = $.data(this, "selectable-item");
if (selectee) {
var doSelect = (![Link] && ![Link]) || !
selectee.$[Link]('ui-selected');
selectee.$element
.removeClass(doSelect ? "ui-unselecting" : "ui-
selected")
.addClass(doSelect ? "ui-selecting" : "ui-
unselecting");
[Link] = !doSelect;
[Link] = doSelect;
[Link] = doSelect;
// selectable (UN)SELECTING callback
if (doSelect) {
self._trigger("selecting", event, {
selecting: [Link]
});
} else {
self._trigger("unselecting", event, {
unselecting: [Link]
});
}
return false;
}
});

},

_mouseDrag: function(event) {
var self = this;
[Link] = true;

if ([Link])
return;

var options = [Link];

var x1 = [Link][0], y1 = [Link][1], x2 = [Link], y2 =

[Link];
if (x1 > x2) { var tmp = x2; x2 = x1; x1 = tmp; }
if (y1 > y2) { var tmp = y2; y2 = y1; y1 = tmp; }
[Link]({left: x1, top: y1, width: x2-x1, height: y2-y1});

[Link](function() {
var selectee = $.data(this, "selectable-item");
//prevent helper from being selected if appendTo: selectable
if (!selectee || [Link] == [Link][0])
return;
var hit = false;
if ([Link] == 'touch') {
hit = ( !([Link] > x2 || [Link] < x1 ||
[Link] > y2 || [Link] < y1) );
} else if ([Link] == 'fit') {
hit = ([Link] > x1 && [Link] < x2 &&
[Link] > y1 && [Link] < y2);
}

if (hit) {
// SELECT
if ([Link]) {
selectee.$[Link]('ui-selected');
[Link] = false;
}
if ([Link]) {
selectee.$[Link]('ui-unselecting');
[Link] = false;
}
if (![Link]) {
selectee.$[Link]('ui-selecting');
[Link] = true;
// selectable SELECTING callback
self._trigger("selecting", event, {
selecting: [Link]
});
}
} else {
// UNSELECT
if ([Link]) {
if (([Link] || [Link]) &&
[Link]) {
selectee.$[Link]('ui-selecting');
[Link] = false;
selectee.$[Link]('ui-selected');
[Link] = true;
} else {
selectee.$[Link]('ui-selecting');
[Link] = false;
if ([Link]) {
selectee.$[Link]('ui-
unselecting');
[Link] = true;
}
// selectable UNSELECTING callback
self._trigger("unselecting", event, {
unselecting: [Link]
});
}
}
if ([Link]) {
if (![Link] && ![Link] && !
[Link]) {
selectee.$[Link]('ui-selected');
[Link] = false;

selectee.$[Link]('ui-unselecting');
[Link] = true;
// selectable UNSELECTING callback
self._trigger("unselecting", event, {
unselecting: [Link]
});
 }
}
}
});

return false;
},

_mouseStop: function(event) {
var self = this;

[Link] = false;

var options = [Link];

$('.ui-unselecting', [Link][0]).each(function() {
var selectee = $.data(this, "selectable-item");
selectee.$[Link]('ui-unselecting');
[Link] = false;
[Link] = false;
self._trigger("unselected", event, {
unselected: [Link]
});
});
$('.ui-selecting', [Link][0]).each(function() {
var selectee = $.data(this, "selectable-item");
selectee.$[Link]('ui-selecting').addClass('ui-
selected');
[Link] = false;
[Link] = true;
[Link] = true;
self._trigger("selected", event, {
selected: [Link]
});
});
this._trigger("stop", event);

[Link]();

return false;
}

});

$.extend($.[Link], {
version: "1.8.24"
});

})(jQuery);

(function( $, undefined ) {

$.widget("[Link]", $.[Link], {
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 = [Link];
[Link] = {};
[Link]("ui-sortable");

//Get the items

[Link]();

//Let's determine if the items are being displayed horizontally

[Link] = [Link] ? [Link] === 'x' || (/left|
right/).test([Link][0].[Link]('float')) || (/inline|table-
cell/).test([Link][0].[Link]('display')) : false;

//Let's determine the parent's offset

[Link] = [Link]();

//Initialize mouse events for interaction

this._mouseInit();

//We're ready to go
[Link] = true

},

destroy: function() {
$.[Link]( this );
[Link]
.removeClass("ui-sortable ui-sortable-disabled");
this._mouseDestroy();

for ( var i = [Link] - 1; i >= 0; i-- )

[Link][i].[Link]([Link] + "-item");

return this;
},

_setOption: function(key, value){

if ( key === "disabled" ) {
 [Link][ key ] = value;

[Link]()
[ value ? "addClass" : "removeClass"]( "ui-sortable-
disabled" );
} else {
// Don't call widget base _setOption for disable as it adds ui-
state-disabled class
$.[Link]._setOption.apply(this, arguments);
}
},

_mouseCapture: function(event, overrideHandle) {

var that = this;

if ([Link]) {
return false;
}

if([Link] || [Link] == '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 [Link]
var currentItem = null, self = this, nodes = $
([Link]).parents().each(function() {
if($.data(this, [Link] + '-item') == self) {
currentItem = $(this);
return false;
}
});
if($.data([Link], [Link] + '-item') == self) currentItem
= $([Link]);

if(!currentItem) return false;

if([Link] && !overrideHandle) {
var validHandle = false;

$([Link],
currentItem).find("*").andSelf().each(function() { if(this == [Link])
validHandle = true; });
if(!validHandle) return false;
}

[Link] = currentItem;
this._removeCurrentsFromItems();
return true;

},

_mouseStart: function(event, overrideHandle, noActivation) {

var o = [Link], self = this;

[Link] = this;

//We only need to call refreshPositions, because the refreshItems call

has been moved to mouseCapture
[Link]();

//Create and append the visible helper

[Link] = 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

[Link] = [Link]();

//The element's absolute position on the page minus margins

[Link] = [Link]();
[Link] = {
top: [Link] - [Link],
left: [Link] - [Link]
};

$.extend([Link], {
click: { //Where the click happened, relative to the element
left: [Link] - [Link],
top: [Link] - [Link]
},
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
[Link]("position", "absolute");
[Link] = [Link]("position");

//Generate the original position

[Link] = this._generatePosition(event);
[Link] = [Link];
[Link] = [Link];

//Adjust the mouse offset relative to the helper if 'cursorAt' is

supplied
([Link] && this._adjustOffsetFromHelper([Link]));

//Cache the former DOM position

[Link] = { prev: [Link]()[0], parent:
[Link]()[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([Link][0] != [Link][0]) {
[Link]();
}

//Create the placeholder

this._createPlaceholder();

//Set a containment if given in the options

if([Link])
this._setContainment();

if([Link]) { // cursor option

if ($('body').css("cursor")) this._storedCursor = $
('body').css("cursor");
$('body').css("cursor", [Link]);
}

if([Link]) { // opacity option

if ([Link]("opacity")) this._storedOpacity =
[Link]("opacity");
[Link]("opacity", [Link]);
}

if([Link]) { // zIndex option

if ([Link]("zIndex")) this._storedZIndex =
[Link]("zIndex");
[Link]("zIndex", [Link]);
}

//Prepare scrolling
if([Link][0] != document && [Link][0].tagName !=
'HTML')
[Link] = [Link]();

//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 = [Link] - 1; i >= 0; i--)
{ [Link][i]._trigger("activate", event, self._uiHash(this)); }
}

//Prepare possible droppables

if($.[Link])
$.[Link] = this;

if ($.[Link] && ![Link])

$.[Link](this, event);

[Link] = true;
 [Link]("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

[Link] = this._generatePosition(event);
[Link] = this._convertPositionTo("absolute");

if (![Link]) {
[Link] = [Link];
}

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

if(([Link] +
[Link][0].offsetHeight) - [Link] < [Link])
[Link][0].scrollTop = scrolled =
[Link][0].scrollTop + [Link];
else if([Link] - [Link] <
[Link])
[Link][0].scrollTop = scrolled =
[Link][0].scrollTop - [Link];

if(([Link] +
[Link][0].offsetWidth) - [Link] < [Link])
[Link][0].scrollLeft = scrolled =
[Link][0].scrollLeft + [Link];
else if([Link] - [Link] <
[Link])
[Link][0].scrollLeft = scrolled =
[Link][0].scrollLeft - [Link];

} else {

if([Link] - $(document).scrollTop() <

[Link])
scrolled = $(document).scrollTop($
(document).scrollTop() - [Link]);
else if($(window).height() - ([Link] - $
(document).scrollTop()) < [Link])
scrolled = $(document).scrollTop($
(document).scrollTop() + [Link]);

if([Link] - $(document).scrollLeft() <

[Link])
scrolled = $(document).scrollLeft($
(document).scrollLeft() - [Link]);
else if($(window).width() - ([Link] - $
(document).scrollLeft()) < [Link])
scrolled = $(document).scrollLeft($
(document).scrollLeft() + [Link]);

if(scrolled !== false && $.[Link] && ![Link])

$.[Link](this, event);
}

//Regenerate the absolute position used for position checks

[Link] = this._convertPositionTo("absolute");

//Set the helper position

if(![Link] || [Link] != "y")
[Link][0].[Link] = [Link]+'px';
if(![Link] || [Link] != "x")
[Link][0].[Link] = [Link]+'px';

//Rearrange
for (var i = [Link] - 1; i >= 0; i--) {

//Cache variables and intersection, continue if no intersection

var item = [Link][i], itemElement = [Link][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 ([Link] !== [Link]) continue;

if (itemElement != [Link][0] //cannot intersect with

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

[Link] = intersection == 1 ? "down" : "up";

if ([Link] == "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($.[Link]) $.[Link](this, event);

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

[Link] = [Link];
return false;

},

_mouseStop: function(event, noPropagation) {

if(!event) return;

//If we are using droppables, inform the manager about the drop
if ($.[Link] && ![Link])
$.[Link](this, event);

if([Link]) {
var self = this;
var cur = [Link]();

[Link] = true;

$([Link]).animate({
left: [Link] - [Link] -
[Link] + ([Link][0] == [Link] ? 0 :
[Link][0].scrollLeft),
top: [Link] - [Link] - [Link] +
([Link][0] == [Link] ? 0 : [Link][0].scrollTop)
}, parseInt([Link], 10) || 500, function() {
self._clear(event);
});
} else {
this._clear(event, noPropagation);
}

return false;

},

cancel: function() {

var self = this;

if([Link]) {

this._mouseUp({ target: null });

if([Link] == "original")
[Link](this._storedCSS).removeClass("ui-
sortable-helper");
 else
[Link]();

//Post deactivating events to containers

for (var i = [Link] - 1; i >= 0; i--){
[Link][i]._trigger("deactivate", null,
self._uiHash(this));
if([Link][i].[Link]) {
[Link][i]._trigger("out", null,
self._uiHash(this));
[Link][i].[Link] = 0;
}
}

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

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

if([Link]) {
$([Link]).after([Link]);
} else {
$([Link]).prepend([Link]);
}
}

return this;

},

serialize: function(o) {

var items = this._getItemsAsjQuery(o && [Link]);

var str = []; o = o || {};

$(items).each(function() {
var res = ($([Link] || this).attr([Link] || 'id') ||
'').match([Link] || (/(.+)[-=_](.+)/));
if(res) [Link](([Link] || res[1]+'[]')+'='+([Link] &&
[Link] ? res[1] : res[2]));
});

if(![Link] && [Link]) {

[Link]([Link] + '=');
}

return [Link]('&');
 },

toArray: function(o) {

var items = this._getItemsAsjQuery(o && [Link]);

var ret = []; o = o || {};

[Link](function() { [Link]($([Link] || this).attr([Link] ||

'id') || ''); });
return ret;

},

/* Be careful with the following core functions */

_intersectsWith: function(item) {

var x1 = [Link],
x2 = x1 + [Link],
y1 = [Link],
y2 = y1 + [Link];

var l = [Link],
r = l + [Link],
t = [Link],
b = t + [Link];

var dyClick = [Link],

dxClick = [Link];

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

if( [Link] == "pointer"

|| [Link]
|| ([Link] != "pointer" &&
[Link][[Link] ? 'width' : 'height'] > item[[Link] ?
'width' : 'height'])
) {
return isOverElement;
} else {

return (l < x1 + ([Link] / 2) // Right Half

&& x2 - ([Link] / 2) < r // Left Half
&& t < y1 + ([Link] / 2) // Bottom
Half
&& y2 - ([Link] / 2) < b ); // Top
Half

}
},

_intersectsWithPointer: function(item) {

var isOverElementHeight = ([Link] === 'x') ||

$.[Link]([Link] + [Link], [Link],
[Link]),
isOverElementWidth = ([Link] === 'y') ||
$.[Link]([Link] + [Link], [Link],
[Link]),
isOverElement = isOverElementHeight && isOverElementWidth,
verticalDirection = this._getDragVerticalDirection(),
horizontalDirection = this._getDragHorizontalDirection();

if (!isOverElement)
return false;

return [Link] ?
( ((horizontalDirection && horizontalDirection == "right") ||
verticalDirection == "down") ? 2 : 1 )
: ( verticalDirection && (verticalDirection == "down" ? 2 : 1) );

},

_intersectsWithSides: function(item) {

var isOverBottomHalf = $.[Link]([Link] +

[Link], [Link] + ([Link]/2), [Link]),
isOverRightHalf = $.[Link]([Link] +
[Link], [Link] + ([Link]/2), [Link]),
verticalDirection = this._getDragVerticalDirection(),
horizontalDirection = this._getDragHorizontalDirection();

if ([Link] && horizontalDirection) {

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

},

_getDragVerticalDirection: function() {
var delta = [Link] - [Link];
return delta != 0 && (delta > 0 ? "down" : "up");
},

_getDragHorizontalDirection: function() {
var delta = [Link] - [Link];
return delta != 0 && (delta > 0 ? "right" : "left");
},

refresh: function(event) {
this._refreshItems(event);
[Link]();
return this;
},

_connectWith: function() {
var options = [Link];
return [Link] == String
? [[Link]]
: [Link];
},

_getItemsAsjQuery: function(connected) {
 var self = this;
var items = [];
var queries = [];
var connectWith = this._connectWith();

if(connectWith && connected) {

for (var i = [Link] - 1; i >= 0; i--){
var cur = $(connectWith[i]);
for (var j = [Link] - 1; j >= 0; j--){
var inst = $.data(cur[j], [Link]);
if(inst && inst != this && ![Link]) {

[Link]([$.isFunction([Link]) ?
[Link]([Link]) : $([Link],
[Link]).not(".ui-sortable-helper").not('.ui-sortable-placeholder'), inst]);
}
};
};
}

[Link]([$.isFunction([Link]) ?
[Link]([Link], null, { options: [Link], item:
[Link] }) : $([Link], [Link]).not(".ui-sortable-
helper").not('.ui-sortable-placeholder'), this]);

for (var i = [Link] - 1; i >= 0; i--){

queries[i][0].each(function() {
[Link](this);
});
};

return $(items);

},

_removeCurrentsFromItems: function() {

var list = [Link](":data(" + [Link] + "-

item)");

for (var i=0; i < [Link]; i++) {

for (var j=0; j < [Link]; j++) {

if(list[j] == [Link][i].item[0])
[Link](i,1);
};

};

},

_refreshItems: function(event) {

[Link] = [];
[Link] = [this];
var items = [Link];
var self = this;
var queries = [[$.isFunction([Link]) ?
[Link]([Link][0], event, { item: [Link] }) : $
([Link], [Link]), this]];
var connectWith = this._connectWith();

if(connectWith && [Link]) { //Shouldn't be run the first time

through due to massive slow-down
for (var i = [Link] - 1; i >= 0; i--){
var cur = $(connectWith[i]);
for (var j = [Link] - 1; j >= 0; j--){
var inst = $.data(cur[j], [Link]);
if(inst && inst != this && ![Link]) {

[Link]([$.isFunction([Link]) ?
[Link]([Link][0], event, { item: [Link] }) : $
([Link], [Link]), inst]);
[Link](inst);
}
};
};
}

for (var i = [Link] - 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]);

[Link]([Link] + '-item', targetData); // Data

for target checking (mouse manager)

[Link]({
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([Link] && [Link]) {
[Link] = this._getParentOffset();
}

for (var i = [Link] - 1; i >= 0; i--){

var item = [Link][i];

//We ignore calculating positions of all connected containers

when we're not over them
if([Link] != [Link] &&
[Link] && [Link][0] != [Link][0])
continue;
 var t = [Link] ? $
([Link], [Link]) : [Link];

if (!fast) {
[Link] = [Link]();
[Link] = [Link]();
}

var p = [Link]();
[Link] = [Link];
[Link] = [Link];
};

if([Link] && [Link]) {

[Link](this);
} else {
for (var i = [Link] - 1; i >= 0; i--){
var p = [Link][i].[Link]();
[Link][i].[Link] = [Link];
[Link][i].[Link] = [Link];
[Link][i].[Link] =
[Link][i].[Link]();
[Link][i].[Link] =
[Link][i].[Link]();
};
}

return this;
},

_createPlaceholder: function(that) {

var self = that || this, o = [Link];

if(![Link] || [Link] == String) {

var className = [Link];
[Link] = {
element: function() {

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

if(!className)
[Link] = "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 && ![Link]) 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(![Link]())
{ [Link]([Link]() -
parseInt([Link]('paddingTop')||0, 10) -
parseInt([Link]('paddingBottom')||0, 10)); };
if(![Link]())
{ [Link]([Link]() -
parseInt([Link]('paddingLeft')||0, 10) -
parseInt([Link]('paddingRight')||0, 10)); };
}
};
}

//Create the placeholder

[Link] = $([Link]([Link],
[Link]));

//Append it after the actual current item

[Link]([Link]);

//Update the size of the placeholder (TODO: Logic to fuzzy, see line
316/317)
[Link](self, [Link]);

},

_contactContainers: function(event) {

// get innermost container that intersects with item

var innermostContainer = null, innermostIndex = null;

for (var i = [Link] - 1; i >= 0; i--){

// never consider a container that's located within the item

itself
if($.[Link]([Link][0],
[Link][i].element[0]))
continue;

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

// if we've already found a container and it's more "inner"

than this, then continue
if(innermostContainer &&
$.[Link]([Link][i].element[0], [Link][0]))
continue;

innermostContainer = [Link][i];
innermostIndex = i;

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

// if no intersecting containers found, return

if(!innermostContainer) return;

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

//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 base =
[Link][[Link][innermostIndex].floating ? 'left' : 'top'];
for (var j = [Link] - 1; j >= 0; j--) {
if(!
$.[Link]([Link][innermostIndex].element[0], [Link][j].item[0]))
continue;
var cur = [Link][innermostIndex].floating ?
[Link][j].[Link]().left : [Link][j].[Link]().top;
if([Link](cur - base) < dist) {
dist = [Link](cur - base); itemWithLeastDistance =
[Link][j];
[Link] = (cur - base > 0) ? 'down' : 'up';
}
}

if(!itemWithLeastDistance && ![Link]) //Check

if dropOnEmpty is enabled
return;

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

//Update the placeholder

[Link]([Link],
[Link]);

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

},

_createHelper: function(event) {

var o = [Link];
 var helper = $.isFunction([Link]) ? $([Link]([Link][0],
[event, [Link]])) : ([Link] == 'clone' ? [Link]() :
[Link]);

if(.length) //Add the helper to the DOM if that

didn't happen already
$([Link] != 'parent' ? [Link] :
[Link][0].parentNode)[0].appendChild(helper[0]);

if(helper[0] == [Link][0])
this._storedCSS = { width: [Link][0].[Link],
height: [Link][0].[Link], position:
[Link]("position"), top: [Link]("top"), left:
[Link]("left") };

if(helper[0].[Link] == '' || [Link])

[Link]([Link]());
if(helper[0].[Link] == '' || [Link])
[Link]([Link]());

return helper;

},

_adjustOffsetFromHelper: function(obj) {
if (typeof obj == 'string') {
obj = [Link](' ');
}
if ($.isArray(obj)) {
obj = {left: +obj[0], top: +obj[1] || 0};
}
if ('left' in obj) {
[Link] = [Link] + [Link];
}
if ('right' in obj) {
[Link] = [Link] - [Link]
+ [Link];
}
if ('top' in obj) {
[Link] = [Link] + [Link];
}
if ('bottom' in obj) {
[Link] = [Link] -
[Link] + [Link];
}
},

_getParentOffset: function() {

//Get the offsetParent and cache its position

[Link] = [Link]();
var po = [Link]();

// 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([Link] == 'absolute' && [Link][0] != document
&& $.[Link]([Link][0], [Link][0])) {
[Link] += [Link]();
[Link] += [Link]();
}

if(([Link][0] == [Link]) //This needs to be actually

done for all browsers, since pageX/pageY includes this information
|| ([Link][0].tagName &&
[Link][0].[Link]() == 'html' && $.[Link])) //Ugly IE
fix
po = { top: 0, left: 0 };

return {
top: [Link] +
(parseInt([Link]("borderTopWidth"),10) || 0),
left: [Link] +
(parseInt([Link]("borderLeftWidth"),10) || 0)
};

},

_getRelativeOffset: function() {

if([Link] == "relative") {
var p = [Link]();
return {
top: [Link] - (parseInt([Link]("top"),10) || 0) +
[Link](),
left: [Link] - (parseInt([Link]("left"),10) || 0)
+ [Link]()
};
} else {
return { top: 0, left: 0 };
}

},

_cacheMargins: function() {
[Link] = {
left: (parseInt([Link]("marginLeft"),10) || 0),
top: (parseInt([Link]("marginTop"),10) || 0)
};
},

_cacheHelperProportions: function() {
[Link] = {
width: [Link](),
height: [Link]()
};
},

_setContainment: function() {

var o = [Link];
if([Link] == 'parent') [Link] =
[Link][0].parentNode;
if([Link] == 'document' || [Link] == 'window')
[Link] = [
0 - [Link] - [Link],
0 - [Link] - [Link],
$([Link] == 'document' ? document : window).width() -
[Link] - [Link],
($([Link] == 'document' ? document : window).height() ||
[Link]) - [Link] -
[Link]
];

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

[Link] = [
[Link] + (parseInt($(ce).css("borderLeftWidth"),10) || 0)
+ (parseInt($(ce).css("paddingLeft"),10) || 0) - [Link],
[Link] + (parseInt($(ce).css("borderTopWidth"),10) || 0) +
(parseInt($(ce).css("paddingTop"),10) || 0) - [Link],
[Link]+(over ? [Link]([Link],[Link]) :
[Link]) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($
(ce).css("paddingRight"),10) || 0) - [Link] -
[Link],
[Link]+(over ? [Link]([Link],[Link]) :
[Link]) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($
(ce).css("paddingBottom"),10) || 0) - [Link] -
[Link]
];
}

},

_convertPositionTo: function(d, pos) {

if(!pos) pos = [Link];

var mod = d == "absolute" ? 1 : -1;
var o = [Link], scroll = [Link] == 'absolute' && !
([Link][0] != document && $.[Link]([Link][0],
[Link][0])) ? [Link] : [Link], scrollIsRootNode =
(/(html|body)/i).test(scroll[0].tagName);

return {
top: (
[Link]
// The absolute mouse position
+ [Link] * mod
// Only for relative positioned nodes: Relative
offset from element to offset parent
+ [Link] * mod
// The offsetParent's offset without borders
(offset + border)
- ($.[Link] && [Link] == 'fixed' ? 0 :
( [Link] == 'fixed' ? -[Link]() : ( scrollIsRootNode
? 0 : [Link]() ) ) * mod)
),
left: (
 [Link]
// The absolute mouse position
+ [Link] * mod
// Only for relative positioned nodes: Relative
offset from element to offset parent
+ [Link] * mod
// The offsetParent's offset without borders
(offset + border)
- ($.[Link] && [Link] == 'fixed' ? 0 :
( [Link] == 'fixed' ? -[Link]() :
scrollIsRootNode ? 0 : [Link]() ) * mod)
)
};

},

_generatePosition: function(event) {

var o = [Link], scroll = [Link] == 'absolute' && !

([Link][0] != document && $.[Link]([Link][0],
[Link][0])) ? [Link] : [Link], 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([Link] == 'relative' && !([Link][0] != document
&& [Link][0] != [Link][0])) {
[Link] = this._getRelativeOffset();
}

var pageX = [Link];

var pageY = [Link];

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

if([Link]) { //If we are not dragging yet, we won't

check for options

if([Link]) {
if([Link] - [Link] <
[Link][0]) pageX = [Link][0] + [Link];
if([Link] - [Link] <
[Link][1]) pageY = [Link][1] + [Link];
if([Link] - [Link] >
[Link][2]) pageX = [Link][2] + [Link];
if([Link] - [Link] >
[Link][3]) pageY = [Link][3] + [Link];
}

if([Link]) {
var top = [Link] + [Link]((pageY -
[Link]) / [Link][1]) * [Link][1];
pageY = [Link] ? (!(top - [Link] <
[Link][1] || top - [Link] > [Link][3]) ? top :
(!(top - [Link] < [Link][1]) ? top - [Link][1] : top +
[Link][1])) : top;

var left = [Link] + [Link]((pageX -

[Link]) / [Link][0]) * [Link][0];
pageX = [Link] ? (!(left - [Link]
< [Link][0] || left - [Link] > [Link][2]) ?
left : (!(left - [Link] < [Link][0]) ? left - [Link][0] :
left + [Link][0])) : left;
}

return {
top: (
pageY
// The absolute mouse position
- [Link]
// Click offset (relative to the element)
- [Link]
// Only for relative positioned nodes: Relative
offset from element to offset parent
- [Link]
// The offsetParent's offset without borders
(offset + border)
+ ($.[Link] && [Link] == 'fixed' ? 0 :
( [Link] == 'fixed' ? -[Link]() : ( scrollIsRootNode
? 0 : [Link]() ) ))
),
left: (
pageX
// The absolute mouse position
- [Link]
// Click offset (relative to the element)
- [Link]
// Only for relative positioned nodes: Relative
offset from element to offset parent
- [Link]
// The offsetParent's offset without borders
(offset + border)
+ ($.[Link] && [Link] == 'fixed' ? 0 :
( [Link] == 'fixed' ? -[Link]() :
scrollIsRootNode ? 0 : [Link]() ))
)
};

},

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

a ? a[0].appendChild([Link][0]) :
[Link][0].[Link]([Link][0], ([Link] == 'down' ?
[Link][0] : [Link][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
[Link] = [Link] ? ++[Link] : 1;
var self = this, counter = [Link];

[Link](function() {
if(counter == [Link]) [Link](!
hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
},0);

},

_clear: function(event, noPropagation) {

[Link] = 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 = [], self = this;

// 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 && [Link]().length)
[Link]([Link]);
this._noFinalSort = null;

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

if([Link] && !noPropagation)

[Link](function(event) { this._trigger("receive", event,
this._uiHash([Link])); });
if(([Link] || [Link] !=
[Link]().not(".ui-sortable-helper")[0] || [Link] !=
[Link]()[0]) && !noPropagation)
[Link](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 !== [Link]) {
if(!noPropagation) {
[Link](function(event)
{ this._trigger("remove", event, this._uiHash()); });
[Link]((function(c) { return function(event)
{ c._trigger("receive", event, this._uiHash(this)); }; }).call(this,
[Link]));
 [Link]((function(c) { return function(event)
{ c._trigger("update", event, this._uiHash(this)); }; }).call(this,
[Link]));
}
}

//Post events to containers

for (var i = [Link] - 1; i >= 0; i--){
if(!noPropagation) [Link]((function(c) { return
function(event) { c._trigger("deactivate", event,
this._uiHash(this)); }; }).call(this, [Link][i]));
if([Link][i].[Link]) {
[Link]((function(c) { return function(event)
{ c._trigger("out", event, this._uiHash(this)); }; }).call(this,
[Link][i]));
[Link][i].[Link] = 0;
}
}

//Do what was originally in plugins

if(this._storedCursor) $('body').css("cursor", this._storedCursor);
//Reset cursor
if(this._storedOpacity) [Link]("opacity",
this._storedOpacity); //Reset opacity
if(this._storedZIndex) [Link]("zIndex", this._storedZIndex ==
'auto' ? '' : this._storedZIndex); //Reset z-index

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

[Link] = false;
return false;
}

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

//$([Link][0]).remove(); would have been the jQuery way -

unfortunately, it unbinds ALL events from the original node!
[Link][0].[Link]([Link][0]);

if([Link][0] != [Link][0]) [Link]();

[Link] = null;

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

[Link] = false;
return true;

},
 _trigger: function() {
if ($.[Link]._trigger.apply(this, arguments) === false) {
[Link]();
}
},

_uiHash: function(inst) {
var self = inst || this;
return {
helper: [Link],
placeholder: [Link] || $([]),
position: [Link],
originalPosition: [Link],
offset: [Link],
item: [Link],
sender: inst ? [Link] : null
};
}

});

$.extend($.[Link], {
version: "1.8.24"
});

})(jQuery);

;[Link] || (function($, undefined) {

$.effects = {};

/******************************************************************************/
/****************************** COLOR ANIMATIONS ******************************/
/******************************************************************************/

// override the animation for color styles

$.each(['backgroundColor', 'borderBottomColor', 'borderLeftColor',
'borderRightColor', 'borderTopColor', 'borderColor', 'color',
'outlineColor'],
function(i, attr) {
$.[Link][attr] = function(fx) {
if (![Link]) {
[Link] = getColor([Link], attr);
[Link] = getRGB([Link]);
[Link] = true;
}

[Link][attr] = 'rgb(' +
[Link]([Link](parseInt(([Link] * ([Link][0] - [Link][0])) +
[Link][0], 10), 255), 0) + ',' +
[Link]([Link](parseInt(([Link] * ([Link][1] - [Link][1])) +
[Link][1], 10), 255), 0) + ',' +
[Link]([Link](parseInt(([Link] * ([Link][2] - [Link][2])) +
[Link][2], 10), 255), 0) + ')';
};
});
// Color Conversion functions from highlightFade
// By Blair Mitchelmore
// [Link]

// Parse strings looking for color tuples [255,255,255]

function getRGB(color) {
var result;

// Check if we're already dealing with an array of colors

if ( color && [Link] == Array && [Link] == 3 )
return color;

// Look for rgb(num,num,num)

if (result = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]
{1,3})\s*\)/.exec(color))
return [parseInt(result[1],10), parseInt(result[2],10),
parseInt(result[3],10)];

// Look for rgb(num%,num%,num%)

if (result = /rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-
9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(color))
return [parseFloat(result[1])*2.55,
parseFloat(result[2])*2.55, parseFloat(result[3])*2.55];

// Look for #a0b1c2

if (result = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]
{2})/.exec(color))
return [parseInt(result[1],16), parseInt(result[2],16),
parseInt(result[3],16)];

// Look for #fff

if (result = /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(color))
return [parseInt(result[1]+result[1],16),
parseInt(result[2]+result[2],16), parseInt(result[3]+result[3],16)];

// Look for rgba(0, 0, 0, 0) == transparent in Safari 3

if (result = /rgba\(0, 0, 0, 0\)/.exec(color))
return colors['transparent'];

// Otherwise, we're most likely dealing with a named color

return colors[$.trim(color).toLowerCase()];
}

function getColor(elem, attr) {

var color;

do {
// jQuery <1.4.3 uses curCSS, in 1.4.3 - 1.7.2 curCSS =
css, 1.8+ only has css
color = ($.curCSS || $.css)(elem, attr);

// Keep going until we find an element that has color, or

we hit the body
if ( color != '' && color != 'transparent' ||
$.nodeName(elem, "body") )
break;

attr = "backgroundColor";
 } while ( elem = [Link] );

return getRGB(color);
};

// Some named colors to work with

// From Interface by Stefan Petre
// [Link]

var colors = {
aqua:[0,255,255],
azure:[240,255,255],
beige:[245,245,220],
black:[0,0,0],
blue:[0,0,255],
brown:[165,42,42],
cyan:[0,255,255],
darkblue:[0,0,139],
darkcyan:[0,139,139],
darkgrey:[169,169,169],
darkgreen:[0,100,0],
darkkhaki:[189,183,107],
darkmagenta:[139,0,139],
darkolivegreen:[85,107,47],
darkorange:[255,140,0],
darkorchid:[153,50,204],
darkred:[139,0,0],
darksalmon:[233,150,122],
darkviolet:[148,0,211],
fuchsia:[255,0,255],
gold:[255,215,0],
green:[0,128,0],
indigo:[75,0,130],
khaki:[240,230,140],
lightblue:[173,216,230],
lightcyan:[224,255,255],
lightgreen:[144,238,144],
lightgrey:[211,211,211],
lightpink:[255,182,193],
lightyellow:[255,255,224],
lime:[0,255,0],
magenta:[255,0,255],
maroon:[128,0,0],
navy:[0,0,128],
olive:[128,128,0],
orange:[255,165,0],
pink:[255,192,203],
purple:[128,0,128],
violet:[128,0,128],
red:[255,0,0],
silver:[192,192,192],
white:[255,255,255],
yellow:[255,255,0],
transparent: [255,255,255]
};

/******************************************************************************/
/****************************** CLASS ANIMATIONS ******************************/
/******************************************************************************/

var classAnimationActions = ['add', 'remove', 'toggle'],

shorthandStyles = {
border: 1,
borderBottom: 1,
borderColor: 1,
borderLeft: 1,
borderRight: 1,
borderTop: 1,
borderWidth: 1,
margin: 1,
padding: 1
};

function getElementStyles() {
var style = [Link]
? [Link](this, null)
: [Link],
newStyle = {},
key,
camelCase;

// webkit enumerates style porperties

if (style && [Link] && style[0] && style[style[0]]) {
var len = [Link];
while (len--) {
key = style[len];
if (typeof style[key] == 'string') {
camelCase = [Link](/\-(\w)/g, function(all, letter){
return [Link]();
});
newStyle[camelCase] = style[key];
}
}
} else {
for (key in style) {
if (typeof style[key] === 'string') {
newStyle[key] = style[key];
}
}
}

return newStyle;
}

function filterStyles(styles) {
var name, value;
for (name in styles) {
value = styles[name];
if (
// ignore null and undefined values
value == null ||
// ignore functions (when does this occur?)
$.isFunction(value) ||
// shorthand styles that need to be expanded
name in shorthandStyles ||
// ignore scrollbars (break in IE)
 (/scrollbar/).test(name) ||

// only colors or values that can be converted to numbers

(!(/color/i).test(name) && isNaN(parseFloat(value)))
) {
delete styles[name];
}
}

return styles;
}

function styleDifference(oldStyle, newStyle) {

var diff = { _: 0 }, // [Link]
name;

for (name in newStyle) {

if (oldStyle[name] != newStyle[name]) {
diff[name] = newStyle[name];
}
}

return diff;
}

$.[Link] = function(value, duration, easing, callback) {

if ($.isFunction(easing)) {
callback = easing;
easing = null;
}

return [Link](function() {
var that = $(this),
originalStyleAttr = [Link]('style') || ' ',
originalStyle = filterStyles([Link](this)),
newStyle,
className = [Link]('class') || "";

$.each(classAnimationActions, function(i, action) {

if (value[action]) {
that[action + 'Class'](value[action]);
}
});
newStyle = filterStyles([Link](this));
[Link]('class', className);

[Link](styleDifference(originalStyle, newStyle), {
queue: false,
duration: duration,
easing: easing,
complete: function() {
$.each(classAnimationActions, function(i, action) {
if (value[action]) { that[action + 'Class']
(value[action]); }
});
// work around bug in IE by clearing the cssText before
setting it
if (typeof [Link]('style') == 'object') {
[Link]('style').cssText = '';
 [Link]('style').cssText = originalStyleAttr;
} else {
[Link]('style', originalStyleAttr);
}
if (callback) { [Link](this, arguments); }
$.dequeue( this );
}
});
});
};

$.[Link]({
_addClass: $.[Link],
addClass: function(classNames, speed, easing, callback) {
return speed ? $.[Link](this, [{ add:
classNames },speed,easing,callback]) : this._addClass(classNames);
},

_removeClass: $.[Link],
removeClass: function(classNames,speed,easing,callback) {
return speed ? $.[Link](this, [{ remove: classNames
},speed,easing,callback]) : this._removeClass(classNames);
},

_toggleClass: $.[Link],
toggleClass: function(classNames, force, speed, easing, callback) {
if ( typeof force == "boolean" || force === undefined ) {
if ( !speed ) {
// without speed parameter;
return this._toggleClass(classNames, force);
} else {
return $.[Link](this, [(force?
{add:classNames}:{remove:classNames}),speed,easing,callback]);
}
} else {
// without switch parameter;
return $.[Link](this, [{ toggle:
classNames },force,speed,easing]);
}
},

switchClass: function(remove,add,speed,easing,callback) {
return $.[Link](this, [{ add: add, remove:
remove },speed,easing,callback]);
}
});

/******************************************************************************/
/*********************************** EFFECTS **********************************/
/******************************************************************************/

$.extend($.effects, {
version: "1.8.24",

// Saves a set of properties in a data storage

save: function(element, set) {
for(var i=0; i < [Link]; i++) {
 if(set[i] !== null) [Link]("[Link]."+set[i],
element[0].style[set[i]]);
}
},

// Restores a set of previously saved properties from a data storage

restore: function(element, set) {
for(var i=0; i < [Link]; i++) {
if(set[i] !== null) [Link](set[i],
[Link]("[Link]."+set[i]));
}
},

setMode: function(el, mode) {

if (mode == 'toggle') mode = [Link](':hidden') ? 'show' : 'hide'; // Set
for toggle
return mode;
},

getBaseline: function(origin, original) { // Translates a [top,left] array

into a baseline value
// this should be a little more flexible in the future to handle a
string & hash
var y, x;
switch (origin[0]) {
case 'top': y = 0; break;
case 'middle': y = 0.5; break;
case 'bottom': y = 1; break;
default: y = origin[0] / [Link];
};
switch (origin[1]) {
case 'left': x = 0; break;
case 'center': x = 0.5; break;
case 'right': x = 1; break;
default: x = origin[1] / [Link];
};
return {x: x, y: y};
},

// Wraps the element around a wrapper that copies position properties

createWrapper: function(element) {

// if the element is already wrapped, return it

if ([Link]().is('.ui-effects-wrapper')) {
return [Link]();
}

// wrap the element

var props = {
width: [Link](true),
height: [Link](true),
'float': [Link]('float')
},
wrapper = $('<div></div>')
.addClass('ui-effects-wrapper')
.css({
fontSize: '100%',
background: 'transparent',
border: 'none',
 margin: 0,
padding: 0
}),
active = [Link];

// support: Firefox
// Firefox incorrectly exposes anonymous content
// [Link]
try {
[Link];
} catch( e ) {
active = [Link];
}

[Link]( wrapper );

// Fixes #7595 - Elements lose focus when wrapped.

if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
$( active ).focus();
}

wrapper = [Link](); //Hotfix for jQuery 1.4 since some change

in wrap() seems to actually loose the reference to the wrapped element

// transfer positioning properties to the wrapper

if ([Link]('position') == 'static') {
[Link]({ position: 'relative' });
[Link]({ position: 'relative' });
} else {
$.extend(props, {
position: [Link]('position'),
zIndex: [Link]('z-index')
});
$.each(['top', 'left', 'bottom', 'right'], function(i, pos) {
props[pos] = [Link](pos);
if (isNaN(parseInt(props[pos], 10))) {
props[pos] = 'auto';
}
});
[Link]({position: 'relative', top: 0, left: 0, right:
'auto', bottom: 'auto' });
}

return [Link](props).show();
},

removeWrapper: function(element) {
var parent,
active = [Link];

if ([Link]().is('.ui-effects-wrapper')) {
parent = [Link]().replaceWith(element);
// Fixes #7595 - Elements lose focus when wrapped.
if ( element[ 0 ] === active || $.contains( element[ 0 ],
active ) ) {
$( active ).focus();
}
return parent;
}
 return element;
},

setTransition: function(element, list, factor, value) {

value = value || {};
$.each(list, function(i, x){
var unit = [Link](x);
if (unit[0] > 0) value[x] = unit[0] * factor + unit[1];
});
return value;
}
});

function _normalizeArguments(effect, options, speed, callback) {

// shift params for method overloading
if (typeof effect == 'object') {
callback = options;
speed = null;
options = effect;
effect = [Link];
}
if ($.isFunction(options)) {
callback = options;
speed = null;
options = {};
}
if (typeof options == 'number' || $.[Link][options]) {
callback = speed;
speed = options;
options = {};
}
if ($.isFunction(speed)) {
callback = speed;
speed = null;
}

options = options || {};

speed = speed || [Link];

speed = $.[Link] ? 0 : typeof speed == 'number'
? speed : speed in $.[Link] ? $.[Link][speed] :
$.[Link]._default;

callback = callback || [Link];

return [effect, options, speed, callback];

}

function standardSpeed( speed ) {

// valid standard speeds
if ( !speed || typeof speed === "number" || $.[Link][ speed ] ) {
return true;
}

// invalid strings - treat as "normal" speed

if ( typeof speed === "string" && !$.effects[ speed ] ) {
return true;
 }

return false;
}

$.[Link]({
effect: function(effect, options, speed, callback) {
var args = _normalizeArguments.apply(this, arguments),
// TODO: make effects take actual parameters instead of a hash
args2 = {
options: args[1],
duration: args[2],
callback: args[3]
},
mode = [Link],
effectMethod = $.effects[effect];

if ( $.[Link] || !effectMethod ) {
// delegate to the original method (e.g., .show()) if possible
if ( mode ) {
return this[ mode ]( [Link], [Link] );
} else {
return [Link](function() {
if ( [Link] ) {
[Link]( this );
}
});
}
}

return [Link](this, args2);

},

_show: $.[Link],
show: function(speed) {
if ( standardSpeed( speed ) ) {
return this._show.apply(this, arguments);
} else {
var args = _normalizeArguments.apply(this, arguments);
args[1].mode = 'show';
return [Link](this, args);
}
},

_hide: $.[Link],
hide: function(speed) {
if ( standardSpeed( speed ) ) {
return this._hide.apply(this, arguments);
} else {
var args = _normalizeArguments.apply(this, arguments);
args[1].mode = 'hide';
return [Link](this, args);
}
},

// jQuery core overloads toggle and creates _toggle

__toggle: $.[Link],
toggle: function(speed) {
if ( standardSpeed( speed ) || typeof speed === "boolean" ||
$.isFunction( speed ) ) {
return this.__toggle.apply(this, arguments);
} else {
var args = _normalizeArguments.apply(this, arguments);
args[1].mode = 'toggle';
return [Link](this, args);
}
},

// helper functions
cssUnit: function(key) {
var style = [Link](key), val = [];
$.each( ['em','px','%','pt'], function(i, unit){
if([Link](unit) > 0)
val = [parseFloat(style), unit];
});
return val;
}
});

/******************************************************************************/
/*********************************** EASING ***********************************/
/******************************************************************************/

// based on easing equations from Robert Penner

([Link]

var baseEasings = {};

$.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {

baseEasings[ name ] = function( p ) {
return [Link]( p, i + 2 );
};
});

$.extend( baseEasings, {
Sine: function ( p ) {
return 1 - [Link]( p * [Link] / 2 );
},
Circ: function ( p ) {
return 1 - [Link]( 1 - p * p );
},
Elastic: function( p ) {
return p === 0 || p === 1 ? p :
-[Link]( 2, 8 * (p - 1) ) * [Link]( ( (p - 1) * 80 - 7.5 ) *
[Link] / 15 );
},
Back: function( p ) {
return p * p * ( 3 * p - 2 );
},
Bounce: function ( p ) {
var pow2,
bounce = 4;

while ( p < ( ( pow2 = [Link]( 2, --bounce ) ) - 1 ) / 11 ) {}

return 1 / [Link]( 4, 3 - bounce ) - 7.5625 * [Link]( ( pow2 * 3 -
2 ) / 22 - p, 2 );
 }
});

$.each( baseEasings, function( name, easeIn ) {

$.easing[ "easeIn" + name ] = easeIn;
$.easing[ "easeOut" + name ] = function( p ) {
return 1 - easeIn( 1 - p );
};
$.easing[ "easeInOut" + name ] = function( p ) {
return p < .5 ?
easeIn( p * 2 ) / 2 :
easeIn( p * -2 + 2 ) / -2 + 1;
};
});

})(jQuery);

(function( $, undefined ) {

$.[Link] = function(o) {

return [Link](function() {

// Create element
var el = $(this), props = ['position','top','bottom','left','right'];

// Set options
var mode = $.[Link](el, [Link] || 'hide'); // Set Mode
var direction = [Link] || 'vertical'; // Default direction

// Adjust
$.[Link](el, props); [Link](); // Save & Show
var wrapper = $.[Link](el).css({overflow:'hidden'}); //
Create Wrapper
var ref = (direction == 'vertical') ? 'height' : 'width';
var distance = (direction == 'vertical') ? [Link]() :
[Link]();
if(mode == 'show') [Link](ref, 0); // Shift

// Animation
var animation = {};
animation[ref] = mode == 'show' ? distance : 0;

// Animate
[Link](animation, [Link], [Link], function() {
if(mode == 'hide') [Link](); // Hide
$.[Link](el, props); $.[Link](el); //
Restore
if([Link]) [Link](el[0], arguments); // Callback
[Link]();
});

});

};

})(jQuery);

(function( $, undefined ) {
$.[Link] = function(o) {

return [Link](function() {

// Create element
var el = $(this), props = ['position','top','bottom','left','right'];

// Set options
var mode = $.[Link](el, [Link] || 'effect'); // Set
Mode
var direction = [Link] || 'up'; // Default direction
var distance = [Link] || 20; // Default distance
var times = [Link] || 5; // Default # of times
var speed = [Link] || 250; // Default speed per bounce
if (/show|hide/.test(mode)) [Link]('opacity'); // Avoid touching
opacity to prevent clearType and PNG issues in IE

// Adjust
$.[Link](el, props); [Link](); // Save & Show
$.[Link](el); // Create Wrapper
var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
var motion = (direction == 'up' || direction == 'left') ? 'pos' :
'neg';
var distance = [Link] || (ref == 'top' ?
[Link](true) / 3 : [Link](true) / 3);
if (mode == 'show') [Link]('opacity', 0).css(ref, motion == 'pos' ? -
distance : distance); // Shift
if (mode == 'hide') distance = distance / (times * 2);
if (mode != 'hide') times--;

// Animate
if (mode == 'show') { // Show Bounce
var animation = {opacity: 1};
animation[ref] = (motion == 'pos' ? '+=' : '-=') + distance;
[Link](animation, speed / 2, [Link]);
distance = distance / 2;
times--;
};
for (var i = 0; i < times; i++) { // Bounces
var animation1 = {}, animation2 = {};
animation1[ref] = (motion == 'pos' ? '-=' : '+=') + distance;
animation2[ref] = (motion == 'pos' ? '+=' : '-=') + distance;
[Link](animation1, speed / 2,
[Link]).animate(animation2, speed / 2, [Link]);
distance = (mode == 'hide') ? distance * 2 : distance / 2;
};
if (mode == 'hide') { // Last Bounce
var animation = {opacity: 0};
animation[ref] = (motion == 'pos' ? '-=' : '+=') + distance;
[Link](animation, speed / 2, [Link], function(){
[Link](); // Hide
$.[Link](el, props);
$.[Link](el); // Restore
if([Link]) [Link](this, arguments); //
Callback
});
} else {
var animation1 = {}, animation2 = {};
 animation1[ref] = (motion == 'pos' ? '-=' : '+=') + distance;
animation2[ref] = (motion == 'pos' ? '+=' : '-=') + distance;
[Link](animation1, speed / 2,
[Link]).animate(animation2, speed / 2, [Link], function(){
$.[Link](el, props);
$.[Link](el); // Restore
if([Link]) [Link](this, arguments); //
Callback
});
};
[Link]('fx', function() { [Link](); });
[Link]();
});

};

})(jQuery);

(function( $, undefined ) {

$.[Link] = function(o) {

return [Link](function() {

// Create element
var el = $(this), props =
['position','top','bottom','left','right','height','width'];

// Set options
var mode = $.[Link](el, [Link] || 'hide'); // Set Mode
var direction = [Link] || 'vertical'; // Default direction

// Adjust
$.[Link](el, props); [Link](); // Save & Show
var wrapper = $.[Link](el).css({overflow:'hidden'}); //
Create Wrapper
var animate = el[0].tagName == 'IMG' ? wrapper : el;
var ref = {
size: (direction == 'vertical') ? 'height' : 'width',
position: (direction == 'vertical') ? 'top' : 'left'
};
var distance = (direction == 'vertical') ? [Link]() :
[Link]();
if(mode == 'show') { [Link]([Link], 0);
[Link]([Link], distance / 2); } // Shift

// Animation
var animation = {};
animation[[Link]] = mode == 'show' ? distance : 0;
animation[[Link]] = mode == 'show' ? 0 : distance / 2;

// Animate
[Link](animation, { queue: false, duration: [Link],
easing: [Link], complete: function() {
if(mode == 'hide') [Link](); // Hide
$.[Link](el, props); $.[Link](el); //
Restore
if([Link]) [Link](el[0], arguments); // Callback
[Link]();
 }});

});

};

})(jQuery);

(function( $, undefined ) {

$.[Link] = function(o) {

return [Link](function() {

// Create element
var el = $(this), props =
['position','top','bottom','left','right','opacity'];

// Set options
var mode = $.[Link](el, [Link] || 'hide'); // Set Mode
var direction = [Link] || 'left'; // Default Direction

// Adjust
$.[Link](el, props); [Link](); // Save & Show
$.[Link](el); // Create Wrapper
var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
var motion = (direction == 'up' || direction == 'left') ? 'pos' :
'neg';
var distance = [Link] || (ref == 'top' ?
[Link]( true ) / 2 : [Link]( true ) / 2);
if (mode == 'show') [Link]('opacity', 0).css(ref, motion == 'pos' ? -
distance : distance); // Shift

// Animation
var animation = {opacity: mode == 'show' ? 1 : 0};
animation[ref] = (mode == 'show' ? (motion == 'pos' ? '+=' : '-=') :
(motion == 'pos' ? '-=' : '+=')) + distance;

// Animate
[Link](animation, { queue: false, duration: [Link], easing:
[Link], complete: function() {
if(mode == 'hide') [Link](); // Hide
$.[Link](el, props); $.[Link](el); //
Restore
if([Link]) [Link](this, arguments); // Callback
[Link]();
}});

});

};

})(jQuery);

(function( $, undefined ) {

$.[Link] = function(o) {

return [Link](function() {
 var rows = [Link] ? [Link]([Link]([Link])) : 3;
var cells = [Link] ? [Link]([Link]([Link])) : 3;

[Link] = [Link] == 'toggle' ? ($(this).is(':visible') ?

'hide' : 'show') : [Link];
var el = $(this).show().css('visibility', 'hidden');
var offset = [Link]();

//Substract the margins - not fixing the problem yet.

[Link] -= parseInt([Link]("marginTop"),10) || 0;
[Link] -= parseInt([Link]("marginLeft"),10) || 0;

var width = [Link](true);

var height = [Link](true);

for(var i=0;i<rows;i++) { // =
for(var j=0;j<cells;j++) { // ||
el
.clone()
.appendTo('body')
.wrap('<div></div>')
.css({
position: 'absolute',
visibility: 'visible',
left: -j*(width/cells),
top: -i*(height/rows)
})
.parent()
.addClass('ui-effects-explode')
.css({
position: 'absolute',
overflow: 'hidden',
width: width/cells,
height: height/rows,
left: [Link] + j*(width/cells) + ([Link]
== 'show' ? ([Link](cells/2))*(width/cells) : 0),
top: [Link] + i*(height/rows) + ([Link]
== 'show' ? ([Link](rows/2))*(height/rows) : 0),
opacity: [Link] == 'show' ? 0 : 1
}).animate({
left: [Link] + j*(width/cells) + ([Link]
== 'show' ? 0 : ([Link](cells/2))*(width/cells)),
top: [Link] + i*(height/rows) + ([Link]
== 'show' ? 0 : ([Link](rows/2))*(height/rows)),
opacity: [Link] == 'show' ? 1 : 0
}, [Link] || 500);
}
}

// Set a timeout, to call the callback approx. when the other animations have
finished
setTimeout(function() {

[Link] == 'show' ? [Link]({ visibility: 'visible' }) : [Link]({

visibility: 'visible' }).hide();
if([Link]) [Link](el[0]); // Callback
[Link]();
 $('[Link]-effects-explode').remove();

}, [Link] || 500);

});

};

})(jQuery);

(function( $, undefined ) {

$.[Link] = function(o) {
return [Link](function() {
var elem = $(this),
mode = $.[Link](elem, [Link] || 'hide');

[Link]({ opacity: mode }, {

queue: false,
duration: [Link],
easing: [Link],
complete: function() {
([Link] && [Link](this, arguments));
[Link]();
}
});
});
};

})(jQuery);

(function( $, undefined ) {

$.[Link] = function(o) {

return [Link](function() {

// Create element
var el = $(this), props = ['position','top','bottom','left','right'];

// Set options
var mode = $.[Link](el, [Link] || 'hide'); // Set Mode
var size = [Link] || 15; // Default fold size
var horizFirst = !(![Link]); // Ensure a boolean value
var duration = [Link] ? [Link] / 2 : $.[Link]._default / 2;

// Adjust
$.[Link](el, props); [Link](); // Save & Show
var wrapper = $.[Link](el).css({overflow:'hidden'}); //
Create Wrapper
var widthFirst = ((mode == 'show') != horizFirst);
var ref = widthFirst ? ['width', 'height'] : ['height', 'width'];
var distance = widthFirst ? [[Link](), [Link]()] :
[[Link](), [Link]()];
var percent = /([0-9]+)%/.exec(size);
if(percent) size = parseInt(percent[1],10) / 100 * distance[mode ==
'hide' ? 0 : 1];
if(mode == 'show') [Link](horizFirst ? {height: 0, width: size} :
{height: size, width: 0}); // Shift

// Animation
var animation1 = {}, animation2 = {};
animation1[ref[0]] = mode == 'show' ? distance[0] : size;
animation2[ref[1]] = mode == 'show' ? distance[1] : 0;

// Animate
[Link](animation1, duration, [Link])
.animate(animation2, duration, [Link], function() {
if(mode == 'hide') [Link](); // Hide
$.[Link](el, props); $.[Link](el); //
Restore
if([Link]) [Link](el[0], arguments); // Callback
[Link]();
});

});

};

})(jQuery);

(function( $, undefined ) {

$.[Link] = function(o) {
return [Link](function() {
var elem = $(this),
props = ['backgroundImage', 'backgroundColor', 'opacity'],
mode = $.[Link](elem, [Link] || 'show'),
animation = {
backgroundColor: [Link]('backgroundColor')
};

if (mode == 'hide') {
[Link] = 0;
}

$.[Link](elem, props);
elem
.show()
.css({
backgroundImage: 'none',
backgroundColor: [Link] || '#ffff99'
})
.animate(animation, {
queue: false,
duration: [Link],
easing: [Link],
complete: function() {
(mode == 'hide' && [Link]());
$.[Link](elem, props);
(mode == 'show' && !$.[Link] &&
[Link]('filter'));
([Link] && [Link](this, arguments));
[Link]();
}
});
});
};

})(jQuery);

(function( $, undefined ) {

$.[Link] = function(o) {
return [Link](function() {
var elem = $(this),
mode = $.[Link](elem, [Link] || 'show'),
times = (([Link] || 5) * 2) - 1,
duration = [Link] ? [Link] / 2 : $.[Link]._default /
2,
isVisible = [Link](':visible'),
animateTo = 0;

if (!isVisible) {
[Link]('opacity', 0).show();
animateTo = 1;
}

if ((mode == 'hide' && isVisible) || (mode == 'show' && !isVisible)) {

times--;
}

for (var i = 0; i < times; i++) {

[Link]({ opacity: animateTo }, duration, [Link]);
animateTo = (animateTo + 1) % 2;
}

[Link]({ opacity: animateTo }, duration, [Link],

function() {
if (animateTo == 0) {
[Link]();
}
([Link] && [Link](this, arguments));
});

elem
.queue('fx', function() { [Link](); })
.dequeue();
});
};

})(jQuery);

(function( $, undefined ) {

$.[Link] = function(o) {
return [Link](function() {
var elem = $(this),
mode = $.[Link](elem, [Link] || 'hide'),
percent = parseInt([Link], 10) || 150,
factor = percent / 100,
original = { height: [Link](), width: [Link]() };

$.extend([Link], {
fade: true,
mode: mode,
 percent: mode == 'hide' ? percent : 100,
from: mode == 'hide'
? original
: {
height: [Link] * factor,
width: [Link] * factor
}
});

[Link]('scale', [Link], [Link], [Link]);

[Link]();
});
};

$.[Link] = function(o) {

return [Link](function() {

// Create element
var el = $(this);

// Set options
var options = $.extend(true, {}, [Link]);
var mode = $.[Link](el, [Link] || 'effect'); // Set
Mode
var percent = parseInt([Link],10) ||
(parseInt([Link],10) == 0 ? 0 : (mode == 'hide' ? 0 : 100)); // Set
default scaling percent
var direction = [Link] || 'both'; // Set default axis
var origin = [Link]; // The origin of the scaling
if (mode != 'effect') { // Set default origin and restore for show/hide
[Link] = origin || ['middle','center'];
[Link] = true;
}
var original = {height: [Link](), width: [Link]()}; // Save
original
[Link] = [Link] || (mode == 'show' ? {height: 0, width: 0} :
original); // Default from state

// Adjust
var factor = { // Set scaling factor
y: direction != 'horizontal' ? (percent / 100) : 1,
x: direction != 'vertical' ? (percent / 100) : 1
};
[Link] = {height: [Link] * factor.y, width: [Link] *
factor.x}; // Set to state

if ([Link]) { // Fade option to support puff

if (mode == 'show') {[Link] = 0; [Link] = 1;};
if (mode == 'hide') {[Link] = 1; [Link] = 0;};
};

// Animation
[Link] = [Link]; [Link] = [Link]; [Link] = mode;

// Animate
[Link]('size', options, [Link], [Link]);
[Link]();
});
};

$.[Link] = function(o) {

return [Link](function() {

// Create element
var el = $(this), props =
['position','top','bottom','left','right','width','height','overflow','opacity'];
var props1 =
['position','top','bottom','left','right','overflow','opacity']; // Always restore
var props2 = ['width','height','overflow']; // Copy for children
var cProps = ['fontSize'];
var vProps = ['borderTopWidth', 'borderBottomWidth', 'paddingTop',
'paddingBottom'];
var hProps = ['borderLeftWidth', 'borderRightWidth', 'paddingLeft',
'paddingRight'];

// Set options
var mode = $.[Link](el, [Link] || 'effect'); // Set
Mode
var restore = [Link] || false; // Default restore
var scale = [Link] || 'both'; // Default scale mode
var origin = [Link]; // The origin of the sizing
var original = {height: [Link](), width: [Link]()}; // Save
original
[Link] = [Link] || original; // Default from state
[Link] = [Link] || original; // Default to state
// Adjust
if (origin) { // Calculate baseline shifts
var baseline = $.[Link](origin, original);
[Link] = ([Link] - [Link]) * baseline.y;
[Link] = ([Link] - [Link]) * baseline.x;
[Link] = ([Link] - [Link]) * baseline.y;
[Link] = ([Link] - [Link]) * baseline.x;
};
var factor = { // Set scaling factor
from: {y: [Link] / [Link], x: [Link] /
[Link]},
to: {y: [Link] / [Link], x: [Link] /
[Link]}
};
if (scale == 'box' || scale == 'both') { // Scale the css box
if ([Link].y != [Link].y) { // Vertical props scaling
props = [Link](vProps);
[Link] = $.[Link](el, vProps,
[Link].y, [Link]);
[Link] = $.[Link](el, vProps, [Link].y,
[Link]);
};
if ([Link].x != [Link].x) { // Horizontal props scaling
props = [Link](hProps);
[Link] = $.[Link](el, hProps,
[Link].x, [Link]);
[Link] = $.[Link](el, hProps, [Link].x,
[Link]);
};
};
 if (scale == 'content' || scale == 'both') { // Scale the content
if ([Link].y != [Link].y) { // Vertical props scaling
props = [Link](cProps);
[Link] = $.[Link](el, cProps,
[Link].y, [Link]);
[Link] = $.[Link](el, cProps, [Link].y,
[Link]);
};
};
$.[Link](el, restore ? props : props1); [Link](); // Save & Show
$.[Link](el); // Create Wrapper
[Link]('overflow','hidden').css([Link]); // Shift

// Animate
if (scale == 'content' || scale == 'both') { // Scale the children
vProps =
[Link](['marginTop','marginBottom']).concat(cProps); // Add margins/font-
size
hProps = [Link](['marginLeft','marginRight']); // Add
margins
props2 = [Link](vProps).concat(hProps); // Concat
[Link]("*[width]").each(function(){
var child = $(this);
if (restore) $.[Link](child, props2);
var c_original = {height: [Link](), width:
[Link]()}; // Save original
[Link] = {height: c_original.height * [Link].y,
width: c_original.width * [Link].x};
[Link] = {height: c_original.height * [Link].y, width:
c_original.width * [Link].x};
if ([Link].y != [Link].y) { // Vertical props
scaling
[Link] = $.[Link](child, vProps,
[Link].y, [Link]);
[Link] = $.[Link](child, vProps,
[Link].y, [Link]);
};
if ([Link].x != [Link].x) { // Horizontal props
scaling
[Link] = $.[Link](child, hProps,
[Link].x, [Link]);
[Link] = $.[Link](child, hProps,
[Link].x, [Link]);
};
[Link]([Link]); // Shift children
[Link]([Link], [Link], [Link],
function(){
if (restore) $.[Link](child, props2); //
Restore children
}); // Animate children
});
};

// Animate
[Link]([Link], { queue: false, duration: [Link], easing:
[Link], complete: function() {
if ([Link] === 0) {
[Link]('opacity', [Link]);
}
 if(mode == 'hide') [Link](); // Hide
$.[Link](el, restore ? props : props1);
$.[Link](el); // Restore
if([Link]) [Link](this, arguments); // Callback
[Link]();
}});

});

};

})(jQuery);

(function( $, undefined ) {

$.[Link] = function(o) {

return [Link](function() {

// Create element
var el = $(this), props = ['position','top','bottom','left','right'];

// Set options
var mode = $.[Link](el, [Link] || 'effect'); // Set
Mode
var direction = [Link] || 'left'; // Default direction
var distance = [Link] || 20; // Default distance
var times = [Link] || 3; // Default # of times
var speed = [Link] || [Link] || 140; // Default speed
per shake

// Adjust
$.[Link](el, props); [Link](); // Save & Show
$.[Link](el); // Create Wrapper
var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
var motion = (direction == 'up' || direction == 'left') ? 'pos' :
'neg';

// Animation
var animation = {}, animation1 = {}, animation2 = {};
animation[ref] = (motion == 'pos' ? '-=' : '+=') + distance;
animation1[ref] = (motion == 'pos' ? '+=' : '-=') + distance * 2;
animation2[ref] = (motion == 'pos' ? '-=' : '+=') + distance * 2;

// Animate
[Link](animation, speed, [Link]);
for (var i = 1; i < times; i++) { // Shakes
[Link](animation1, speed,
[Link]).animate(animation2, speed, [Link]);
};
[Link](animation1, speed, [Link]).
animate(animation, speed / 2, [Link], function(){ // Last
shake
$.[Link](el, props); $.[Link](el); //
Restore
if([Link]) [Link](this, arguments); // Callback
});
[Link]('fx', function() { [Link](); });
[Link]();
 });

};

})(jQuery);

(function( $, undefined ) {

$.[Link] = function(o) {

return [Link](function() {

// Create element
var el = $(this), props = ['position','top','bottom','left','right'];

// Set options
var mode = $.[Link](el, [Link] || 'show'); // Set Mode
var direction = [Link] || 'left'; // Default Direction

// Adjust
$.[Link](el, props); [Link](); // Save & Show
$.[Link](el).css({overflow:'hidden'}); // Create Wrapper
var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
var motion = (direction == 'up' || direction == 'left') ? 'pos' :
'neg';
var distance = [Link] || (ref == 'top' ?
[Link]( true ) : [Link]( true ));
if (mode == 'show') [Link](ref, motion == 'pos' ? (isNaN(distance) ?
"-" + distance : -distance) : distance); // Shift

// Animation
var animation = {};
animation[ref] = (mode == 'show' ? (motion == 'pos' ? '+=' : '-=') :
(motion == 'pos' ? '-=' : '+=')) + distance;

// Animate
[Link](animation, { queue: false, duration: [Link], easing:
[Link], complete: function() {
if(mode == 'hide') [Link](); // Hide
$.[Link](el, props); $.[Link](el); //
Restore
if([Link]) [Link](this, arguments); // Callback
[Link]();
}});

});

};

})(jQuery);

(function( $, undefined ) {

$.[Link] = function(o) {
return [Link](function() {
var elem = $(this),
target = $([Link]),
endPosition = [Link](),
animation = {
 top: [Link],
left: [Link],
height: [Link](),
width: [Link]()
},
startPosition = [Link](),
transfer = $('<div class="ui-effects-transfer"></div>')
.appendTo([Link])
.addClass([Link])
.css({
top: [Link],
left: [Link],
height: [Link](),
width: [Link](),
position: 'absolute'
})
.animate(animation, [Link], [Link],
function() {
[Link]();
([Link] && [Link](elem[0], arguments));
[Link]();
});
});
};

})(jQuery);

(function( $, undefined ) {

$.widget( "[Link]", {
options: {
active: 0,
animated: "slide",
autoHeight: true,
clearStyle: false,
collapsible: false,
event: "click",
fillSpace: false,
header: "> li > :first-child,> :not(li):even",
icons: {
header: "ui-icon-triangle-1-e",
headerSelected: "ui-icon-triangle-1-s"
},
navigation: false,
navigationFilter: function() {
return [Link]() === [Link]();
}
},

_create: function() {
var self = this,
options = [Link];

[Link] = 0;

[Link]
.addClass( "ui-accordion ui-widget ui-helper-reset" )
// in lack of child-selectors in CSS
// we need to mark top-LIs in a UL-accordion for some IE-fix
 .children( "li" )
.addClass( "ui-accordion-li-fix" );

[Link] = [Link]( [Link] )

.addClass( "ui-accordion-header ui-helper-reset ui-state-default
ui-corner-all" )
.bind( "[Link]", function() {
if ( [Link] ) {
return;
}
$( this ).addClass( "ui-state-hover" );
})
.bind( "[Link]", function() {
if ( [Link] ) {
return;
}
$( this ).removeClass( "ui-state-hover" );
})
.bind( "[Link]", function() {
if ( [Link] ) {
return;
}
$( this ).addClass( "ui-state-focus" );
})
.bind( "[Link]", function() {
if ( [Link] ) {
return;
}
$( this ).removeClass( "ui-state-focus" );
});

[Link]()
.addClass( "ui-accordion-content ui-helper-reset ui-widget-
content ui-corner-bottom" );

if ( [Link] ) {
var current =
[Link]( "a" ).filter( [Link] ).eq( 0 );
if ( [Link] ) {
var header = [Link]( ".ui-accordion-header" );
if ( [Link] ) {
// anchor within header
[Link] = header;
} else {
// anchor within content
[Link] = [Link]( ".ui-accordion-
content" ).prev();
}
}
}

[Link] = self._findActive( [Link] || [Link] )

.addClass( "ui-state-default ui-state-active" )
.toggleClass( "ui-corner-all" )
.toggleClass( "ui-corner-top" );
[Link]().addClass( "ui-accordion-content-active" );

self._createIcons();
[Link]();
 // ARIA
[Link]( "role", "tablist" );

[Link]
.attr( "role", "tab" )
.bind( "[Link]", function( event ) {
return self._keydown( event );
})
.next()
.attr( "role", "tabpanel" );

[Link]
.not( [Link] || "" )
.attr({
"aria-expanded": "false",
"aria-selected": "false",
tabIndex: -1
})
.next()
.hide();

// make sure at least one header is in the tab order

if ( ![Link] ) {
[Link]( 0 ).attr( "tabIndex", 0 );
} else {
[Link]
.attr({
"aria-expanded": "true",
"aria-selected": "true",
tabIndex: 0
});
}

// only need links in tab order for Safari

if ( !$.[Link] ) {
[Link]( "a" ).attr( "tabIndex", -1 );
}

if ( [Link] ) {
[Link]( [Link](" ").join(".accordion ") +
".accordion", function(event) {
self._clickHandler.call( self, event, this );
[Link]();
});
}
},

_createIcons: function() {
var options = [Link];
if ( [Link] ) {
$( "<span></span>" )
.addClass( "ui-icon " + [Link] )
.prependTo( [Link] );
[Link]( ".ui-icon" )
.toggleClass([Link])
.toggleClass([Link]);
[Link]( "ui-accordion-icons" );
}
 },

_destroyIcons: function() {
[Link]( ".ui-icon" ).remove();
[Link]( "ui-accordion-icons" );
},

destroy: function() {
var options = [Link];

[Link]
.removeClass( "ui-accordion ui-widget ui-helper-reset" )
.removeAttr( "role" );

[Link]
.unbind( ".accordion" )
.removeClass( "ui-accordion-header ui-accordion-disabled ui-
helper-reset ui-state-default ui-corner-all ui-state-active ui-state-disabled ui-
corner-top" )
.removeAttr( "role" )
.removeAttr( "aria-expanded" )
.removeAttr( "aria-selected" )
.removeAttr( "tabIndex" );

[Link]( "a" ).removeAttr( "tabIndex" );

this._destroyIcons();
var contents = [Link]()
.css( "display", "" )
.removeAttr( "role" )
.removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom
ui-accordion-content ui-accordion-content-active ui-accordion-disabled ui-state-
disabled" );
if ( [Link] || [Link] ) {
[Link]( "height", "" );
}

return $.[Link]( this );

},

_setOption: function( key, value ) {

$.[Link]._setOption.apply( this, arguments );

if ( key == "active" ) {
[Link]( value );
}
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" ) {
[Link]([Link]())
[ value ? "addClass" : "removeClass" ](
"ui-accordion-disabled ui-state-disabled" );
}
},
 _keydown: function( event ) {
if ( [Link] || [Link] || [Link] ) {
return;
}

var keyCode = $.[Link],

length = [Link],
currentIndex = [Link]( [Link] ),
toFocus = false;

switch ( [Link] ) {
case [Link]:
case [Link]:
toFocus = [Link][ ( currentIndex + 1 ) % length ];
break;
case [Link]:
case [Link]:
toFocus = [Link][ ( currentIndex - 1 + length ) %
length ];
break;
case [Link]:
case [Link]:
this._clickHandler( { target: [Link] },
[Link] );
[Link]();
}

if ( toFocus ) {
$( [Link] ).attr( "tabIndex", -1 );
$( toFocus ).attr( "tabIndex", 0 );
[Link]();
return false;
}

return true;
},

resize: function() {
var options = [Link],
maxHeight;

if ( [Link] ) {
if ( $.[Link] ) {
var defOverflow = [Link]().css( "overflow" );
[Link]().css( "overflow", "hidden");
}
maxHeight = [Link]().height();
if ($.[Link]) {
[Link]().css( "overflow", defOverflow );
}

[Link](function() {
maxHeight -= $( this ).outerHeight( true );
});

[Link]()
.each(function() {
$( this ).height( [Link]( 0, maxHeight -
 $( this ).innerHeight() + $
( this ).height() ) );
})
.css( "overflow", "auto" );
} else if ( [Link] ) {
maxHeight = 0;
[Link]()
.each(function() {
maxHeight = [Link]( maxHeight, $( this ).height( ""
).height() );
})
.height( maxHeight );
}

return this;
},

activate: function( index ) {

// TODO this gets called on init, changing the option without an
explicit call for that
[Link] = index;
// call clickHandler with custom event
var active = this._findActive( index )[ 0 ];
this._clickHandler( { target: active }, active );

return this;
},

_findActive: function( selector ) {

return selector
? typeof selector === "number"
? [Link]( ":eq(" + selector + ")" )
: [Link]( [Link]( selector ) )
: selector === false
? $( [] )
: [Link]( ":eq(0)" );
},

// TODO isn't [Link] enough? why the separate target argument?

_clickHandler: function( event, target ) {
var options = [Link];
if ( [Link] ) {
return;
}

// called only when using activate(false) to close all parts

programmatically
if ( ![Link] ) {
if ( ![Link] ) {
return;
}
[Link]
.removeClass( "ui-state-active ui-corner-top" )
.addClass( "ui-state-default ui-corner-all" )
.children( ".ui-icon" )
.removeClass( [Link] )
.addClass( [Link] );
[Link]().addClass( "ui-accordion-content-active" );
var toHide = [Link](),
 data = {
options: options,
newHeader: $( [] ),
oldHeader: [Link],
newContent: $( [] ),
oldContent: toHide
},
toShow = ( [Link] = $( [] ) );
this._toggle( toShow, toHide, data );
return;
}

// get the click target

var clicked = $( [Link] || target ),
clickedIsActive = clicked[0] === [Link][0];

// TODO the option is changed, is that correct?

// TODO if it is correct, shouldn't that happen after determining that
the click is valid?
[Link] = [Link] && clickedIsActive ?
false :
[Link]( clicked );

// if animations are still active, or the active header is the target,

ignore click
if ( [Link] || ( ![Link] && clickedIsActive ) ) {
return;
}

// find elements to show and hide

var active = [Link],
toShow = [Link](),
toHide = [Link](),
data = {
options: options,
newHeader: clickedIsActive && [Link] ? $([]) :
clicked,
oldHeader: [Link],
newContent: clickedIsActive && [Link] ? $
([]) : toShow,
oldContent: toHide
},
down = [Link]( [Link][0] ) > [Link](
clicked[0] );

// when the call to ._toggle() comes after the class changes

// it causes a very odd bug in IE 8 (see #6720)
[Link] = clickedIsActive ? $([]) : clicked;
this._toggle( toShow, toHide, data, clickedIsActive, down );

// switch classes
active
.removeClass( "ui-state-active ui-corner-top" )
.addClass( "ui-state-default ui-corner-all" )
.children( ".ui-icon" )
.removeClass( [Link] )
.addClass( [Link] );
if ( !clickedIsActive ) {
clicked
 .removeClass( "ui-state-default ui-corner-all" )
.addClass( "ui-state-active ui-corner-top" )
.children( ".ui-icon" )
.removeClass( [Link] )
.addClass( [Link] );
clicked
.next()
.addClass( "ui-accordion-content-active" );
}

return;
},

_toggle: function( toShow, toHide, data, clickedIsActive, down ) {

var self = this,
options = [Link];

[Link] = toShow;
[Link] = toHide;
[Link] = data;

var complete = function() {

if ( !self ) {
return;
}
return self._completed.apply( self, arguments );
};

// trigger changestart event

self._trigger( "changestart", null, [Link] );

// count elements to animate

[Link] = [Link]() === 0 ? [Link]() : [Link]();

if ( [Link] ) {
var animOptions = {};

if ( [Link] && clickedIsActive ) {

animOptions = {
toShow: $( [] ),
toHide: toHide,
complete: complete,
down: down,
autoHeight: [Link] || [Link]
};
} else {
animOptions = {
toShow: toShow,
toHide: toHide,
complete: complete,
down: down,
autoHeight: [Link] || [Link]
};
}

if ( ![Link] ) {
[Link] = [Link];
}
 if ( ![Link] ) {
[Link] = [Link];
}

[Link] = $.isFunction( [Link] ) ?

[Link]( animOptions ) :
[Link];

[Link] = $.isFunction( [Link] ) ?

[Link]( animOptions ) :
[Link];

var animations = $.[Link],

duration = [Link],
easing = [Link];

if ( easing && !animations[ easing ] && !$.easing[ easing ] ) {

easing = "slide";
}
if ( !animations[ easing ] ) {
animations[ easing ] = function( options ) {
[Link]( options, {
easing: easing,
duration: duration || 700
});
};
}

animations[ easing ]( animOptions );

} else {
if ( [Link] && clickedIsActive ) {
[Link]();
} else {
[Link]();
[Link]();
}

complete( true );
}

// TODO assert that the blur and focus triggers are really necessary,
remove otherwise
[Link]()
.attr({
"aria-expanded": "false",
"aria-selected": "false",
tabIndex: -1
})
.blur();
[Link]()
.attr({
"aria-expanded": "true",
"aria-selected": "true",
tabIndex: 0
})
.focus();
},

_completed: function( cancel ) {

 [Link] = cancel ? 0 : --[Link];
if ( [Link] ) {
return;
}

if ( [Link] ) {
[Link]( [Link] ).css({
height: "",
overflow: ""
});
}

// other classes are removed before the animation; this one needs to
stay until completed
[Link]( "ui-accordion-content-active" );
// Work around for rendering bug in IE (#5421)
if ( [Link] ) {
[Link]()[0].className = [Link]()
[0].className;
}

this._trigger( "change", null, [Link] );

}
});

$.extend( $.[Link], {
version: "1.8.24",
animations: {
slide: function( options, additions ) {
options = $.extend({
easing: "swing",
duration: 300
}, options, additions );
if ( ![Link]() ) {
[Link]({
height: "show",
paddingTop: "show",
paddingBottom: "show"
}, options );
return;
}
if ( ![Link]() ) {
[Link]({
height: "hide",
paddingTop: "hide",
paddingBottom: "hide"
}, options );
return;
}
var overflow = [Link]( "overflow" ),
percentDone = 0,
showProps = {},
hideProps = {},
fxAttrs = [ "height", "paddingTop", "paddingBottom" ],
originalWidth;
// fix width before calculating height of hidden element
var s = [Link];
originalWidth = s[0].[Link];
[Link]( [Link]().width()
 - parseFloat( [Link]( "paddingLeft" ) )
- parseFloat( [Link]( "paddingRight" ) )
- ( parseFloat( [Link]( "borderLeftWidth" ) ) || 0 )
- ( parseFloat( [Link]( "borderRightWidth" ) ) || 0 ) );

$.each( fxAttrs, function( i, prop ) {

hideProps[ prop ] = "hide";

var parts = ( "" + $.css( [Link][0],

prop ) ).match( /^([\d+-.]+)(.*)$/ );
showProps[ prop ] = {
value: parts[ 1 ],
unit: parts[ 2 ] || "px"
};
});
[Link]({ height: 0, overflow: "hidden" }).show();
[Link]
.filter( ":hidden" )
.each( [Link] )
.end()
.filter( ":visible" )
.animate( hideProps, {
step: function( now, settings ) {
// only calculate the percent when animating height
// IE gets very inconsistent results when animating
elements
// with small values, which is common for padding
if ( [Link] == "height" ) {
percentDone = ( [Link] - [Link]
=== 0 ) ? 0 :
( [Link] - [Link] ) /
( [Link] - [Link] );
}

[Link][ 0 ].style[ [Link] ] =

( percentDone *
showProps[ [Link] ].value )
+ showProps[ [Link] ].unit;
},
duration: [Link],
easing: [Link],
complete: function() {
if ( ![Link] ) {
[Link]( "height", "" );
}
[Link]({
width: originalWidth,
overflow: overflow
});
[Link]();
}
});
},
bounceslide: function( options ) {
[Link]( options, {
easing: [Link] ? "easeOutBounce" : "swing",
duration: [Link] ? 1000 : 200
});
}
 }
});

})( jQuery );

(function( $, undefined ) {

// used to prevent race conditions with remote data sources

var requestIndex = 0;

$.widget( "[Link]", {
options: {
appendTo: "body",
autoFocus: false,
delay: 300,
minLength: 1,
position: {
my: "left top",
at: "left bottom",
collision: "none"
},
source: null
},

pending: 0,

_create: function() {
var self = this,
doc = [Link][ 0 ].ownerDocument,
suppressKeyPress;
[Link] = [Link]( "textarea" );

[Link]
.addClass( "ui-autocomplete-input" )
.attr( "autocomplete", "off" )
// TODO verify these actually work as intended
.attr({
role: "textbox",
"aria-autocomplete": "list",
"aria-haspopup": "true"
})
.bind( "[Link]", function( event ) {
if ( [Link] ||
[Link]( "readOnly" ) ) {
return;
}

suppressKeyPress = false;
var keyCode = $.[Link];
switch( [Link] ) {
case keyCode.PAGE_UP:
self._move( "previousPage", event );
break;
case keyCode.PAGE_DOWN:
self._move( "nextPage", event );
break;
case [Link]:
self._keyEvent( "previous", event );
break;
 case [Link]:
self._keyEvent( "next", event );
break;
case [Link]:
case keyCode.NUMPAD_ENTER:
// when menu is open and has focus
if ( [Link] ) {
// #6055 - Opera still allows the keypress to
occur
// which causes forms to submit
suppressKeyPress = true;
[Link]();
}
//passthrough - ENTER and TAB both select the current
element
case [Link]:
if ( ![Link] ) {
return;
}
[Link]( event );
break;
case [Link]:
[Link]( [Link] );
[Link]( event );
break;
default:
// keypress is triggered before the input value is
changed
clearTimeout( [Link] );
[Link] = setTimeout(function() {
// only search if the value has changed
if ( [Link] != [Link]() ) {
[Link] = null;
[Link]( null, event );
}
}, [Link] );
break;
}
})
.bind( "[Link]", function( event ) {
if ( suppressKeyPress ) {
suppressKeyPress = false;
[Link]();
}
})
.bind( "[Link]", function() {
if ( [Link] ) {
return;
}

[Link] = null;
[Link] = [Link]();
})
.bind( "[Link]", function( event ) {
if ( [Link] ) {
return;
}

clearTimeout( [Link] );
 // clicks on the menu (or a button to trigger a search)
will cause a blur event
[Link] = setTimeout(function() {
[Link]( event );
self._change( event );
}, 150 );
});
this._initSource();
[Link] = $( "<ul></ul>" )
.addClass( "ui-autocomplete" )
.appendTo( $( [Link] || "body", doc )[0] )
// prevent the close-on-blur in case of a "slow" click on the
menu (long mousedown)
.mousedown(function( event ) {
// clicking on the scrollbar causes focus to shift to the
body
// but we can't detect a mouseup or a click immediately
afterward
// so we have to track the next mousedown and close the
menu if
// the user clicks somewhere outside of the autocomplete
var menuElement = [Link][ 0 ];
if ( !$( [Link] ).closest( ".ui-menu-item" ).length )
{
setTimeout(function() {
$( document ).one( 'mousedown', function( event
) {
if ( [Link] !== [Link][ 0 ]
&&
[Link] !== menuElement &&
!$.[Link]( menuElement,
[Link] ) ) {
[Link]();
}
});
}, 1 );
}

// use another timeout to make sure the blur-event-handler

on the input was already triggered
setTimeout(function() {
clearTimeout( [Link] );
}, 13);
})
.menu({
focus: function( event, ui ) {
var item = [Link]( "[Link]" );
if ( false !== self._trigger( "focus", event, { item:
item } ) ) {
// use value to match what will end up in the
input, if it was a key event
if ( /^key/.test([Link]) ) {
[Link]( [Link] );
}
}
},
selected: function( event, ui ) {
var item = [Link]( "[Link]" ),
previous = [Link];
 // only trigger when focus was lost (click on menu)
if ( [Link][0] !== [Link] ) {
[Link]();
[Link] = previous;
// #6109 - IE triggers two focus events and the
second
// is asynchronous, so we need to reset the
previous
// term synchronously and asynchronously :-(
setTimeout(function() {
[Link] = previous;
[Link] = item;
}, 1);
}

if ( false !== self._trigger( "select", event,

{ item: item } ) ) {
[Link]( [Link] );
}
// reset the term after the select event
// this allows custom select handling to work
properly
[Link] = [Link]();

[Link]( event );
[Link] = item;
},
blur: function( event, ui ) {
// don't set the value of the text field if it's
already correct
// this prevents moving the cursor unnecessarily
if ( [Link](":visible") &&
( [Link]() !== [Link] ) ) {
[Link]( [Link] );
}
}
})
.zIndex( [Link]() + 1 )
// workaround for jQuery bug #5781
[Link]
.css({ top: 0, left: 0 })
.hide()
.data( "menu" );
if ( $.[Link] ) {
[Link]();
}
// turning off autocomplete prevents the browser from remembering the
// value when navigating through history, so we re-enable autocomplete
// if the page is unloaded before the widget is destroyed. #7790
[Link] = function() {
[Link]( "autocomplete" );
};
$( window ).bind( "beforeunload", [Link] );
},

destroy: function() {
[Link]
.removeClass( "ui-autocomplete-input" )
 .removeAttr( "autocomplete" )
.removeAttr( "role" )
.removeAttr( "aria-autocomplete" )
.removeAttr( "aria-haspopup" );
[Link]();
$( window ).unbind( "beforeunload", [Link] );
$.[Link]( this );
},

_setOption: function( key, value ) {

$.[Link]._setOption.apply( this, arguments );
if ( key === "source" ) {
this._initSource();
}
if ( key === "appendTo" ) {
[Link]( $( value || "body",
[Link][0].ownerDocument )[0] )
}
if ( key === "disabled" && value && [Link] ) {
[Link]();
}
},

_initSource: function() {
var self = this,
array,
url;
if ( $.isArray([Link]) ) {
array = [Link];
[Link] = function( request, response ) {
response( $.[Link](array, [Link]) );
};
} else if ( typeof [Link] === "string" ) {
url = [Link];
[Link] = function( request, response ) {
if ( [Link] ) {
[Link]();
}
[Link] = $.ajax({
url: url,
data: request,
dataType: "json",
success: function( data, status ) {
response( data );
},
error: function() {
response( [] );
}
});
};
} else {
[Link] = [Link];
}
},

search: function( value, event ) {

value = value != null ? value : [Link]();

// always save the actual value, not the one passed as an argument
 [Link] = [Link]();

if ( [Link] < [Link] ) {

return [Link]( event );
}

clearTimeout( [Link] );
if ( this._trigger( "search", event ) === false ) {
return;
}

return this._search( value );

},

_search: function( value ) {

[Link]++;
[Link]( "ui-autocomplete-loading" );

[Link]( { term: value }, this._response() );

},

_response: function() {
var that = this,
index = ++requestIndex;

return function( content ) {

if ( index === requestIndex ) {
that.__response( content );
}

[Link]--;
if ( ![Link] ) {
[Link]( "ui-autocomplete-loading" );
}
};
},

__response: function( content ) {

if ( ![Link] && content && [Link] ) {
content = this._normalize( content );
this._suggest( content );
this._trigger( "open" );
} else {
[Link]();
}
},

close: function( event ) {

clearTimeout( [Link] );
if ( [Link](":visible") ) {
[Link]();
[Link]();
this._trigger( "close", event );
}
},

_change: function( event ) {

if ( [Link] !== [Link]() ) {
this._trigger( "change", event, { item: [Link] } );
 }
},

_normalize: function( items ) {

// assume all items have the right format when the first item is
complete
if ( [Link] && items[0].label && items[0].value ) {
return items;
}
return $.map( items, function(item) {
if ( typeof item === "string" ) {
return {
label: item,
value: item
};
}
return $.extend({
label: [Link] || [Link],
value: [Link] || [Link]
}, item );
});
},

_suggest: function( items ) {

var ul = [Link]
.empty()
.zIndex( [Link]() + 1 );
this._renderMenu( ul, items );
// TODO refresh should check if the active item is still in the dom,
removing the need for a manual deactivate
[Link]();
[Link]();

// size and position menu

[Link]();
this._resizeMenu();
[Link]( $.extend({
of: [Link]
}, [Link] ));

if ( [Link] ) {
[Link]( new $.Event("mouseover") );
}
},

_resizeMenu: function() {
var ul = [Link];
[Link]( [Link](
// Firefox wraps long text (possibly a rounding bug)
// so we add 1px to avoid the wrapping (#7513)
[Link]( "" ).outerWidth() + 1,
[Link]()
) );
},

_renderMenu: function( ul, items ) {

var self = this;
$.each( items, function( index, item ) {
self._renderItem( ul, item );
 });
},

_renderItem: function( ul, item) {

return $( "<li></li>" )
.data( "[Link]", item )
.append( $( "<a></a>" ).text( [Link] ) )
.appendTo( ul );
},

_move: function( direction, event ) {

if ( ![Link](":visible") ) {
[Link]( null, event );
return;
}
if ( [Link]() && /^previous/.test(direction) ||
[Link]() && /^next/.test(direction) ) {
[Link]( [Link] );
[Link]();
return;
}
[Link][ direction ]( event );
},

widget: function() {
return [Link];
},
_keyEvent: function( keyEvent, event ) {
if ( ![Link] || [Link]( ":visible" ) ) {
this._move( keyEvent, event );

// prevents moving cursor to beginning/end of the text field in

some browsers
[Link]();
}
}
});

$.extend( $.[Link], {
escapeRegex: function( value ) {
return [Link](/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
},
filter: function(array, term) {
var matcher = new RegExp( $.[Link](term), "i" );
return $.grep( array, function(value) {
return [Link]( [Link] || [Link] || value );
});
}
});

}( jQuery ));

/*
* jQuery UI Menu (not officially released)
*
* This widget isn't yet finished and the API is subject to change. We plan to
finish
* it for the next release. You're welcome to give it a try anyway and give us
feedback,
 * as long as you're okay with migrating your code later on. We can help with that,
too.
*
* Copyright 2010, [Link] ([Link]
* Licensed under the MIT license.
* [Link]
*
* [Link]
*
* Depends:
* [Link]
* [Link]
*/
(function($) {

$.widget("[Link]", {
_create: function() {
var self = this;
[Link]
.addClass("ui-menu ui-widget ui-widget-content ui-corner-all")
.attr({
role: "listbox",
"aria-activedescendant": "ui-active-menuitem"
})
.click(function( event ) {
if ( !$( [Link] ).closest( ".ui-menu-item a" ).length
) {
return;
}
// temporary
[Link]();
[Link]( event );
});
[Link]();
},

refresh: function() {
var self = this;

// don't refresh list items that are already adapted

var items = [Link]("li:not(.ui-menu-item):has(a)")
.addClass("ui-menu-item")
.attr("role", "menuitem");

[Link]("a")
.addClass("ui-corner-all")
.attr("tabindex", -1)
// mouseenter doesn't work with event delegation
.mouseenter(function( event ) {
[Link]( event, $(this).parent() );
})
.mouseleave(function() {
[Link]();
});
},

activate: function( event, item ) {

[Link]();
if ([Link]()) {
 var offset = [Link]().top - [Link]().top,
scroll = [Link](),
elementHeight = [Link]();
if (offset < 0) {
[Link]( scroll + offset);
} else if (offset >= elementHeight) {
[Link]( scroll + offset - elementHeight +
[Link]());
}
}
[Link] = [Link](0)
.children("a")
.addClass("ui-state-hover")
.attr("id", "ui-active-menuitem")
.end();
this._trigger("focus", event, { item: item });
},

deactivate: function() {
if (![Link]) { return; }

[Link]("a")
.removeClass("ui-state-hover")
.removeAttr("id");
this._trigger("blur");
[Link] = null;
},

next: function(event) {
[Link]("next", ".ui-menu-item:first", event);
},

previous: function(event) {
[Link]("prev", ".ui-menu-item:last", event);
},

first: function() {
return [Link] && ![Link](".ui-menu-item").length;
},

last: function() {
return [Link] && ![Link](".ui-menu-item").length;
},

move: function(direction, edge, event) {

if (![Link]) {
[Link](event, [Link](edge));
return;
}
var next = [Link][direction + "All"](".ui-menu-item").eq(0);
if ([Link]) {
[Link](event, next);
} else {
[Link](event, [Link](edge));
}
},

// TODO merge with previousPage

nextPage: function(event) {
 if ([Link]()) {
// TODO merge with no-scroll-else
if (![Link] || [Link]()) {
[Link](event, [Link](".ui-menu-
item:first"));
return;
}
var base = [Link]().top,
height = [Link](),
result = [Link](".ui-menu-
item").filter(function() {
var close = $(this).offset().top - base - height + $
(this).height();
// TODO improve approximation
return close < 10 && close > -10;
});

// TODO try to catch this earlier when scrollTop indicates the

last page anyway
if (![Link]) {
result = [Link](".ui-menu-item:last");
}
[Link](event, result);
} else {
[Link](event, [Link](".ui-menu-item")
.filter(![Link] || [Link]() ? ":first" : ":last"));
}
},

// TODO merge with nextPage

previousPage: function(event) {
if ([Link]()) {
// TODO merge with no-scroll-else
if (![Link] || [Link]()) {
[Link](event, [Link](".ui-menu-
item:last"));
return;
}

var base = [Link]().top,

height = [Link](),
result = [Link](".ui-menu-
item").filter(function() {
var close = $(this).offset().top - base + height - $
(this).height();
// TODO improve approximation
return close < 10 && close > -10;
});

// TODO try to catch this earlier when scrollTop indicates the

last page anyway
if (![Link]) {
result = [Link](".ui-menu-item:first");
}
[Link](event, result);
} else {
[Link](event, [Link](".ui-menu-item")
.filter(![Link] || [Link]() ? ":last" :
":first"));
 }
},

hasScroll: function() {
return [Link]() < [Link][ $.[Link] ? "prop" :
"attr" ]("scrollHeight");
},

select: function( event ) {

this._trigger("selected", event, { item: [Link] });
}
});

}(jQuery));

(function( $, undefined ) {

var lastActive, startXPos, startYPos, clickDragged,

baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
stateClasses = "ui-state-hover ui-state-active ",
typeClasses = "ui-button-icons-only ui-button-icon-only ui-button-text-icons
ui-button-text-icon-primary ui-button-text-icon-secondary ui-button-text-only",
formResetHandler = function() {
var buttons = $( this ).find( ":ui-button" );
setTimeout(function() {
[Link]( "refresh" );
}, 1 );
},
radioGroup = function( radio ) {
var name = [Link],
form = [Link],
radios = $( [] );
if ( name ) {
if ( form ) {
radios = $( form ).find( "[name='" + name + "']" );
} else {
radios = $( "[name='" + name + "']", [Link] )
.filter(function() {
return ![Link];
});
}
}
return radios;
};

$.widget( "[Link]", {
options: {
disabled: null,
text: true,
label: null,
icons: {
primary: null,
secondary: null
}
},
_create: function() {
[Link]( "form" )
.unbind( "[Link]" )
.bind( "[Link]", formResetHandler );
 if ( typeof [Link] !== "boolean" ) {
[Link] = !![Link]( "disabled" );
} else {
[Link]( "disabled", [Link] );
}

this._determineButtonType();
[Link] = !![Link]( "title" );

var self = this,

options = [Link],
toggleButton = [Link] === "checkbox" || [Link] === "radio",
hoverClass = "ui-state-hover" + ( !toggleButton ? " ui-state-
active" : "" ),
focusClass = "ui-state-focus";

if ( [Link] === null ) {

[Link] = [Link]();
}

[Link]
.addClass( baseClasses )
.attr( "role", "button" )
.bind( "[Link]", function() {
if ( [Link] ) {
return;
}
$( this ).addClass( "ui-state-hover" );
if ( this === lastActive ) {
$( this ).addClass( "ui-state-active" );
}
})
.bind( "[Link]", function() {
if ( [Link] ) {
return;
}
$( this ).removeClass( hoverClass );
})
.bind( "[Link]", function( event ) {
if ( [Link] ) {
[Link]();
[Link]();
}
});

[Link]
.bind( "[Link]", function() {
// no need to check disabled, focus won't be triggered
anyway
[Link]( focusClass );
})
.bind( "[Link]", function() {
[Link]( focusClass );
});

if ( toggleButton ) {
[Link]( "[Link]", function() {
if ( clickDragged ) {
 return;
}
[Link]();
});
// if mouse moves between mousedown and mouseup (drag) set
clickDragged flag
// prevents issue where button state changes but checkbox/radio
checked state
// does not in Firefox (see ticket #6970)
[Link]
.bind( "[Link]", function( event ) {
if ( [Link] ) {
return;
}
clickDragged = false;
startXPos = [Link];
startYPos = [Link];
})
.bind( "[Link]", function( event ) {
if ( [Link] ) {
return;
}
if ( startXPos !== [Link] || startYPos !==
[Link] ) {
clickDragged = true;
}
});
}

if ( [Link] === "checkbox" ) {

[Link]( "[Link]", function() {
if ( [Link] || clickDragged ) {
return false;
}
$( this ).toggleClass( "ui-state-active" );
[Link]( "aria-pressed",
[Link][0].checked );
});
} else if ( [Link] === "radio" ) {
[Link]( "[Link]", function() {
if ( [Link] || clickDragged ) {
return false;
}
$( this ).addClass( "ui-state-active" );
[Link]( "aria-pressed", "true" );

var radio = [Link][ 0 ];

radioGroup( radio )
.not( radio )
.map(function() {
return $( this ).button( "widget" )[ 0 ];
})
.removeClass( "ui-state-active" )
.attr( "aria-pressed", "false" );
});
} else {
[Link]
.bind( "[Link]", function() {
if ( [Link] ) {
 return false;
}
$( this ).addClass( "ui-state-active" );
lastActive = this;
$( document ).one( "mouseup", function() {
lastActive = null;
});
})
.bind( "[Link]", function() {
if ( [Link] ) {
return false;
}
$( this ).removeClass( "ui-state-active" );
})
.bind( "[Link]", function(event) {
if ( [Link] ) {
return false;
}
if ( [Link] == $.[Link] ||
[Link] == $.[Link] ) {
$( this ).addClass( "ui-state-active" );
}
})
.bind( "[Link]", function() {
$( this ).removeClass( "ui-state-active" );
});

if ( [Link]("a") ) {
[Link](function(event) {
if ( [Link] === $.[Link] ) {
// TODO pass through original event correctly
(just as 2nd argument doesn't work)
$( this ).click();
}
});
}
}

// TODO: pull out $.Widget's handling for the disabled option into
// $.[Link]._setOptionDisabled so it's easy to proxy and can
// be overridden by individual plugins
this._setOption( "disabled", [Link] );
this._resetButton();
},

_determineButtonType: function() {

if ( [Link](":checkbox") ) {
[Link] = "checkbox";
} else if ( [Link](":radio") ) {
[Link] = "radio";
} else if ( [Link]("input") ) {
[Link] = "input";
} else {
[Link] = "button";
}

if ( [Link] === "checkbox" || [Link] === "radio" ) {

// we don't search against the document in case the element
 // is disconnected from the DOM
var ancestor = [Link]().filter(":last"),
labelSelector = "label[for='" + [Link]("id") +
"']";
[Link] = [Link]( labelSelector );
if ( ![Link] ) {
ancestor = [Link] ? [Link]() :
[Link]();
[Link] = [Link]( labelSelector );
if ( ![Link] ) {
[Link] = [Link]( labelSelector );
}
}
[Link]( "ui-helper-hidden-accessible" );

var checked = [Link]( ":checked" );

if ( checked ) {
[Link]( "ui-state-active" );
}
[Link]( "aria-pressed", checked );
} else {
[Link] = [Link];
}
},

widget: function() {
return [Link];
},

destroy: function() {
[Link]
.removeClass( "ui-helper-hidden-accessible" );
[Link]
.removeClass( baseClasses + " " + stateClasses + " " +
typeClasses )
.removeAttr( "role" )
.removeAttr( "aria-pressed" )
.html( [Link](".ui-button-text").html() );

if ( ![Link] ) {
[Link]( "title" );
}

$.[Link]( this );
},

_setOption: function( key, value ) {

$.[Link]._setOption.apply( this, arguments );
if ( key === "disabled" ) {
if ( value ) {
[Link]( "disabled", true );
} else {
[Link]( "disabled", false );
}
return;
}
this._resetButton();
},
 refresh: function() {
var isDisabled = [Link]( ":disabled" );
if ( isDisabled !== [Link] ) {
this._setOption( "disabled", isDisabled );
}
if ( [Link] === "radio" ) {
radioGroup( [Link][0] ).each(function() {
if ( $( this ).is( ":checked" ) ) {
$( this ).button( "widget" )
.addClass( "ui-state-active" )
.attr( "aria-pressed", "true" );
} else {
$( this ).button( "widget" )
.removeClass( "ui-state-active" )
.attr( "aria-pressed", "false" );
}
});
} else if ( [Link] === "checkbox" ) {
if ( [Link]( ":checked" ) ) {
[Link]
.addClass( "ui-state-active" )
.attr( "aria-pressed", "true" );
} else {
[Link]
.removeClass( "ui-state-active" )
.attr( "aria-pressed", "false" );
}
}
},

_resetButton: function() {
if ( [Link] === "input" ) {
if ( [Link] ) {
[Link]( [Link] );
}
return;
}
var buttonElement = [Link]( typeClasses ),
buttonText = $( "<span></span>", [Link][0].ownerDocument )
.addClass( "ui-button-text" )
.html( [Link] )
.appendTo( [Link]() )
.text(),
icons = [Link],
multipleIcons = [Link] && [Link],
buttonClasses = [];

if ( [Link] || [Link] ) {
if ( [Link] ) {
[Link]( "ui-button-text-icon" + ( multipleIcons
? "s" : ( [Link] ? "-primary" : "-secondary" ) ) );
}

if ( [Link] ) {
[Link]( "<span class='ui-button-icon-primary
ui-icon " + [Link] + "'></span>" );
}

if ( [Link] ) {
 [Link]( "<span class='ui-button-icon-
secondary ui-icon " + [Link] + "'></span>" );
}

if ( ![Link] ) {
[Link]( multipleIcons ? "ui-button-icons-
only" : "ui-button-icon-only" );

if ( ![Link] ) {
[Link]( "title", buttonText );
}
}
} else {
[Link]( "ui-button-text-only" );
}
[Link]( [Link]( " " ) );
}
});

$.widget( "[Link]", {
options: {
items: ":button, :submit, :reset, :checkbox, :radio, a, :data(button)"
},

_create: function() {
[Link]( "ui-buttonset" );
},

_init: function() {
[Link]();
},

_setOption: function( key, value ) {

if ( key === "disabled" ) {
[Link]( "option", key, value );
}

$.[Link]._setOption.apply( this, arguments );

},

refresh: function() {
var rtl = [Link]( "direction" ) === "rtl";

[Link] = [Link]( [Link] )

.filter( ":ui-button" )
.button( "refresh" )
.end()
.not( ":ui-button" )
.button()
.end()
.map(function() {
return $( this ).button( "widget" )[ 0 ];
})
.removeClass( "ui-corner-all ui-corner-left ui-corner-
right" )
.filter( ":first" )
.addClass( rtl ? "ui-corner-right" : "ui-corner-left"
)
.end()
 .filter( ":last" )
.addClass( rtl ? "ui-corner-left" : "ui-corner-right"
)
.end()
.end();
},

destroy: function() {
[Link]( "ui-buttonset" );
[Link]
.map(function() {
return $( this ).button( "widget" )[ 0 ];
})
.removeClass( "ui-corner-left ui-corner-right" )
.end()
.button( "destroy" );

$.[Link]( this );
}
});

}( jQuery ) );

(function( $, undefined ) {

$.extend($.ui, { datepicker: { version: "1.8.24" } });

var PROP_NAME = 'datepicker';

var dpuuid = new Date().getTime();
var instActive;

/* Date picker manager.

Use the singleton instance of this class, $.datepicker, to interact with the
date picker.
Settings for (groups of) date pickers are maintained in an instance object,
allowing multiple different settings on the same page. */

function Datepicker() {
[Link] = false; // Change this to true to start debugging
this._curInst = null; // The current instance in use
this._keyEvent = false; // If the last event was a key event
this._disabledInputs = []; // List of date picker inputs that have been
disabled
this._datepickerShowing = false; // True if the popup picker is showing ,
false if not
this._inDialog = false; // True if showing within a "dialog", false if not
this._mainDivId = 'ui-datepicker-div'; // The ID of the main datepicker
division
this._inlineClass = 'ui-datepicker-inline'; // The name of the inline marker
class
this._appendClass = 'ui-datepicker-append'; // The name of the append marker
class
this._triggerClass = 'ui-datepicker-trigger'; // The name of the trigger
marker class
this._dialogClass = 'ui-datepicker-dialog'; // The name of the dialog marker
class
this._disableClass = 'ui-datepicker-disabled'; // The name of the disabled
covering marker class
this._unselectableClass = 'ui-datepicker-unselectable'; // The name of the
unselectable cell marker class
this._currentClass = 'ui-datepicker-current-day'; // The name of the current
day marker class
this._dayOverClass = 'ui-datepicker-days-cell-over'; // The name of the day
hover marker class
[Link] = []; // Available regional settings, indexed by language code
[Link][''] = { // Default regional settings
closeText: 'Done', // Display text for close link
prevText: 'Prev', // Display text for previous month link
nextText: 'Next', // Display text for next month link
currentText: 'Today', // Display text for current month link
monthNames: ['January','February','March','April','May','June',
'July','August','September','October','November','December'], //
Names of months for drop-down and formatting
monthNamesShort: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul',
'Aug', 'Sep', 'Oct', 'Nov', 'Dec'], // For formatting
dayNames: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday',
'Friday', 'Saturday'], // For formatting
dayNamesShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'], //
For formatting
dayNamesMin: ['Su','Mo','Tu','We','Th','Fr','Sa'], // Column headings
for days starting at Sunday
weekHeader: 'Wk', // Column header for week of the year
dateFormat: 'mm/dd/yy', // See format options on parseDate
firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
isRTL: false, // True if right-to-left language, false if left-to-right
showMonthAfterYear: false, // True if the year select precedes month,
false for month then year
yearSuffix: '' // Additional text to append to the year in the month
headers
};
this._defaults = { // Global defaults for all the date picker instances
showOn: 'focus', // 'focus' for popup on focus,
// 'button' for trigger button, or 'both' for either
showAnim: 'fadeIn', // Name of jQuery animation for popup
showOptions: {}, // Options for enhanced animations
defaultDate: null, // Used when field is blank: actual date,
// +/-number for offset from today, null for today
appendText: '', // Display text following the input box, e.g. showing
the format
buttonText: '...', // Text for trigger button
buttonImage: '', // URL for trigger button image
buttonImageOnly: false, // True if the image appears alone, false if it
appears on a button
hideIfNoPrevNext: false, // True to hide next/previous month links
// if not applicable, false to just disable them
navigationAsDateFormat: false, // True if date formatting applied to
prev/today/next links
gotoCurrent: false, // True if today link goes back to current
selection instead
changeMonth: false, // True if month can be selected directly, false if
only prev/next
changeYear: false, // True if year can be selected directly, false if
only prev/next
yearRange: 'c-10:c+10', // Range of years to display in drop-down,
// either relative to today's year (-nn:+nn), relative to
currently displayed year
// (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the
above (nnnn:-n)
 showOtherMonths: false, // True to show dates in other months, false to
leave blank
selectOtherMonths: false, // True to allow selection of dates in other
months, false for unselectable
showWeek: false, // True to show week of the year, false to not show it
calculateWeek: this.iso8601Week, // How to calculate the week of the
year,
// takes a Date and returns the number of the week for it
shortYearCutoff: '+10', // Short year values < this are in the current
century,
// > this are in the previous century,
// string value starting with '+' for current year + value
minDate: null, // The earliest selectable date, or null for no limit
maxDate: null, // The latest selectable date, or null for no limit
duration: 'fast', // Duration of display/closure
beforeShowDay: null, // Function that takes a date and returns an array
with
// [0] = true if selectable, false if not, [1] = custom CSS class
name(s) or '',
// [2] = cell title (optional), e.g. $.[Link]
beforeShow: null, // Function that takes an input field and
// returns a set of custom settings for the date picker
onSelect: null, // Define a callback function when a date is selected
onChangeMonthYear: null, // Define a callback function when the month
or year is changed
onClose: null, // Define a callback function when the datepicker is
closed
numberOfMonths: 1, // Number of months to show at a time
showCurrentAtPos: 0, // The position in multipe months at which to show
the current month (starting at 0)
stepMonths: 1, // Number of months to step back/forward
stepBigMonths: 12, // Number of months to step back/forward for the big
links
altField: '', // Selector for an alternate field to store selected
dates into
altFormat: '', // The date format to use for the alternate field
constrainInput: true, // The input is constrained by the current date
format
showButtonPanel: false, // True to show button panel, false to not show
it
autoSize: false, // True to size the input for the date format, false
to leave as is
disabled: false // The initial disabled state
};
$.extend(this._defaults, [Link]['']);
[Link] = bindHover($('<div id="' + this._mainDivId + '" class="ui-
datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all"></div>'));
}

$.extend([Link], {
/* Class name added to elements to indicate already configured with a date
picker. */
markerClassName: 'hasDatepicker',

//Keep track of the maximum number of rows displayed (see #7043)

maxRows: 4,

/* Debug logging (if enabled). */

log: function () {
 if ([Link])
[Link]('', arguments);
},

// TODO rename to "widget" when switching to widget factory

_widgetDatepicker: function() {
return [Link];
},

/* Override the default settings for all instances of the date picker.
@param settings object - the new settings to use as defaults (anonymous
object)
@return the manager object */
setDefaults: function(settings) {
extendRemove(this._defaults, settings || {});
return this;
},

/* Attach the date picker to a jQuery selection.

@param target element - the target input field or division or span
@param settings object - the new settings to use for this date picker
instance (anonymous) */
_attachDatepicker: function(target, settings) {
// check for settings on the control itself - in namespace 'date:'
var inlineSettings = null;
for (var attrName in this._defaults) {
var attrValue = [Link]('date:' + attrName);
if (attrValue) {
inlineSettings = inlineSettings || {};
try {
inlineSettings[attrName] = eval(attrValue);
} catch (err) {
inlineSettings[attrName] = attrValue;
}
}
}
var nodeName = [Link]();
var inline = (nodeName == 'div' || nodeName == 'span');
if (![Link]) {
[Link] += 1;
[Link] = 'dp' + [Link];
}
var inst = this._newInst($(target), inline);
[Link] = $.extend({}, settings || {}, inlineSettings || {});
if (nodeName == 'input') {
this._connectDatepicker(target, inst);
} else if (inline) {
this._inlineDatepicker(target, inst);
}
},

/* Create a new instance object. */

_newInst: function(target, inline) {
var id = target[0].[Link](/([^A-Za-z0-9_-])/g, '\\\\$1'); // escape
jQuery meta chars
return {id: id, input: target, // associated target
selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current
selection
drawMonth: 0, drawYear: 0, // month being drawn
 inline: inline, // is datepicker inline or not
dpDiv: (!inline ? [Link] : // presentation div
bindHover($('<div class="' + this._inlineClass + ' ui-datepicker
ui-widget ui-widget-content ui-helper-clearfix ui-corner-all"></div>')))};
},

/* Attach the date picker to an input field. */

_connectDatepicker: function(target, inst) {
var input = $(target);
[Link] = $([]);
[Link] = $([]);
if ([Link]([Link]))
return;
this._attachments(input, inst);
[Link]([Link]).keydown(this._doKeyDown).
keypress(this._doKeyPress).keyup(this._doKeyUp).
bind("[Link]", function(event, key, value) {
[Link][key] = value;
}).bind("[Link]", function(event, key) {
return this._get(inst, key);
});
this._autoSize(inst);
$.data(target, PROP_NAME, inst);
//If disabled option is true, disable the datepicker once it has been
attached to the input (see ticket #5665)
if( [Link] ) {
this._disableDatepicker( target );
}
},

/* Make attachments based on settings. */

_attachments: function(input, inst) {
var appendText = this._get(inst, 'appendText');
var isRTL = this._get(inst, 'isRTL');
if ([Link])
[Link]();
if (appendText) {
[Link] = $('<span class="' + this._appendClass + '">' +
appendText + '</span>');
input[isRTL ? 'before' : 'after']([Link]);
}
[Link]('focus', this._showDatepicker);
if ([Link])
[Link]();
var showOn = this._get(inst, 'showOn');
if (showOn == 'focus' || showOn == 'both') // pop-up date picker when
in the marked field
[Link](this._showDatepicker);
if (showOn == 'button' || showOn == 'both') { // pop-up date picker
when button clicked
var buttonText = this._get(inst, 'buttonText');
var buttonImage = this._get(inst, 'buttonImage');
[Link] = $(this._get(inst, 'buttonImageOnly') ?
$('<img/>').addClass(this._triggerClass).
attr({ src: buttonImage, alt: buttonText, title:
buttonText }) :
$('<button
type="button"></button>').addClass(this._triggerClass).
html(buttonImage == '' ? buttonText :
$('<img/>').attr(
{ src:buttonImage, alt:buttonText,
title:buttonText })));
input[isRTL ? 'before' : 'after']([Link]);
[Link](function() {
if ($.datepicker._datepickerShowing &&
$.datepicker._lastInput == input[0])
$.datepicker._hideDatepicker();
else if ($.datepicker._datepickerShowing &&
$.datepicker._lastInput != input[0]) {
$.datepicker._hideDatepicker();
$.datepicker._showDatepicker(input[0]);
} else
$.datepicker._showDatepicker(input[0]);
return false;
});
}
},

/* Apply the maximum length for the date format. */

_autoSize: function(inst) {
if (this._get(inst, 'autoSize') && ![Link]) {
var date = new Date(2009, 12 - 1, 20); // Ensure double digits
var dateFormat = this._get(inst, 'dateFormat');
if ([Link](/[DM]/)) {
var findMax = function(names) {
var max = 0;
var maxI = 0;
for (var i = 0; i < [Link]; i++) {
if (names[i].length > max) {
max = names[i].length;
maxI = i;
}
}
return maxI;
};
[Link](findMax(this._get(inst,
([Link](/MM/) ?
'monthNames' : 'monthNamesShort'))));
[Link](findMax(this._get(inst,
([Link](/DD/) ?
'dayNames' : 'dayNamesShort'))) + 20 -
[Link]());
}
[Link]('size', this._formatDate(inst, date).length);
}
},

/* Attach an inline date picker to a div. */

_inlineDatepicker: function(target, inst) {
var divSpan = $(target);
if ([Link]([Link]))
return;
[Link]([Link]).append([Link]).
bind("[Link]", function(event, key, value){
[Link][key] = value;
}).bind("[Link]", function(event, key){
return this._get(inst, key);
});
 $.data(target, PROP_NAME, inst);
this._setDate(inst, this._getDefaultDate(inst), true);
this._updateDatepicker(inst);
this._updateAlternate(inst);
//If disabled option is true, disable the datepicker before showing it
(see ticket #5665)
if( [Link] ) {
this._disableDatepicker( target );
}
// Set display:block in place of [Link]() which won't work on
disconnected elements
// [Link] - A Datepicker created on a
detached div has zero height
[Link]( "display", "block" );
},

/* Pop-up the date picker in a "dialog" box.

@param input element - ignored
@param date string or Date - the initial date to display
@param onSelect function - the function to call when a date is selected
@param settings object - update the dialog date picker instance's
settings (anonymous object)
@param pos int[2] - coordinates for the dialog's position within
the screen or
event - with x/y coordinates or
leave empty for default (screen centre)
@return the manager object */
_dialogDatepicker: function(input, date, onSelect, settings, pos) {
var inst = this._dialogInst; // internal instance
if (!inst) {
[Link] += 1;
var id = 'dp' + [Link];
this._dialogInput = $('<input type="text" id="' + id +
'" style="position: absolute; top: -100px; width:
0px;"/>');
this._dialogInput.keydown(this._doKeyDown);
$('body').append(this._dialogInput);
inst = this._dialogInst = this._newInst(this._dialogInput,
false);
[Link] = {};
$.data(this._dialogInput[0], PROP_NAME, inst);
}
extendRemove([Link], settings || {});
date = (date && [Link] == Date ? this._formatDate(inst, date)
: date);
this._dialogInput.val(date);

this._pos = (pos ? ([Link] ? pos : [[Link], [Link]]) : null);

if (!this._pos) {
var browserWidth = [Link];
var browserHeight = [Link];
var scrollX = [Link] ||
[Link];
var scrollY = [Link] ||
[Link];
this._pos = // should use actual width/height below
[(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) -
150 + scrollY];
}
 // move input on screen for focus, but hidden behind dialog
this._dialogInput.css('left', (this._pos[0] + 20) + 'px').css('top',
this._pos[1] + 'px');
[Link] = onSelect;
this._inDialog = true;
[Link](this._dialogClass);
this._showDatepicker(this._dialogInput[0]);
if ($.blockUI)
$.blockUI([Link]);
$.data(this._dialogInput[0], PROP_NAME, inst);
return this;
},

/* Detach a datepicker from its control.

@param target element - the target input field or division or span */
_destroyDatepicker: function(target) {
var $target = $(target);
var inst = $.data(target, PROP_NAME);
if (!$[Link]([Link])) {
return;
}
var nodeName = [Link]();
$.removeData(target, PROP_NAME);
if (nodeName == 'input') {
[Link]();
[Link]();
$[Link]([Link]).
unbind('focus', this._showDatepicker).
unbind('keydown', this._doKeyDown).
unbind('keypress', this._doKeyPress).
unbind('keyup', this._doKeyUp);
} else if (nodeName == 'div' || nodeName == 'span')
$[Link]([Link]).empty();
},

/* Enable the date picker to a jQuery selection.

@param target element - the target input field or division or span */
_enableDatepicker: function(target) {
var $target = $(target);
var inst = $.data(target, PROP_NAME);
if (!$[Link]([Link])) {
return;
}
var nodeName = [Link]();
if (nodeName == 'input') {
[Link] = false;
[Link]('button').
each(function() { [Link] = false; }).end().
filter('img').css({opacity: '1.0', cursor: ''});
}
else if (nodeName == 'div' || nodeName == 'span') {
var inline = $[Link]('.' + this._inlineClass);
[Link]().removeClass('ui-state-disabled');
[Link]("[Link]-datepicker-month, [Link]-datepicker-
year").
removeAttr("disabled");
}
this._disabledInputs = $.map(this._disabledInputs,
 function(value) { return (value == target ? null : value); }); //
delete entry
},

/* Disable the date picker to a jQuery selection.

@param target element - the target input field or division or span */
_disableDatepicker: function(target) {
var $target = $(target);
var inst = $.data(target, PROP_NAME);
if (!$[Link]([Link])) {
return;
}
var nodeName = [Link]();
if (nodeName == 'input') {
[Link] = true;
[Link]('button').
each(function() { [Link] = true; }).end().
filter('img').css({opacity: '0.5', cursor: 'default'});
}
else if (nodeName == 'div' || nodeName == 'span') {
var inline = $[Link]('.' + this._inlineClass);
[Link]().addClass('ui-state-disabled');
[Link]("[Link]-datepicker-month, [Link]-datepicker-
year").
attr("disabled", "disabled");
}
this._disabledInputs = $.map(this._disabledInputs,
function(value) { return (value == target ? null : value); }); //
delete entry
this._disabledInputs[this._disabledInputs.length] = target;
},

/* Is the first field in a jQuery collection disabled as a datepicker?

@param target element - the target input field or division or span
@return boolean - true if disabled, false if enabled */
_isDisabledDatepicker: function(target) {
if (!target) {
return false;
}
for (var i = 0; i < this._disabledInputs.length; i++) {
if (this._disabledInputs[i] == target)
return true;
}
return false;
},

/* Retrieve the instance data for the target control.

@param target element - the target input field or division or span
@return object - the associated instance data
@throws error if a jQuery problem getting data */
_getInst: function(target) {
try {
return $.data(target, PROP_NAME);
}
catch (err) {
throw 'Missing instance data for this datepicker';
}
},
 /* Update or retrieve the settings for a date picker attached to an input
field or division.
@param target element - the target input field or division or span
@param name object - the new settings to update or
string - the name of the setting to change or retrieve,
when retrieving also 'all' for all instance settings or
'defaults' for all global defaults
@param value any - the new value for the setting
(omit if above is an object or to retrieve a value) */
_optionDatepicker: function(target, name, value) {
var inst = this._getInst(target);
if ([Link] == 2 && typeof name == 'string') {
return (name == 'defaults' ? $.extend({}, $.datepicker._defaults)
:
(inst ? (name == 'all' ? $.extend({}, [Link]) :
this._get(inst, name)) : null));
}
var settings = name || {};
if (typeof name == 'string') {
settings = {};
settings[name] = value;
}
if (inst) {
if (this._curInst == inst) {
this._hideDatepicker();
}
var date = this._getDateDatepicker(target, true);
var minDate = this._getMinMaxDate(inst, 'min');
var maxDate = this._getMinMaxDate(inst, 'max');
extendRemove([Link], settings);
// reformat the old minDate/maxDate values if dateFormat changes
and a new minDate/maxDate isn't provided
if (minDate !== null && settings['dateFormat'] !== undefined &&
settings['minDate'] === undefined)
[Link] = this._formatDate(inst, minDate);
if (maxDate !== null && settings['dateFormat'] !== undefined &&
settings['maxDate'] === undefined)
[Link] = this._formatDate(inst, maxDate);
this._attachments($(target), inst);
this._autoSize(inst);
this._setDate(inst, date);
this._updateAlternate(inst);
this._updateDatepicker(inst);
}
},

// change method deprecated

_changeDatepicker: function(target, name, value) {
this._optionDatepicker(target, name, value);
},

/* Redraw the date picker attached to an input field or division.

@param target element - the target input field or division or span */
_refreshDatepicker: function(target) {
var inst = this._getInst(target);
if (inst) {
this._updateDatepicker(inst);
}
},
 /* Set the dates for a jQuery selection.
@param target element - the target input field or division or span
@param date Date - the new date */
_setDateDatepicker: function(target, date) {
var inst = this._getInst(target);
if (inst) {
this._setDate(inst, date);
this._updateDatepicker(inst);
this._updateAlternate(inst);
}
},

/* Get the date(s) for the first entry in a jQuery selection.

@param target element - the target input field or division or span
@param noDefault boolean - true if no default date is to be used
@return Date - the current date */
_getDateDatepicker: function(target, noDefault) {
var inst = this._getInst(target);
if (inst && ![Link])
this._setDateFromField(inst, noDefault);
return (inst ? this._getDate(inst) : null);
},

/* Handle keystrokes. */
_doKeyDown: function(event) {
var inst = $.datepicker._getInst([Link]);
var handled = true;
var isRTL = [Link]('.ui-datepicker-rtl');
inst._keyEvent = true;
if ($.datepicker._datepickerShowing)
switch ([Link]) {
case 9: $.datepicker._hideDatepicker();
handled = false;
break; // hide on tab out
case 13: var sel = $('td.' + $.datepicker._dayOverClass +
':not(.' +
$.datepicker._currentClass +
')', [Link]);
if (sel[0])
$.datepicker._selectDay([Link],
[Link], [Link], sel[0]);
var onSelect = $.datepicker._get(inst,
'onSelect');
if (onSelect) {
var dateStr =
$.datepicker._formatDate(inst);

// trigger custom callback

[Link](([Link] ?
[Link][0] : null), [dateStr, inst]);
}
else
$.datepicker._hideDatepicker();
return false; // don't submit the form
break; // select the value on enter
case 27: $.datepicker._hideDatepicker();
break; // hide on escape
case 33: $.datepicker._adjustDate([Link],
([Link] ?
-$.datepicker._get(inst, 'stepBigMonths')
:
-$.datepicker._get(inst, 'stepMonths')),
'M');
break; // previous month/year on page up/+ ctrl
case 34: $.datepicker._adjustDate([Link],
([Link] ?
+$.datepicker._get(inst, 'stepBigMonths')
:
+$.datepicker._get(inst, 'stepMonths')),
'M');
break; // next month/year on page down/+ ctrl
case 35: if ([Link] || [Link])
$.datepicker._clearDate([Link]);
handled = [Link] || [Link];
break; // clear on ctrl or command +end
case 36: if ([Link] || [Link])
$.datepicker._gotoToday([Link]);
handled = [Link] || [Link];
break; // current on ctrl or command +home
case 37: if ([Link] || [Link])
$.datepicker._adjustDate([Link], (isRTL ? +1 : -1), 'D');
handled = [Link] || [Link];
// -1 day on ctrl or command +left
if ([Link])
$.datepicker._adjustDate([Link], ([Link] ?
-$.datepicker._get(inst,
'stepBigMonths') :
-$.datepicker._get(inst,
'stepMonths')), 'M');
// next month/year on alt +left on Mac
break;
case 38: if ([Link] || [Link])
$.datepicker._adjustDate([Link], -7, 'D');
handled = [Link] || [Link];
break; // -1 week on ctrl or command +up
case 39: if ([Link] || [Link])
$.datepicker._adjustDate([Link], (isRTL ? -1 : +1), 'D');
handled = [Link] || [Link];
// +1 day on ctrl or command +right
if ([Link])
$.datepicker._adjustDate([Link], ([Link] ?
+$.datepicker._get(inst,
'stepBigMonths') :
+$.datepicker._get(inst,
'stepMonths')), 'M');
// next month/year on alt +right
break;
case 40: if ([Link] || [Link])
$.datepicker._adjustDate([Link], +7, 'D');
handled = [Link] || [Link];
break; // +1 week on ctrl or command +down
default: handled = false;
}
else if ([Link] == 36 && [Link]) // display the date
picker on ctrl+home
$.datepicker._showDatepicker(this);
else {
 handled = false;
}
if (handled) {
[Link]();
[Link]();
}
},

/* Filter entered characters - based on date format. */

_doKeyPress: function(event) {
var inst = $.datepicker._getInst([Link]);
if ($.datepicker._get(inst, 'constrainInput')) {
var chars = $.datepicker._possibleChars($.datepicker._get(inst,
'dateFormat'));
var chr = [Link]([Link] == undefined ?
[Link] : [Link]);
return [Link] || [Link] || (chr < ' ' || !chars ||
[Link](chr) > -1);
}
},

/* Synchronise manual entry and field/alternate field. */

_doKeyUp: function(event) {
var inst = $.datepicker._getInst([Link]);
if ([Link]() != [Link]) {
try {
var date = $.[Link]($.datepicker._get(inst,
'dateFormat'),
([Link] ? [Link]() : null),
$.datepicker._getFormatConfig(inst));
if (date) { // only if valid
$.datepicker._setDateFromField(inst);
$.datepicker._updateAlternate(inst);
$.datepicker._updateDatepicker(inst);
}
}
catch (err) {
$.[Link](err);
}
}
return true;
},

/* Pop-up the date picker for a given input field.

If false returned from beforeShow event handler do not show.
@param input element - the input field attached to the date picker or
event - if triggered by focus */
_showDatepicker: function(input) {
input = [Link] || input;
if ([Link]() != 'input') // find from button/image
trigger
input = $('input', [Link])[0];
if ($.datepicker._isDisabledDatepicker(input) ||
$.datepicker._lastInput == input) // already here
return;
var inst = $.datepicker._getInst(input);
if ($.datepicker._curInst && $.datepicker._curInst != inst) {
$.datepicker._curInst.[Link](true, true);
if ( inst && $.datepicker._datepickerShowing ) {
 $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] );
}
}
var beforeShow = $.datepicker._get(inst, 'beforeShow');
var beforeShowSettings = beforeShow ? [Link](input, [input,
inst]) : {};
if(beforeShowSettings === false){
//false
return;
}
extendRemove([Link], beforeShowSettings);
[Link] = null;
$.datepicker._lastInput = input;
$.datepicker._setDateFromField(inst);
if ($.datepicker._inDialog) // hide cursor
[Link] = '';
if (!$.datepicker._pos) { // position below input
$.datepicker._pos = $.datepicker._findPos(input);
$.datepicker._pos[1] += [Link]; // add the height
}
var isFixed = false;
$(input).parents().each(function() {
isFixed |= $(this).css('position') == 'fixed';
return !isFixed;
});
if (isFixed && $.[Link]) { // correction for Opera when fixed
and scrolled
$.datepicker._pos[0] -= [Link];
$.datepicker._pos[1] -= [Link];
}
var offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
$.datepicker._pos = null;
//to avoid flashes on Firefox
[Link]();
// determine sizing offscreen
[Link]({position: 'absolute', display: 'block', top: '-
1000px'});
$.datepicker._updateDatepicker(inst);
// fix width for dynamic number of date pickers
// and adjust position before showing
offset = $.datepicker._checkOffset(inst, offset, isFixed);
[Link]({position: ($.datepicker._inDialog && $.blockUI ?
'static' : (isFixed ? 'fixed' : 'absolute')), display: 'none',
left: [Link] + 'px', top: [Link] + 'px'});
if (![Link]) {
var showAnim = $.datepicker._get(inst, 'showAnim');
var duration = $.datepicker._get(inst, 'duration');
var postProcess = function() {
var cover = [Link]('[Link]-datepicker-
cover'); // IE6- only
if( !! [Link] ){
var borders = $.datepicker._getBorders([Link]);
[Link]({left: -borders[0], top: -borders[1],
width: [Link](), height:
[Link]()});
}
};
[Link]($(input).zIndex()+1);
 $.datepicker._datepickerShowing = true;
if ($.effects && $.effects[showAnim])
[Link](showAnim, $.datepicker._get(inst,
'showOptions'), duration, postProcess);
else
[Link][showAnim || 'show']((showAnim ? duration :
null), postProcess);
if (!showAnim || !duration)
postProcess();
if ([Link](':visible') && )
[Link]();
$.datepicker._curInst = inst;
}
},

/* Generate the date picker content. */

_updateDatepicker: function(inst) {
var self = this;
[Link] = 4; //Reset the max number of rows being displayed (see
#7043)
var borders = $.datepicker._getBorders([Link]);
instActive = inst; // for delegate hover events
[Link]().append(this._generateHTML(inst));
this._attachHandlers(inst);
var cover = [Link]('[Link]-datepicker-cover'); // IE6- only
if( !![Link] ){ //avoid call to outerXXXX() when not in IE6
[Link]({left: -borders[0], top: -borders[1], width:
[Link](), height: [Link]()})
}
[Link]('.' + this._dayOverClass + ' a').mouseover();
var numMonths = this._getNumberOfMonths(inst);
var cols = numMonths[1];
var width = 17;
[Link]('ui-datepicker-multi-2 ui-datepicker-multi-3 ui-
datepicker-multi-4').width('');
if (cols > 1)
[Link]('ui-datepicker-multi-' + cols).css('width',
(width * cols) + 'em');
[Link][(numMonths[0] != 1 || numMonths[1] != 1 ? 'add' : 'remove')
+
'Class']('ui-datepicker-multi');
[Link][(this._get(inst, 'isRTL') ? 'add' : 'remove') +
'Class']('ui-datepicker-rtl');
if (inst == $.datepicker._curInst && $.datepicker._datepickerShowing &&
[Link] &&
// #6694 - don't focus the input if it's already focused
// this breaks the change event in IE
[Link](':visible') &&  &&
[Link][0] != [Link])
[Link]();
// deffered render of the years select (to avoid flashes on Firefox)
if( [Link] ){
var origyearshtml = [Link];
setTimeout(function(){
//assure that [Link] didn't change.
if( origyearshtml === [Link] && [Link] ){
[Link]('[Link]-datepicker-
year:first').replaceWith([Link]);
}
 origyearshtml = [Link] = null;
}, 0);
}
},

/* Retrieve the size of left and top borders for an element.

@param elem (jQuery object) the element of interest
@return (number[2]) the left and top borders */
_getBorders: function(elem) {
var convert = function(value) {
return {thin: 1, medium: 2, thick: 3}[value] || value;
};
return [parseFloat(convert([Link]('border-left-width'))),
parseFloat(convert([Link]('border-top-width')))];
},

/* Check positioning to remain on screen. */

_checkOffset: function(inst, offset, isFixed) {
var dpWidth = [Link]();
var dpHeight = [Link]();
var inputWidth = [Link] ? [Link]() : 0;
var inputHeight = [Link] ? [Link]() : 0;
var viewWidth = [Link] + (isFixed ? 0 : $
(document).scrollLeft());
var viewHeight = [Link] + (isFixed ? 0 :
$(document).scrollTop());

[Link] -= (this._get(inst, 'isRTL') ? (dpWidth - inputWidth) : 0);

[Link] -= (isFixed && [Link] == [Link]().left) ? $
(document).scrollLeft() : 0;
[Link] -= (isFixed && [Link] == ([Link]().top +
inputHeight)) ? $(document).scrollTop() : 0;

// now check if datepicker is showing outside window viewport - move to

a better place if so.
[Link] -= [Link]([Link], ([Link] + dpWidth > viewWidth
&& viewWidth > dpWidth) ?
[Link]([Link] + dpWidth - viewWidth) : 0);
[Link] -= [Link]([Link], ([Link] + dpHeight > viewHeight
&& viewHeight > dpHeight) ?
[Link](dpHeight + inputHeight) : 0);

return offset;
},

/* Find an object's position on the screen. */

_findPos: function(obj) {
var inst = this._getInst(obj);
var isRTL = this._get(inst, 'isRTL');
while (obj && ([Link] == 'hidden' || [Link] != 1 ||
$.[Link](obj))) {
obj = obj[isRTL ? 'previousSibling' : 'nextSibling'];
}
var position = $(obj).offset();
return [[Link], [Link]];
},

/* Hide the date picker from view.

@param input element - the input field attached to the date picker */
 _hideDatepicker: function(input) {
var inst = this._curInst;
if (!inst || (input && inst != $.data(input, PROP_NAME)))
return;
if (this._datepickerShowing) {
var showAnim = this._get(inst, 'showAnim');
var duration = this._get(inst, 'duration');
var postProcess = function() {
$.datepicker._tidyDialog(inst);
};
if ($.effects && $.effects[showAnim])
[Link](showAnim, $.datepicker._get(inst,
'showOptions'), duration, postProcess);
else
[Link][(showAnim == 'slideDown' ? 'slideUp' :
(showAnim == 'fadeIn' ? 'fadeOut' : 'hide'))]
((showAnim ? duration : null), postProcess);
if (!showAnim)
postProcess();
this._datepickerShowing = false;
var onClose = this._get(inst, 'onClose');
if (onClose)
[Link](([Link] ? [Link][0] : null),
[([Link] ? [Link]() : ''), inst]);
this._lastInput = null;
if (this._inDialog) {
this._dialogInput.css({ position: 'absolute', left: '0',
top: '-100px' });
if ($.blockUI) {
$.unblockUI();
$('body').append([Link]);
}
}
this._inDialog = false;
}
},

/* Tidy up after a dialog display. */

_tidyDialog: function(inst) {
[Link](this._dialogClass).unbind('.ui-datepicker-
calendar');
},

/* Close date picker if clicked elsewhere. */

_checkExternalClick: function(event) {
if (!$.datepicker._curInst)
return;

var $target = $([Link]),

inst = $.datepicker._getInst($target[0]);

if ( ( ( $target[0].id != $.datepicker._mainDivId &&

$[Link]('#' + $.datepicker._mainDivId).length == 0
&&
!$[Link]($.[Link]) &&
!$[Link]("." + $.datepicker._triggerClass).length
&&
$.datepicker._datepickerShowing && !($.datepicker._inDialog
&& $.blockUI) ) ) ||
 ( $[Link]($.[Link]) &&
$.datepicker._curInst != inst ) )
$.datepicker._hideDatepicker();
},

/* Adjust one of the date sub-fields. */

_adjustDate: function(id, offset, period) {
var target = $(id);
var inst = this._getInst(target[0]);
if (this._isDisabledDatepicker(target[0])) {
return;
}
this._adjustInstDate(inst, offset +
(period == 'M' ? this._get(inst, 'showCurrentAtPos') : 0), //
undo positioning
period);
this._updateDatepicker(inst);
},

/* Action for current link. */

_gotoToday: function(id) {
var target = $(id);
var inst = this._getInst(target[0]);
if (this._get(inst, 'gotoCurrent') && [Link]) {
[Link] = [Link];
[Link] = [Link] = [Link];
[Link] = [Link] = [Link];
}
else {
var date = new Date();
[Link] = [Link]();
[Link] = [Link] = [Link]();
[Link] = [Link] = [Link]();
}
this._notifyChange(inst);
this._adjustDate(target);
},

/* Action for selecting a new month/year. */

_selectMonthYear: function(id, select, period) {
var target = $(id);
var inst = this._getInst(target[0]);
inst['selected' + (period == 'M' ? 'Month' : 'Year')] =
inst['draw' + (period == 'M' ? 'Month' : 'Year')] =
parseInt([Link][[Link]].value,10);
this._notifyChange(inst);
this._adjustDate(target);
},

/* Action for selecting a day. */

_selectDay: function(id, month, year, td) {
var target = $(id);
if ($(td).hasClass(this._unselectableClass) ||
this._isDisabledDatepicker(target[0])) {
return;
}
var inst = this._getInst(target[0]);
[Link] = [Link] = $('a', td).html();
[Link] = [Link] = month;
 [Link] = [Link] = year;
this._selectDate(id, this._formatDate(inst,
[Link], [Link], [Link]));
},

/* Erase the input field and hide the date picker. */

_clearDate: function(id) {
var target = $(id);
var inst = this._getInst(target[0]);
this._selectDate(target, '');
},

/* Update the input field with the selected date. */

_selectDate: function(id, dateStr) {
var target = $(id);
var inst = this._getInst(target[0]);
dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
if ([Link])
[Link](dateStr);
this._updateAlternate(inst);
var onSelect = this._get(inst, 'onSelect');
if (onSelect)
[Link](([Link] ? [Link][0] : null), [dateStr,
inst]); // trigger custom callback
else if ([Link])
[Link]('change'); // fire the change event
if ([Link])
this._updateDatepicker(inst);
else {
this._hideDatepicker();
this._lastInput = [Link][0];
if (typeof([Link][0]) != 'object')
[Link](); // restore focus
this._lastInput = null;
}
},

/* Update any alternate field to synchronise with the main field. */

_updateAlternate: function(inst) {
var altField = this._get(inst, 'altField');
if (altField) { // update alternate field too
var altFormat = this._get(inst, 'altFormat') || this._get(inst,
'dateFormat');
var date = this._getDate(inst);
var dateStr = [Link](altFormat, date,
this._getFormatConfig(inst));
$(altField).each(function() { $(this).val(dateStr); });
}
},

/* Set as beforeShowDay function to prevent selection of weekends.

@param date Date - the date to customise
@return [boolean, string] - is this date selectable?, what is its CSS
class? */
noWeekends: function(date) {
var day = [Link]();
return [(day > 0 && day < 6), ''];
},
 /* Set as calculateWeek to determine the week of the year based on the ISO
8601 definition.
@param date Date - the date to get the week for
@return number - the number of the week within the year that contains
this date */
iso8601Week: function(date) {
var checkDate = new Date([Link]());
// Find Thursday of this week starting on Monday
[Link]([Link]() + 4 - ([Link]() || 7));
var time = [Link]();
[Link](0); // Compare with Jan 1
[Link](1);
return [Link]([Link]((time - checkDate) / 86400000) / 7) + 1;
},

/* Parse a string value into a date object.

See formatDate below for the possible formats.

@param format string - the expected format of the date

@param value string - the date in the above format
@param settings Object - attributes include:
shortYearCutoff number - the cutoff year for
determining the century (optional)
dayNamesShort string[7] - abbreviated names of the
days from Sunday (optional)
dayNames string[7] - names of the days from
Sunday (optional)
monthNamesShort string[12] - abbreviated names of the
months (optional)
monthNames string[12] - names of the months
(optional)
@return Date - the extracted date value or null if value is blank */
parseDate: function (format, value, settings) {
if (format == null || value == null)
throw 'Invalid arguments';
value = (typeof value == 'object' ? [Link]() : value + '');
if (value == '')
return null;
var shortYearCutoff = (settings ? [Link] : null) ||
this._defaults.shortYearCutoff;
shortYearCutoff = (typeof shortYearCutoff != 'string' ? shortYearCutoff
:
new Date().getFullYear() % 100 + parseInt(shortYearCutoff,
10));
var dayNamesShort = (settings ? [Link] : null) ||
this._defaults.dayNamesShort;
var dayNames = (settings ? [Link] : null) ||
this._defaults.dayNames;
var monthNamesShort = (settings ? [Link] : null) ||
this._defaults.monthNamesShort;
var monthNames = (settings ? [Link] : null) ||
this._defaults.monthNames;
var year = -1;
var month = -1;
var day = -1;
var doy = -1;
var literal = false;
// Check whether a format character is doubled
var lookAhead = function(match) {
 var matches = (iFormat + 1 < [Link] &&
[Link](iFormat + 1) == match);
if (matches)
iFormat++;
return matches;
};
// Extract a number from the string value
var getNumber = function(match) {
var isDoubled = lookAhead(match);
var size = (match == '@' ? 14 : (match == '!' ? 20 :
(match == 'y' && isDoubled ? 4 : (match == 'o' ? 3 : 2))));
var digits = new RegExp('^\\d{1,' + size + '}');
var num = [Link](iValue).match(digits);
if (!num)
throw 'Missing number at position ' + iValue;
iValue += num[0].length;
return parseInt(num[0], 10);
};
// Extract a name from the string value and convert to an index
var getName = function(match, shortNames, longNames) {
var names = $.map(lookAhead(match) ? longNames : shortNames,
function (v, k) {
return [ [k, v] ];
}).sort(function (a, b) {
return -(a[1].length - b[1].length);
});
var index = -1;
$.each(names, function (i, pair) {
var name = pair[1];
if ([Link](iValue, [Link]).toLowerCase() ==
[Link]()) {
index = pair[0];
iValue += [Link];
return false;
}
});
if (index != -1)
return index + 1;
else
throw 'Unknown name at position ' + iValue;
};
// Confirm that a literal character matches the string value
var checkLiteral = function() {
if ([Link](iValue) != [Link](iFormat))
throw 'Unexpected literal at position ' + iValue;
iValue++;
};
var iValue = 0;
for (var iFormat = 0; iFormat < [Link]; iFormat++) {
if (literal)
if ([Link](iFormat) == "'" && !lookAhead("'"))
literal = false;
else
checkLiteral();
else
switch ([Link](iFormat)) {
case 'd':
day = getNumber('d');
break;
 case 'D':
getName('D', dayNamesShort, dayNames);
break;
case 'o':
doy = getNumber('o');
break;
case 'm':
month = getNumber('m');
break;
case 'M':
month = getName('M', monthNamesShort,
monthNames);
break;
case 'y':
year = getNumber('y');
break;
case '@':
var date = new Date(getNumber('@'));
year = [Link]();
month = [Link]() + 1;
day = [Link]();
break;
case '!':
var date = new Date((getNumber('!') -
this._ticksTo1970) / 10000);
year = [Link]();
month = [Link]() + 1;
day = [Link]();
break;
case "'":
if (lookAhead("'"))
checkLiteral();
else
literal = true;
break;
default:
checkLiteral();
}
}
if (iValue < [Link]){
throw "Extra/unparsed characters found in date: " +
[Link](iValue);
}
if (year == -1)
year = new Date().getFullYear();
else if (year < 100)
year += new Date().getFullYear() - new Date().getFullYear() % 100
+
(year <= shortYearCutoff ? 0 : -100);
if (doy > -1) {
month = 1;
day = doy;
do {
var dim = this._getDaysInMonth(year, month - 1);
if (day <= dim)
break;
month++;
day -= dim;
} while (true);
 }
var date = this._daylightSavingAdjust(new Date(year, month - 1, day));
if ([Link]() != year || [Link]() + 1 != month ||
[Link]() != day)
throw 'Invalid date'; // E.g. 31/02/00
return date;
},

/* Standard date formats. */

ATOM: 'yy-mm-dd', // RFC 3339 (ISO 8601)
COOKIE: 'D, dd M yy',
ISO_8601: 'yy-mm-dd',
RFC_822: 'D, d M y',
RFC_850: 'DD, dd-M-y',
RFC_1036: 'D, d M y',
RFC_1123: 'D, d M yy',
RFC_2822: 'D, d M yy',
RSS: 'D, d M y', // RFC 822
TICKS: '!',
TIMESTAMP: '@',
W3C: 'yy-mm-dd', // ISO 8601

_ticksTo1970: (((1970 - 1) * 365 + [Link](1970 / 4) - [Link](1970 /

100) +
[Link](1970 / 400)) * 24 * 60 * 60 * 10000000),

/* Format a date object into a string value.

The format can be combinations of the following:
d - day of month (no leading zero)
dd - day of month (two digit)
o - day of year (no leading zeros)
oo - day of year (three digit)
D - day name short
DD - day name long
m - month of year (no leading zero)
mm - month of year (two digit)
M - month name short
MM - month name long
y - year (two digit)
yy - year (four digit)
@ - Unix timestamp (ms since 01/01/1970)
! - Windows ticks (100ns since 01/01/0001)
'...' - literal text
'' - single quote

@param format string - the desired format of the date

@param date Date - the date value to format
@param settings Object - attributes include:
dayNamesShort string[7] - abbreviated names of the
days from Sunday (optional)
dayNames string[7] - names of the days from
Sunday (optional)
monthNamesShort string[12] - abbreviated names of the
months (optional)
monthNames string[12] - names of the months
(optional)
@return string - the date in the above format */
formatDate: function (format, date, settings) {
if (!date)
 return '';
var dayNamesShort = (settings ? [Link] : null) ||
this._defaults.dayNamesShort;
var dayNames = (settings ? [Link] : null) ||
this._defaults.dayNames;
var monthNamesShort = (settings ? [Link] : null) ||
this._defaults.monthNamesShort;
var monthNames = (settings ? [Link] : null) ||
this._defaults.monthNames;
// Check whether a format character is doubled
var lookAhead = function(match) {
var matches = (iFormat + 1 < [Link] &&
[Link](iFormat + 1) == match);
if (matches)
iFormat++;
return matches;
};
// Format a number, with leading zero if necessary
var formatNumber = function(match, value, len) {
var num = '' + value;
if (lookAhead(match))
while ([Link] < len)
num = '0' + num;
return num;
};
// Format a name, short or long as requested
var formatName = function(match, value, shortNames, longNames) {
return (lookAhead(match) ? longNames[value] : shortNames[value]);
};
var output = '';
var literal = false;
if (date)
for (var iFormat = 0; iFormat < [Link]; iFormat++) {
if (literal)
if ([Link](iFormat) == "'" && !lookAhead("'"))
literal = false;
else
output += [Link](iFormat);
else
switch ([Link](iFormat)) {
case 'd':
output += formatNumber('d',
[Link](), 2);
break;
case 'D':
output += formatName('D', [Link](),
dayNamesShort, dayNames);
break;
case 'o':
output += formatNumber('o',
[Link]((new
Date([Link](), [Link](), [Link]()).getTime() - new
Date([Link](), 0, 0).getTime()) / 86400000), 3);
break;
case 'm':
output += formatNumber('m',
[Link]() + 1, 2);
break;
case 'M':
 output += formatName('M',
[Link](), monthNamesShort, monthNames);
break;
case 'y':
output += (lookAhead('y') ?
[Link]() :
([Link]() % 100 < 10 ? '0' :
'') + [Link]() % 100);
break;
case '@':
output += [Link]();
break;
case '!':
output += [Link]() * 10000 +
this._ticksTo1970;
break;
case "'":
if (lookAhead("'"))
output += "'";
else
literal = true;
break;
default:
output += [Link](iFormat);
}
}
return output;
},

/* Extract all possible characters from the date format. */

_possibleChars: function (format) {
var chars = '';
var literal = false;
// Check whether a format character is doubled
var lookAhead = function(match) {
var matches = (iFormat + 1 < [Link] &&
[Link](iFormat + 1) == match);
if (matches)
iFormat++;
return matches;
};
for (var iFormat = 0; iFormat < [Link]; iFormat++)
if (literal)
if ([Link](iFormat) == "'" && !lookAhead("'"))
literal = false;
else
chars += [Link](iFormat);
else
switch ([Link](iFormat)) {
case 'd': case 'm': case 'y': case '@':
chars += '0123456789';
break;
case 'D': case 'M':
return null; // Accept anything
case "'":
if (lookAhead("'"))
chars += "'";
else
literal = true;
 break;
default:
chars += [Link](iFormat);
}
return chars;
},

/* Get a setting value, defaulting if necessary. */

_get: function(inst, name) {
return [Link][name] !== undefined ?
[Link][name] : this._defaults[name];
},

/* Parse existing date and initialise date picker. */

_setDateFromField: function(inst, noDefault) {
if ([Link]() == [Link]) {
return;
}
var dateFormat = this._get(inst, 'dateFormat');
var dates = [Link] = [Link] ? [Link]() : null;
var date, defaultDate;
date = defaultDate = this._getDefaultDate(inst);
var settings = this._getFormatConfig(inst);
try {
date = [Link](dateFormat, dates, settings) ||
defaultDate;
} catch (event) {
[Link](event);
dates = (noDefault ? '' : dates);
}
[Link] = [Link]();
[Link] = [Link] = [Link]();
[Link] = [Link] = [Link]();
[Link] = (dates ? [Link]() : 0);
[Link] = (dates ? [Link]() : 0);
[Link] = (dates ? [Link]() : 0);
this._adjustInstDate(inst);
},

/* Retrieve the default date shown on opening. */

_getDefaultDate: function(inst) {
return this._restrictMinMax(inst,
this._determineDate(inst, this._get(inst, 'defaultDate'), new
Date()));
},

/* A date may be specified as an exact value or a relative one. */

_determineDate: function(inst, date, defaultDate) {
var offsetNumeric = function(offset) {
var date = new Date();
[Link]([Link]() + offset);
return date;
};
var offsetString = function(offset) {
try {
return $.[Link]($.datepicker._get(inst,
'dateFormat'),
offset, $.datepicker._getFormatConfig(inst));
}
 catch (e) {
// Ignore
}
var date = ([Link]().match(/^c/) ?
$.datepicker._getDate(inst) : null) || new Date();
var year = [Link]();
var month = [Link]();
var day = [Link]();
var pattern = /([+-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g;
var matches = [Link](offset);
while (matches) {
switch (matches[2] || 'd') {
case 'd' : case 'D' :
day += parseInt(matches[1],10); break;
case 'w' : case 'W' :
day += parseInt(matches[1],10) * 7; break;
case 'm' : case 'M' :
month += parseInt(matches[1],10);
day = [Link](day,
$.datepicker._getDaysInMonth(year, month));
break;
case 'y': case 'Y' :
year += parseInt(matches[1],10);
day = [Link](day,
$.datepicker._getDaysInMonth(year, month));
break;
}
matches = [Link](offset);
}
return new Date(year, month, day);
};
var newDate = (date == null || date === '' ? defaultDate : (typeof date
== 'string' ? offsetString(date) :
(typeof date == 'number' ? (isNaN(date) ? defaultDate :
offsetNumeric(date)) : new Date([Link]()))));
newDate = (newDate && [Link]() == 'Invalid Date' ?
defaultDate : newDate);
if (newDate) {
[Link](0);
[Link](0);
[Link](0);
[Link](0);
}
return this._daylightSavingAdjust(newDate);
},

/* Handle switch to/from daylight saving.

Hours may be non-zero on daylight saving cut-over:
> 12 when midnight changeover, but then cannot generate
midnight datetime, so jump to 1AM, otherwise reset.
@param date (Date) the date to check
@return (Date) the corrected date */
_daylightSavingAdjust: function(date) {
if (!date) return null;
[Link]([Link]() > 12 ? [Link]() + 2 : 0);
return date;
},

/* Set the date(s) directly. */

 _setDate: function(inst, date, noChange) {
var clear = !date;
var origMonth = [Link];
var origYear = [Link];
var newDate = this._restrictMinMax(inst, this._determineDate(inst,
date, new Date()));
[Link] = [Link] = [Link]();
[Link] = [Link] = [Link] =
[Link]();
[Link] = [Link] = [Link] =
[Link]();
if ((origMonth != [Link] || origYear != [Link])
&& !noChange)
this._notifyChange(inst);
this._adjustInstDate(inst);
if ([Link]) {
[Link](clear ? '' : this._formatDate(inst));
}
},

/* Retrieve the date(s) directly. */

_getDate: function(inst) {
var startDate = (![Link] || ([Link] && [Link]()
== '') ? null :
this._daylightSavingAdjust(new Date(
[Link], [Link], [Link])));
return startDate;
},

/* Attach the onxxx handlers. These are declared statically so

* they work with static code transformers like Caja.
*/
_attachHandlers: function(inst) {
var stepMonths = this._get(inst, 'stepMonths');
var id = '#' + [Link]( /\\\\/g, "\\" );
[Link]('[data-handler]').map(function () {
var handler = {
prev: function () {
window['DP_jQuery_' +
dpuuid].datepicker._adjustDate(id, -stepMonths, 'M');
},
next: function () {
window['DP_jQuery_' +
dpuuid].datepicker._adjustDate(id, +stepMonths, 'M');
},
hide: function () {
window['DP_jQuery_' +
dpuuid].datepicker._hideDatepicker();
},
today: function () {
window['DP_jQuery_' +
dpuuid].datepicker._gotoToday(id);
},
selectDay: function () {
window['DP_jQuery_' +
dpuuid].datepicker._selectDay(id, +[Link]('data-month'),
+[Link]('data-year'), this);
return false;
},
 selectMonth: function () {
window['DP_jQuery_' +
dpuuid].datepicker._selectMonthYear(id, this, 'M');
return false;
},
selectYear: function () {
window['DP_jQuery_' +
dpuuid].datepicker._selectMonthYear(id, this, 'Y');
return false;
}
};
$(this).bind([Link]('data-event'),
handler[[Link]('data-handler')]);
});
},

/* Generate the HTML for the current state of the date picker. */
_generateHTML: function(inst) {
var today = new Date();
today = this._daylightSavingAdjust(
new Date([Link](), [Link](),
[Link]())); // clear time
var isRTL = this._get(inst, 'isRTL');
var showButtonPanel = this._get(inst, 'showButtonPanel');
var hideIfNoPrevNext = this._get(inst, 'hideIfNoPrevNext');
var navigationAsDateFormat = this._get(inst, 'navigationAsDateFormat');
var numMonths = this._getNumberOfMonths(inst);
var showCurrentAtPos = this._get(inst, 'showCurrentAtPos');
var stepMonths = this._get(inst, 'stepMonths');
var isMultiMonth = (numMonths[0] != 1 || numMonths[1] != 1);
var currentDate = this._daylightSavingAdjust((![Link] ? new
Date(9999, 9, 9) :
new Date([Link], [Link], [Link])));
var minDate = this._getMinMaxDate(inst, 'min');
var maxDate = this._getMinMaxDate(inst, 'max');
var drawMonth = [Link] - showCurrentAtPos;
var drawYear = [Link];
if (drawMonth < 0) {
drawMonth += 12;
drawYear--;
}
if (maxDate) {
var maxDraw = this._daylightSavingAdjust(new
Date([Link](),
[Link]() - (numMonths[0] * numMonths[1]) + 1,
[Link]()));
maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
while (this._daylightSavingAdjust(new Date(drawYear, drawMonth,
1)) > maxDraw) {
drawMonth--;
if (drawMonth < 0) {
drawMonth = 11;
drawYear--;
}
}
}
[Link] = drawMonth;
[Link] = drawYear;
var prevText = this._get(inst, 'prevText');
 prevText = (!navigationAsDateFormat ? prevText :
[Link](prevText,
this._daylightSavingAdjust(new Date(drawYear, drawMonth -
stepMonths, 1)),
this._getFormatConfig(inst)));
var prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
'<a class="ui-datepicker-prev ui-corner-all" data-handler="prev"
data-event="click"' +
' title="' + prevText + '"><span class="ui-icon ui-icon-circle-
triangle-' + ( isRTL ? 'e' : 'w') + '">' + prevText + '</span></a>' :
(hideIfNoPrevNext ? '' : '<a class="ui-datepicker-prev ui-corner-
all ui-state-disabled" title="'+ prevText +'"><span class="ui-icon ui-icon-circle-
triangle-' + ( isRTL ? 'e' : 'w') + '">' + prevText + '</span></a>'));
var nextText = this._get(inst, 'nextText');
nextText = (!navigationAsDateFormat ? nextText :
[Link](nextText,
this._daylightSavingAdjust(new Date(drawYear, drawMonth +
stepMonths, 1)),
this._getFormatConfig(inst)));
var next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
'<a class="ui-datepicker-next ui-corner-all" data-handler="next"
data-event="click"' +
' title="' + nextText + '"><span class="ui-icon ui-icon-circle-
triangle-' + ( isRTL ? 'w' : 'e') + '">' + nextText + '</span></a>' :
(hideIfNoPrevNext ? '' : '<a class="ui-datepicker-next ui-corner-
all ui-state-disabled" title="'+ nextText + '"><span class="ui-icon ui-icon-circle-
triangle-' + ( isRTL ? 'w' : 'e') + '">' + nextText + '</span></a>'));
var currentText = this._get(inst, 'currentText');
var gotoDate = (this._get(inst, 'gotoCurrent') && [Link] ?
currentDate : today);
currentText = (!navigationAsDateFormat ? currentText :
[Link](currentText, gotoDate,
this._getFormatConfig(inst)));
var controls = (![Link] ? '<button type="button" class="ui-
datepicker-close ui-state-default ui-priority-primary ui-corner-all" data-
handler="hide" data-event="click">' +
this._get(inst, 'closeText') + '</button>' : '');
var buttonPanel = (showButtonPanel) ? '<div class="ui-datepicker-
buttonpane ui-widget-content">' + (isRTL ? controls : '') +
(this._isInRange(inst, gotoDate) ? '<button type="button"
class="ui-datepicker-current ui-state-default ui-priority-secondary ui-corner-all"
data-handler="today" data-event="click"' +
'>' + currentText + '</button>' : '') + (isRTL ? '' : controls) +
'</div>' : '';
var firstDay = parseInt(this._get(inst, 'firstDay'),10);
firstDay = (isNaN(firstDay) ? 0 : firstDay);
var showWeek = this._get(inst, 'showWeek');
var dayNames = this._get(inst, 'dayNames');
var dayNamesShort = this._get(inst, 'dayNamesShort');
var dayNamesMin = this._get(inst, 'dayNamesMin');
var monthNames = this._get(inst, 'monthNames');
var monthNamesShort = this._get(inst, 'monthNamesShort');
var beforeShowDay = this._get(inst, 'beforeShowDay');
var showOtherMonths = this._get(inst, 'showOtherMonths');
var selectOtherMonths = this._get(inst, 'selectOtherMonths');
var calculateWeek = this._get(inst, 'calculateWeek') ||
this.iso8601Week;
var defaultDate = this._getDefaultDate(inst);
var html = '';
 for (var row = 0; row < numMonths[0]; row++) {
var group = '';
[Link] = 4;
for (var col = 0; col < numMonths[1]; col++) {
var selectedDate = this._daylightSavingAdjust(new
Date(drawYear, drawMonth, [Link]));
var cornerClass = ' ui-corner-all';
var calender = '';
if (isMultiMonth) {
calender += '<div class="ui-datepicker-group';
if (numMonths[1] > 1)
switch (col) {
case 0: calender += ' ui-datepicker-
group-first';
cornerClass = ' ui-corner-' +
(isRTL ? 'right' : 'left'); break;
case numMonths[1]-1: calender += ' ui-
datepicker-group-last';
cornerClass = ' ui-corner-' +
(isRTL ? 'left' : 'right'); break;
default: calender += ' ui-datepicker-
group-middle'; cornerClass = ''; break;
}
calender += '">';
}
calender += '<div class="ui-datepicker-header ui-widget-
header ui-helper-clearfix' + cornerClass + '">' +
(/all|left/.test(cornerClass) && row == 0 ? (isRTL ?
next : prev) : '') +
(/all|right/.test(cornerClass) && row == 0 ? (isRTL ?
prev : next) : '') +
this._generateMonthYearHeader(inst, drawMonth,
drawYear, minDate, maxDate,
row > 0 || col > 0, monthNames, monthNamesShort) + //
draw month headers
'</div><table class="ui-datepicker-calendar"><thead>'
+
'<tr>';
var thead = (showWeek ? '<th class="ui-datepicker-week-
col">' + this._get(inst, 'weekHeader') + '</th>' : '');
for (var dow = 0; dow < 7; dow++) { // days of the week
var day = (dow + firstDay) % 7;
thead += '<th' + ((dow + firstDay + 6) % 7 >= 5 ? '
class="ui-datepicker-week-end"' : '') + '>' +
'<span title="' + dayNames[day] + '">' +
dayNamesMin[day] + '</span></th>';
}
calender += thead + '</tr></thead><tbody>';
var daysInMonth = this._getDaysInMonth(drawYear,
drawMonth);
if (drawYear == [Link] && drawMonth ==
[Link])
[Link] = [Link]([Link],
daysInMonth);
var leadDays = (this._getFirstDayOfMonth(drawYear,
drawMonth) - firstDay + 7) % 7;
var curRows = [Link]((leadDays + daysInMonth) / 7); //
calculate the number of rows to generate
var numRows = (isMultiMonth ? [Link] > curRows ?
[Link] : curRows : curRows); //If multiple months, use the higher number of
rows (see #7043)
[Link] = numRows;
var printDate = this._daylightSavingAdjust(new
Date(drawYear, drawMonth, 1 - leadDays));
for (var dRow = 0; dRow < numRows; dRow++) { // create date
picker rows
calender += '<tr>';
var tbody = (!showWeek ? '' : '<td class="ui-
datepicker-week-col">' +
this._get(inst, 'calculateWeek')(printDate) +
'</td>');
for (var dow = 0; dow < 7; dow++) { // create date
picker days
var daySettings = (beforeShowDay ?
[Link](([Link] ?
[Link][0] : null), [printDate]) : [true, '']);
var otherMonth = ([Link]() !=
drawMonth);
var unselectable = (otherMonth && !
selectOtherMonths) || !daySettings[0] ||
(minDate && printDate < minDate) ||
(maxDate && printDate > maxDate);
tbody += '<td class="' +
((dow + firstDay + 6) % 7 >= 5 ? ' ui-
datepicker-week-end' : '') + // highlight weekends
(otherMonth ? ' ui-datepicker-other-
month' : '') + // highlight days from other months
(([Link]() ==
[Link]() && drawMonth == [Link] && inst._keyEvent) || //
user pressed key
([Link]() ==
[Link]() && [Link]() == [Link]()) ?
// or defaultDate is current printedDate
and defaultDate is selectedDate
' ' + this._dayOverClass : '') + //
highlight selected day
(unselectable ? ' ' +
this._unselectableClass + ' ui-state-disabled': '') + // highlight unselectable
days
(otherMonth && !showOtherMonths ? '' : '
' + daySettings[1] + // highlight custom dates
([Link]() ==
[Link]() ? ' ' + this._currentClass : '') + // highlight selected day
([Link]() == [Link]() ?
' ui-datepicker-today' : '')) + '"' + // highlight today (if different)
((!otherMonth || showOtherMonths) &&
daySettings[2] ? ' title="' + daySettings[2] + '"' : '') + // cell title
(unselectable ? '' : ' data-
handler="selectDay" data-event="click" data-month="' + [Link]() + '"
data-year="' + [Link]() + '"') + '>' + // actions
(otherMonth && !showOtherMonths ?
'&#xa0;' : // display for other months
(unselectable ? '<span class="ui-state-
default">' + [Link]() + '</span>' : '<a class="ui-state-default' +
([Link]() == [Link]() ?
' ui-state-highlight' : '') +
([Link]() ==
[Link]() ? ' ui-state-active' : '') + // highlight selected day
 (otherMonth ? ' ui-priority-secondary' :
'') + // distinguish dates from other months
'" href="#">' + [Link]() +
'</a>')) + '</td>'; // display selectable date
[Link]([Link]() + 1);
printDate =
this._daylightSavingAdjust(printDate);
}
calender += tbody + '</tr>';
}
drawMonth++;
if (drawMonth > 11) {
drawMonth = 0;
drawYear++;
}
calender += '</tbody></table>' + (isMultiMonth ? '</div>' +
((numMonths[0] > 0 && col ==
numMonths[1]-1) ? '<div class="ui-datepicker-row-break"></div>' : '') : '');
group += calender;
}
html += group;
}
html += buttonPanel + ($.[Link] && parseInt($.[Link],10)
< 7 && ![Link] ?
'<iframe src="javascript:false;" class="ui-datepicker-cover"
frameborder="0"></iframe>' : '');
inst._keyEvent = false;
return html;
},

/* Generate the month and year header. */

_generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate,
maxDate,
secondary, monthNames, monthNamesShort) {
var changeMonth = this._get(inst, 'changeMonth');
var changeYear = this._get(inst, 'changeYear');
var showMonthAfterYear = this._get(inst, 'showMonthAfterYear');
var html = '<div class="ui-datepicker-title">';
var monthHtml = '';
// month selection
if (secondary || !changeMonth)
monthHtml += '<span class="ui-datepicker-month">' +
monthNames[drawMonth] + '</span>';
else {
var inMinYear = (minDate && [Link]() == drawYear);
var inMaxYear = (maxDate && [Link]() == drawYear);
monthHtml += '<select class="ui-datepicker-month" data-
handler="selectMonth" data-event="change">';
for (var month = 0; month < 12; month++) {
if ((!inMinYear || month >= [Link]()) &&
(!inMaxYear || month <= [Link]()))
monthHtml += '<option value="' + month + '"' +
(month == drawMonth ? ' selected="selected"' :
'') +
'>' + monthNamesShort[month] + '</option>';
}
monthHtml += '</select>';
}
if (!showMonthAfterYear)
 html += monthHtml + (secondary || !(changeMonth && changeYear) ?
'&#xa0;' : '');
// year selection
if ( ![Link] ) {
[Link] = '';
if (secondary || !changeYear)
html += '<span class="ui-datepicker-year">' + drawYear +
'</span>';
else {
// determine range of years to display
var years = this._get(inst, 'yearRange').split(':');
var thisYear = new Date().getFullYear();
var determineYear = function(value) {
var year = ([Link](/c[+-].*/) ? drawYear +
parseInt([Link](1), 10) :
([Link](/[+-].*/) ? thisYear +
parseInt(value, 10) :
parseInt(value, 10)));
return (isNaN(year) ? thisYear : year);
};
var year = determineYear(years[0]);
var endYear = [Link](year, determineYear(years[1] ||
''));
year = (minDate ? [Link](year, [Link]()) :
year);
endYear = (maxDate ? [Link](endYear,
[Link]()) : endYear);
[Link] += '<select class="ui-datepicker-year" data-
handler="selectYear" data-event="change">';
for (; year <= endYear; year++) {
[Link] += '<option value="' + year + '"' +
(year == drawYear ? ' selected="selected"' :
'') +
'>' + year + '</option>';
}
[Link] += '</select>';

html += [Link];
[Link] = null;
}
}
html += this._get(inst, 'yearSuffix');
if (showMonthAfterYear)
html += (secondary || !(changeMonth && changeYear) ? '&#xa0;' :
'') + monthHtml;
html += '</div>'; // Close datepicker_header
return html;
},

/* Adjust one of the date sub-fields. */

_adjustInstDate: function(inst, offset, period) {
var year = [Link] + (period == 'Y' ? offset : 0);
var month = [Link] + (period == 'M' ? offset : 0);
var day = [Link]([Link], this._getDaysInMonth(year, month))
+
(period == 'D' ? offset : 0);
var date = this._restrictMinMax(inst,
this._daylightSavingAdjust(new Date(year, month, day)));
[Link] = [Link]();
 [Link] = [Link] = [Link]();
[Link] = [Link] = [Link]();
if (period == 'M' || period == 'Y')
this._notifyChange(inst);
},

/* Ensure a date is within any min/max bounds. */

_restrictMinMax: function(inst, date) {
var minDate = this._getMinMaxDate(inst, 'min');
var maxDate = this._getMinMaxDate(inst, 'max');
var newDate = (minDate && date < minDate ? minDate : date);
newDate = (maxDate && newDate > maxDate ? maxDate : newDate);
return newDate;
},

/* Notify change of month/year. */

_notifyChange: function(inst) {
var onChange = this._get(inst, 'onChangeMonthYear');
if (onChange)
[Link](([Link] ? [Link][0] : null),
[[Link], [Link] + 1, inst]);
},

/* Determine the number of months to show. */

_getNumberOfMonths: function(inst) {
var numMonths = this._get(inst, 'numberOfMonths');
return (numMonths == null ? [1, 1] : (typeof numMonths == 'number' ?
[1, numMonths] : numMonths));
},

/* Determine the current maximum date - ensure no time components are set. */
_getMinMaxDate: function(inst, minMax) {
return this._determineDate(inst, this._get(inst, minMax + 'Date'),
null);
},

/* Find the number of days in a given month. */

_getDaysInMonth: function(year, month) {
return 32 - this._daylightSavingAdjust(new Date(year, month,
32)).getDate();
},

/* Find the day of the week of the first of a month. */

_getFirstDayOfMonth: function(year, month) {
return new Date(year, month, 1).getDay();
},

/* Determines if we should allow a "next/prev" month display change. */

_canAdjustMonth: function(inst, offset, curYear, curMonth) {
var numMonths = this._getNumberOfMonths(inst);
var date = this._daylightSavingAdjust(new Date(curYear,
curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]),
1));
if (offset < 0)
[Link](this._getDaysInMonth([Link](),
[Link]()));
return this._isInRange(inst, date);
},
 /* Is the given date in the accepted range? */
_isInRange: function(inst, date) {
var minDate = this._getMinMaxDate(inst, 'min');
var maxDate = this._getMinMaxDate(inst, 'max');
return ((!minDate || [Link]() >= [Link]()) &&
(!maxDate || [Link]() <= [Link]()));
},

/* Provide the configuration settings for formatting/parsing. */

_getFormatConfig: function(inst) {
var shortYearCutoff = this._get(inst, 'shortYearCutoff');
shortYearCutoff = (typeof shortYearCutoff != 'string' ? shortYearCutoff
:
new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
return {shortYearCutoff: shortYearCutoff,
dayNamesShort: this._get(inst, 'dayNamesShort'), dayNames:
this._get(inst, 'dayNames'),
monthNamesShort: this._get(inst, 'monthNamesShort'), monthNames:
this._get(inst, 'monthNames')};
},

/* Format the given date for display. */

_formatDate: function(inst, day, month, year) {
if (!day) {
[Link] = [Link];
[Link] = [Link];
[Link] = [Link];
}
var date = (day ? (typeof day == 'object' ? day :
this._daylightSavingAdjust(new Date(year, month, day))) :
this._daylightSavingAdjust(new Date([Link],
[Link], [Link])));
return [Link](this._get(inst, 'dateFormat'), date,
this._getFormatConfig(inst));
}
});

/*
* Bind hover events for datepicker elements.
* Done via delegate so the binding only occurs once in the lifetime of the parent
div.
* Global instActive, set by _updateDatepicker allows the handlers to find their
way back to the active picker.
*/
function bindHover(dpDiv) {
var selector = 'button, .ui-datepicker-prev, .ui-datepicker-next, .ui-
datepicker-calendar td a';
return [Link]('mouseout', function(event) {
var elem = $( [Link] ).closest( selector );
if ( ![Link] ) {
return;
}
[Link]( "ui-state-hover ui-datepicker-prev-hover ui-
datepicker-next-hover" );
})
.bind('mouseover', function(event) {
var elem = $( [Link] ).closest( selector );
if ($.datepicker._isDisabledDatepicker( [Link] ?
[Link]()[0] : [Link][0]) ||
 ![Link] ) {
return;
}
[Link]('.ui-datepicker-
calendar').find('a').removeClass('ui-state-hover');
[Link]('ui-state-hover');
if ([Link]('ui-datepicker-prev')) [Link]('ui-
datepicker-prev-hover');
if ([Link]('ui-datepicker-next')) [Link]('ui-
datepicker-next-hover');
});
}

/* jQuery extend now ignores nulls! */

function extendRemove(target, props) {
$.extend(target, props);
for (var name in props)
if (props[name] == null || props[name] == undefined)
target[name] = props[name];
return target;
};

/* Determine whether an object is an array. */

function isArray(a) {
return (a && (($.[Link] && typeof a == 'object' && [Link]) ||
([Link] && [Link]().match(/\Array\(\)/))));
};

/* Invoke the datepicker functionality.

@param options string - a command, optionally followed by additional
parameters or
Object - settings for attaching new datepicker functionality
@return jQuery object */
$.[Link] = function(options){

/* Verify an empty collection wasn't passed - Fixes #6976 */

if ( ![Link] ) {
return this;
}

/* Initialise the date picker. */

if (!$.[Link]) {
$(document).mousedown($.datepicker._checkExternalClick).
find('body').append($.[Link]);
$.[Link] = true;
}

var otherArgs = [Link](arguments, 1);

if (typeof options == 'string' && (options == 'isDisabled' || options ==
'getDate' || options == 'widget'))
return $.datepicker['_' + options + 'Datepicker'].
apply($.datepicker, [this[0]].concat(otherArgs));
if (options == 'option' && [Link] == 2 && typeof arguments[1] ==
'string')
return $.datepicker['_' + options + 'Datepicker'].
apply($.datepicker, [this[0]].concat(otherArgs));
return [Link](function() {
typeof options == 'string' ?
$.datepicker['_' + options + 'Datepicker'].
 apply($.datepicker, [this].concat(otherArgs)) :
$.datepicker._attachDatepicker(this, options);
});
};

$.datepicker = new Datepicker(); // singleton instance

$.[Link] = false;
$.[Link] = new Date().getTime();
$.[Link] = "1.8.24";

// Workaround for #4055

// Add another global to avoid noConflict issues with inline event handlers
window['DP_jQuery_' + dpuuid] = $;

})(jQuery);

(function( $, undefined ) {

var uiDialogClasses =
'ui-dialog ' +
'ui-widget ' +
'ui-widget-content ' +
'ui-corner-all ',
sizeRelatedOptions = {
buttons: true,
height: true,
maxHeight: true,
maxWidth: true,
minHeight: true,
minWidth: true,
width: true
},
resizableRelatedOptions = {
maxHeight: true,
maxWidth: true,
minHeight: true,
minWidth: true
};

$.widget("[Link]", {
options: {
autoOpen: true,
buttons: {},
closeOnEscape: true,
closeText: 'close',
dialogClass: '',
draggable: true,
hide: null,
height: 'auto',
maxHeight: false,
maxWidth: false,
minHeight: 150,
minWidth: 150,
modal: false,
position: {
my: 'center',
at: 'center',
collision: 'fit',
// ensure that the titlebar is never outside the document
 using: function(pos) {
var topOffset = $(this).css(pos).offset().top;
if (topOffset < 0) {
$(this).css('top', [Link] - topOffset);
}
}
},
resizable: true,
show: null,
stack: true,
title: '',
width: 300,
zIndex: 1000
},

_create: function() {
[Link] = [Link]('title');
// #5742 - .attr() might return a DOMElement
if ( typeof [Link] !== "string" ) {
[Link] = "";
}

[Link] = [Link] || [Link];

var self = this,
options = [Link],

title = [Link] || '&#160;',

titleId = $.[Link]([Link]),

uiDialog = ([Link] = $('<div></div>'))

.appendTo([Link])
.hide()
.addClass(uiDialogClasses + [Link])
.css({
zIndex: [Link]
})
// setting tabIndex makes the div focusable
// setting outline to 0 prevents a border on focus in
Mozilla
.attr('tabIndex', -1).css('outline',
0).keydown(function(event) {
if ([Link] && !
[Link]() && [Link] &&
[Link] === $.[Link]) {

[Link](event);
[Link]();
}
})
.attr({
role: 'dialog',
'aria-labelledby': titleId
})
.mousedown(function(event) {
[Link](false, event);
}),

uiDialogContent = [Link]
.show()
 .removeAttr('title')
.addClass(
'ui-dialog-content ' +
'ui-widget-content')
.appendTo(uiDialog),

uiDialogTitlebar = ([Link] = $('<div></div>'))

.addClass(
'ui-dialog-titlebar ' +
'ui-widget-header ' +
'ui-corner-all ' +
'ui-helper-clearfix'
)
.prependTo(uiDialog),

uiDialogTitlebarClose = $('<a href="#"></a>')

.addClass(
'ui-dialog-titlebar-close ' +
'ui-corner-all'
)
.attr('role', 'button')
.hover(
function() {
[Link]('ui-state-
hover');
},
function() {
[Link]('ui-state-
hover');
}
)
.focus(function() {
[Link]('ui-state-focus');
})
.blur(function() {
[Link]('ui-state-focus');
})
.click(function(event) {
[Link](event);
return false;
})
.appendTo(uiDialogTitlebar),

uiDialogTitlebarCloseText = ([Link] = $
('<span></span>'))
.addClass(
'ui-icon ' +
'ui-icon-closethick'
)
.text([Link])
.appendTo(uiDialogTitlebarClose),

uiDialogTitle = $('<span></span>')
.addClass('ui-dialog-title')
.attr('id', titleId)
.html(title)
.prependTo(uiDialogTitlebar);

//handling of deprecated beforeclose (vs beforeClose) option

 //Ticket #4669 [Link]
//TODO: remove in 1.9pre
if ($.isFunction([Link]) && !
$.isFunction([Link])) {
[Link] = [Link];
}

[Link]("*").add(uiDialogTitlebar).disableSelection();

if ([Link] && $.[Link]) {

self._makeDraggable();
}
if ([Link] && $.[Link]) {
self._makeResizable();
}

self._createButtons([Link]);
self._isOpen = false;

if ($.[Link]) {
[Link]();
}
},

_init: function() {
if ( [Link] ) {
[Link]();
}
},

destroy: function() {
var self = this;

if ([Link]) {
[Link]();
}
[Link]();
[Link]
.unbind('.dialog')
.removeData('dialog')
.removeClass('ui-dialog-content ui-widget-content')
.hide().appendTo('body');
[Link]();

if ([Link]) {
[Link]('title', [Link]);
}

return self;
},

widget: function() {
return [Link];
},

close: function(event) {
var self = this,
maxZ, thisZ;
 if (false === self._trigger('beforeClose', event)) {
return;
}

if ([Link]) {
[Link]();
}
[Link]('[Link]-dialog');

self._isOpen = false;

if ([Link]) {
[Link]([Link], function() {
self._trigger('close', event);
});
} else {
[Link]();
self._trigger('close', event);
}

$.[Link]();

// adjust the maxZ to allow other modal dialogs to continue to work

(see #4309)
if ([Link]) {
maxZ = 0;
$('.ui-dialog').each(function() {
if (this !== [Link][0]) {
thisZ = $(this).css('z-index');
if(!isNaN(thisZ)) {
maxZ = [Link](maxZ, thisZ);
}
}
});
$.[Link] = maxZ;
}

return self;
},

isOpen: function() {
return this._isOpen;
},

// the force parameter allows us to move modal dialogs to their correct

// position on open
moveToTop: function(force, event) {
var self = this,
options = [Link],
saveScroll;

if (([Link] && !force) ||

(![Link] && ![Link])) {
return self._trigger('focus', event);
}

if ([Link] > $.[Link]) {

$.[Link] = [Link];
}
 if ([Link]) {
$.[Link] += 1;
[Link].$[Link]('z-index', $.[Link] =
$.[Link]);
}

//Save and then restore scroll since Opera 9.5+ resets when parent z-
Index is changed.
// [Link]
saveScroll = { scrollTop: [Link](), scrollLeft:
[Link]() };
$.[Link] += 1;
[Link]('z-index', $.[Link]);
[Link](saveScroll);
self._trigger('focus', event);

return self;
},

open: function() {
if (this._isOpen) { return; }

var self = this,

options = [Link],
uiDialog = [Link];

[Link] = [Link] ? new $.[Link](self) : null;

self._size();
self._position([Link]);
[Link]([Link]);
[Link](true);

// prevent tabbing out of modal dialogs

if ( [Link] ) {
[Link]( "[Link]-dialog", function( event ) {
if ( [Link] !== $.[Link] ) {
return;
}

var tabbables = $(':tabbable', this),

first = [Link](':first'),
last = [Link](':last');

if ([Link] === last[0] && ![Link]) {

[Link](1);
return false;
} else if ([Link] === first[0] && [Link]) {
[Link](1);
return false;
}
});
}

// set focus to the first tabbable element in the content area or the
first button
// if there are no tabbable elements, set focus on the dialog itself
$([Link](':tabbable').get().concat(
[Link]('.ui-dialog-buttonpane :tabbable').get().concat(
[Link]()))).eq(0).focus();
 self._isOpen = true;
self._trigger('open');

return self;
},

_createButtons: function(buttons) {
var self = this,
hasButtons = false,
uiDialogButtonPane = $('<div></div>')
.addClass(
'ui-dialog-buttonpane ' +
'ui-widget-content ' +
'ui-helper-clearfix'
),
uiButtonSet = $( "<div></div>" )
.addClass( "ui-dialog-buttonset" )
.appendTo( uiDialogButtonPane );

// if we already have a button pane, remove it

[Link]('.ui-dialog-buttonpane').remove();

if (typeof buttons === 'object' && buttons !== null) {

$.each(buttons, function() {
return !(hasButtons = true);
});
}
if (hasButtons) {
$.each(buttons, function(name, props) {
props = $.isFunction( props ) ?
{ click: props, text: name } :
props;
var button = $('<button type="button"></button>')
.click(function() {
[Link]([Link][0], arguments);
})
.appendTo(uiButtonSet);
// can't use .attr( props, true ) with jQuery 1.3.2.
$.each( props, function( key, value ) {
if ( key === "click" ) {
return;
}
if ( key in button ) {
button[ key ]( value );
} else {
[Link]( key, value );
}
});
if ($.[Link]) {
[Link]();
}
});
[Link]([Link]);
}
},

_makeDraggable: function() {
var self = this,
 options = [Link],
doc = $(document),
heightBeforeDrag;

function filteredUi(ui) {
return {
position: [Link],
offset: [Link]
};
}

[Link]({
cancel: '.ui-dialog-content, .ui-dialog-titlebar-close',
handle: '.ui-dialog-titlebar',
containment: 'document',
start: function(event, ui) {
heightBeforeDrag = [Link] === "auto" ? "auto" : $
(this).height();
$(this).height($(this).height()).addClass("ui-dialog-
dragging");
self._trigger('dragStart', event, filteredUi(ui));
},
drag: function(event, ui) {
self._trigger('drag', event, filteredUi(ui));
},
stop: function(event, ui) {
[Link] = [[Link] - [Link](),
[Link] - [Link]()];
$(this).removeClass("ui-dialog-
dragging").height(heightBeforeDrag);
self._trigger('dragStop', event, filteredUi(ui));
$.[Link]();
}
});
},

_makeResizable: function(handles) {
handles = (handles === undefined ? [Link] : handles);
var self = this,
options = [Link],
// .ui-resizable has position: relative defined in the stylesheet
// but dialogs have to use absolute or fixed positioning
position = [Link]('position'),
resizeHandles = (typeof handles === 'string' ?
handles :
'n,e,s,w,se,sw,ne,nw'
);

function filteredUi(ui) {
return {
originalPosition: [Link],
originalSize: [Link],
position: [Link],
size: [Link]
};
}

[Link]({
cancel: '.ui-dialog-content',
 containment: 'document',
alsoResize: [Link],
maxWidth: [Link],
maxHeight: [Link],
minWidth: [Link],
minHeight: self._minHeight(),
handles: resizeHandles,
start: function(event, ui) {
$(this).addClass("ui-dialog-resizing");
self._trigger('resizeStart', event, filteredUi(ui));
},
resize: function(event, ui) {
self._trigger('resize', event, filteredUi(ui));
},
stop: function(event, ui) {
$(this).removeClass("ui-dialog-resizing");
[Link] = $(this).height();
[Link] = $(this).width();
self._trigger('resizeStop', event, filteredUi(ui));
$.[Link]();
}
})
.css('position', position)
.find('.ui-resizable-se').addClass('ui-icon ui-icon-grip-diagonal-se');
},

_minHeight: function() {
var options = [Link];

if ([Link] === 'auto') {

return [Link];
} else {
return [Link]([Link], [Link]);
}
},

_position: function(position) {
var myAt = [],
offset = [0, 0],
isVisible;

if (position) {
// deep extending converts arrays to objects in jQuery <=
1.3.2 :-(
// if (typeof position == 'string' || $.isArray(position)) {
// myAt = $.isArray(position) ? position : [Link]('
');

if (typeof position === 'string' || (typeof position === 'object'

&& '0' in position)) {
myAt = [Link] ? [Link](' ') : [position[0],
position[1]];
if ([Link] === 1) {
myAt[1] = myAt[0];
}

$.each(['left', 'top'], function(i, offsetPosition) {

if (+myAt[i] === myAt[i]) {
offset[i] = myAt[i];
 myAt[i] = offsetPosition;
}
});

position = {
my: [Link](" "),
at: [Link](" "),
offset: [Link](" ")
};
}

position = $.extend({}, $.[Link],

position);
} else {
position = $.[Link];
}

// need to show the dialog to get the actual offset in the position
plugin
isVisible = [Link](':visible');
if (!isVisible) {
[Link]();
}
[Link]
// workaround for jQuery bug #5781
[Link]
.css({ top: 0, left: 0 })
.position($.extend({ of: window }, position));
if (!isVisible) {
[Link]();
}
},

_setOptions: function( options ) {

var self = this,
resizableOptions = {},
resize = false;

$.each( options, function( key, value ) {

self._setOption( key, value );

if ( key in sizeRelatedOptions ) {
resize = true;
}
if ( key in resizableRelatedOptions ) {
resizableOptions[ key ] = value;
}
});

if ( resize ) {
this._size();
}
if ( [Link]( ":data(resizable)" ) ) {
[Link]( "option", resizableOptions );
}
},

_setOption: function(key, value){

var self = this,
 uiDialog = [Link];

switch (key) {
//handling of deprecated beforeclose (vs beforeClose) option
//Ticket #4669 [Link]
//TODO: remove in 1.9pre
case "beforeclose":
key = "beforeClose";
break;
case "buttons":
self._createButtons(value);
break;
case "closeText":
// ensure that we always pass a string
[Link]("" + value);
break;
case "dialogClass":
uiDialog
.removeClass([Link])
.addClass(uiDialogClasses + value);
break;
case "disabled":
if (value) {
[Link]('ui-dialog-disabled');
} else {
[Link]('ui-dialog-disabled');
}
break;
case "draggable":
var isDraggable = [Link]( ":data(draggable)" );
if ( isDraggable && !value ) {
[Link]( "destroy" );
}

if ( !isDraggable && value ) {

self._makeDraggable();
}
break;
case "position":
self._position(value);
break;
case "resizable":
// currently resizable, becoming non-resizable
var isResizable = [Link]( ":data(resizable)" );
if (isResizable && !value) {
[Link]('destroy');
}

// currently resizable, changing handles

if (isResizable && typeof value === 'string') {
[Link]('option', 'handles', value);
}

// currently non-resizable, becoming resizable

if (!isResizable && value !== false) {
self._makeResizable(value);
}
break;
case "title":
 // convert whatever was passed in o a string, for html() to
not throw up
$(".ui-dialog-title", [Link]).html("" +
(value || '&#160;'));
break;
}

$.[Link]._setOption.apply(self, arguments);
},

_size: function() {
/* If the user has resized the dialog, the .ui-dialog and .ui-dialog-
content
* divs will both have width and height set, so we need to reset them
*/
var options = [Link],
nonContentHeight,
minContentHeight,
isVisible = [Link]( ":visible" );

// reset content sizing

[Link]().css({
width: 'auto',
minHeight: 0,
height: 0
});

if ([Link] > [Link]) {

[Link] = [Link];
}

// reset wrapper sizing

// determine the height of all the non-content elements
nonContentHeight = [Link]({
height: 'auto',
width: [Link]
})
.height();
minContentHeight = [Link]( 0, [Link] - nonContentHeight );

if ( [Link] === "auto" ) {

// only needed for IE6 support
if ( $.[Link] ) {
[Link]({
minHeight: minContentHeight,
height: "auto"
});
} else {
[Link]();
var autoHeight = [Link]( "height",
"auto" ).height();
if ( !isVisible ) {
[Link]();
}
[Link]( [Link]( autoHeight, minContentHeight
) );
}
} else {
[Link]( [Link]( [Link] - nonContentHeight,
0 ) );
}

if ([Link](':data(resizable)')) {
[Link]('option', 'minHeight',
this._minHeight());
}
}
});

$.extend($.[Link], {
version: "1.8.24",

uuid: 0,
maxZ: 0,

getTitleId: function($el) {
var id = $[Link]('id');
if (!id) {
[Link] += 1;
id = [Link];
}
return 'ui-dialog-title-' + id;
},

overlay: function(dialog) {
this.$el = $.[Link](dialog);
}
});

$.extend($.[Link], {
instances: [],
// reuse old instances due to IE memory leak with alpha transparency (see
#5185)
oldInstances: [],
maxZ: 0,
events: $.map('focus,mousedown,mouseup,keydown,keypress,click'.split(','),
function(event) { return event + '.dialog-overlay'; }).join(' '),
create: function(dialog) {
if ([Link] === 0) {
// prevent use of anchors and inputs
// we use a setTimeout in case the overlay is created from an
// event that we're going to be cancelling (see #2804)
setTimeout(function() {
// handle $(el).dialog().dialog('close') (see #4065)
if ($.[Link]) {
$(document).bind($.[Link],
function(event) {
// stop events if the z-index of the target is
< the z-index of the overlay
// we cannot return true when we don't want to
cancel the event (#3523)
if ($([Link]).zIndex() <
$.[Link]) {
return false;
}
});
}
}, 1);
 // allow closing by pressing the escape key
$(document).bind('[Link]-overlay', function(event) {
if ([Link] && !
[Link]() && [Link] &&
[Link] === $.[Link]) {

[Link](event);
[Link]();
}
});

// handle window resize

$(window).bind('[Link]-overlay',
$.[Link]);
}

var $el = ([Link]() || $('<div></div>').addClass('ui-

widget-overlay'))
.appendTo([Link])
.css({
width: [Link](),
height: [Link]()
});

if ($.[Link]) {
$[Link]();
}

[Link]($el);
return $el;
},

destroy: function($el) {
var indexOf = $.inArray($el, [Link]);
if (indexOf != -1){
[Link]([Link](indexOf, 1)[0]);
}

if ([Link] === 0) {
$([document, window]).unbind('.dialog-overlay');
}

$[Link]();

// adjust the maxZ to allow other modal dialogs to continue to work

(see #4309)
var maxZ = 0;
$.each([Link], function() {
maxZ = [Link](maxZ, [Link]('z-index'));
});
[Link] = maxZ;
},

height: function() {
var scrollHeight,
offsetHeight;
// handle IE 6
if ($.[Link] && $.[Link] < 7) {
 scrollHeight = [Link](
[Link],
[Link]
);
offsetHeight = [Link](
[Link],
[Link]
);

if (scrollHeight < offsetHeight) {

return $(window).height() + 'px';
} else {
return scrollHeight + 'px';
}
// handle "good" browsers
} else {
return $(document).height() + 'px';
}
},

width: function() {
var scrollWidth,
offsetWidth;
// handle IE
if ( $.[Link] ) {
scrollWidth = [Link](
[Link],
[Link]
);
offsetWidth = [Link](
[Link],
[Link]
);

if (scrollWidth < offsetWidth) {

return $(window).width() + 'px';
} else {
return scrollWidth + 'px';
}
// handle "good" browsers
} else {
return $(document).width() + 'px';
}
},

resize: function() {
/* If the dialog is draggable and the user drags it past the
* right edge of the window, the document becomes wider so we
* need to stretch the overlay. If the user then drags the
* dialog back to the left, the document will become narrower,
* so we need to shrink the overlay to the appropriate size.
* This is handled by shrinking the overlay before setting it
* to the full document size.
*/
var $overlays = $([]);
$.each($.[Link], function() {
$overlays = $[Link](this);
});
 $[Link]({
width: 0,
height: 0
}).css({
width: $.[Link](),
height: $.[Link]()
});
}
});

$.extend($.[Link], {
destroy: function() {
$.[Link](this.$el);
}
});

}(jQuery));

(function( $, undefined ) {

$.ui = $.ui || {};

var horizontalPositions = /left|center|right/,

verticalPositions = /top|center|bottom/,
center = "center",
support = {},
_position = $.[Link],
_offset = $.[Link];

$.[Link] = function( options ) {

if ( !options || ![Link] ) {
return _position.apply( this, arguments );
}

// make a copy, we don't want to modify arguments

options = $.extend( {}, options );

var target = $( [Link] ),

targetElem = target[0],
collision = ( [Link] || "flip" ).split( " " ),
offset = [Link] ? [Link]( " " ) : [ 0, 0 ],
targetWidth,
targetHeight,
basePosition;

if ( [Link] === 9 ) {
targetWidth = [Link]();
targetHeight = [Link]();
basePosition = { top: 0, left: 0 };
// TODO: use $.isWindow() in 1.9
} else if ( [Link] ) {
targetWidth = [Link]();
targetHeight = [Link]();
basePosition = { top: [Link](), left: [Link]() };
} else if ( [Link] ) {
// force left top to allow flipping
[Link] = "left top";
targetWidth = targetHeight = 0;
basePosition = { top: [Link], left: [Link] };
 } else {
targetWidth = [Link]();
targetHeight = [Link]();
basePosition = [Link]();
}

// force my and at to have valid horizontal and veritcal positions

// if a value is missing or invalid, it will be converted to center
$.each( [ "my", "at" ], function() {
var pos = ( options[this] || "" ).split( " " );
if ( [Link] === 1) {
pos = [Link]( pos[0] ) ?
[Link]( [center] ) :
[Link]( pos[0] ) ?
[ center ].concat( pos ) :
[ center, center ];
}
pos[ 0 ] = [Link]( pos[0] ) ? pos[ 0 ] : center;
pos[ 1 ] = [Link]( pos[1] ) ? pos[ 1 ] : center;
options[ this ] = pos;
});

// normalize collision option

if ( [Link] === 1 ) {
collision[ 1 ] = collision[ 0 ];
}

// normalize offset option

offset[ 0 ] = parseInt( offset[0], 10 ) || 0;
if ( [Link] === 1 ) {
offset[ 1 ] = offset[ 0 ];
}
offset[ 1 ] = parseInt( offset[1], 10 ) || 0;

if ( [Link][0] === "right" ) {

[Link] += targetWidth;
} else if ( [Link][0] === center ) {
[Link] += targetWidth / 2;
}

if ( [Link][1] === "bottom" ) {

[Link] += targetHeight;
} else if ( [Link][1] === center ) {
[Link] += targetHeight / 2;
}

[Link] += offset[ 0 ];
[Link] += offset[ 1 ];

return [Link](function() {
var elem = $( this ),
elemWidth = [Link](),
elemHeight = [Link](),
marginLeft = parseInt( $.curCSS( this, "marginLeft", true ) ) ||
0,
marginTop = parseInt( $.curCSS( this, "marginTop", true ) ) || 0,
collisionWidth = elemWidth + marginLeft +
( parseInt( $.curCSS( this, "marginRight", true ) ) || 0 ),
collisionHeight = elemHeight + marginTop +
 ( parseInt( $.curCSS( this, "marginBottom", true ) ) ||
0 ),
position = $.extend( {}, basePosition ),
collisionPosition;

if ( [Link][0] === "right" ) {

[Link] -= elemWidth;
} else if ( [Link][0] === center ) {
[Link] -= elemWidth / 2;
}

if ( [Link][1] === "bottom" ) {

[Link] -= elemHeight;
} else if ( [Link][1] === center ) {
[Link] -= elemHeight / 2;
}

// prevent fractions if jQuery version doesn't support them (see #5280)

if ( ![Link] ) {
[Link] = [Link]( [Link] );
[Link] = [Link]( [Link] );
}

collisionPosition = {
left: [Link] - marginLeft,
top: [Link] - marginTop
};

$.each( [ "left", "top" ], function( i, dir ) {

if ( $.[Link][ collision[i] ] ) {
$.[Link][ collision[i] ][ dir ]( position, {
targetWidth: targetWidth,
targetHeight: targetHeight,
elemWidth: elemWidth,
elemHeight: elemHeight,
collisionPosition: collisionPosition,
collisionWidth: collisionWidth,
collisionHeight: collisionHeight,
offset: offset,
my: [Link],
at: [Link]
});
}
});

if ( $.[Link] ) {
[Link]();
}
[Link]( $.extend( position, { using: [Link] } ) );
});
};

$.[Link] = {
fit: {
left: function( position, data ) {
var win = $( window ),
over = [Link] + [Link] -
[Link]() - [Link]();
[Link] = over > 0 ? [Link] - over :
[Link]( [Link] - [Link], [Link] );
},
top: function( position, data ) {
var win = $( window ),
over = [Link] + [Link] -
[Link]() - [Link]();
[Link] = over > 0 ? [Link] - over :
[Link]( [Link] - [Link], [Link] );
}
},

flip: {
left: function( position, data ) {
if ( [Link][0] === center ) {
return;
}
var win = $( window ),
over = [Link] + [Link] -
[Link]() - [Link](),
myOffset = [Link][ 0 ] === "left" ?
-[Link] :
[Link][ 0 ] === "right" ?
[Link] :
0,
atOffset = [Link][ 0 ] === "left" ?
[Link] :
-[Link],
offset = -2 * [Link][ 0 ];
[Link] += [Link] < 0 ?
myOffset + atOffset + offset :
over > 0 ?
myOffset + atOffset + offset :
0;
},
top: function( position, data ) {
if ( [Link][1] === center ) {
return;
}
var win = $( window ),
over = [Link] + [Link] -
[Link]() - [Link](),
myOffset = [Link][ 1 ] === "top" ?
-[Link] :
[Link][ 1 ] === "bottom" ?
[Link] :
0,
atOffset = [Link][ 1 ] === "top" ?
[Link] :
-[Link],
offset = -2 * [Link][ 1 ];
[Link] += [Link] < 0 ?
myOffset + atOffset + offset :
over > 0 ?
myOffset + atOffset + offset :
0;
}
}
};
// offset setter from jQuery 1.4
if ( !$.[Link] ) {
$.[Link] = function( elem, options ) {
// set position first, in-case top/left are set even on static elem
if ( /static/.test( $.curCSS( elem, "position" ) ) ) {
[Link] = "relative";
}
var curElem = $( elem ),
curOffset = [Link](),
curTop = parseInt( $.curCSS( elem, "top", true ), 10 ) || 0,
curLeft = parseInt( $.curCSS( elem, "left", true ), 10) || 0,
props = {
top: ([Link] - [Link]) + curTop,
left: ([Link] - [Link]) + curLeft
};

if ( 'using' in options ) {
[Link]( elem, props );
} else {
[Link]( props );
}
};

$.[Link] = function( options ) {

var elem = this[ 0 ];
if ( !elem || ![Link] ) { return null; }
if ( options ) {
if ( $.isFunction( options ) ) {
return [Link](function( i ) {
$( this ).offset( [Link]( this, i, $
( this ).offset() ) );
});
}
return [Link](function() {
$.[Link]( this, options );
});
}
return _offset.call( this );
};
}

// jQuery <1.4.3 uses curCSS, in 1.4.3 - 1.7.2 curCSS = css, 1.8+ only has css
if ( !$.curCSS ) {
$.curCSS = $.css;
}

// fraction support test (older versions of jQuery don't support fractions)

(function () {
var body = [Link]( "body" )[ 0 ],
div = [Link]( "div" ),
testElement, testElementParent, testElementStyle, offset, offsetTotal;

//Create a "fake body" for testing based on method used in [Link]

testElement = [Link]( body ? "div" : "body" );
testElementStyle = {
visibility: "hidden",
width: 0,
height: 0,
border: 0,
 margin: 0,
background: "none"
};
if ( body ) {
$.extend( testElementStyle, {
position: "absolute",
left: "-1000px",
top: "-1000px"
});
}
for ( var i in testElementStyle ) {
[Link][ i ] = testElementStyle[ i ];
}
[Link]( div );
testElementParent = body || [Link];
[Link]( testElement, [Link] );

[Link] = "position: absolute; left: 10.7432222px; top:

10.432325px; height: 30px; width: 201px;";

offset = $( div ).offset( function( _, offset ) {

return offset;
}).offset();

[Link] = "";
[Link]( testElement );

offsetTotal = [Link] + [Link] + ( body ? 2000 : 0 );

[Link] = offsetTotal > 21 && offsetTotal < 22;
})();

}( jQuery ));

(function( $, undefined ) {

$.widget( "[Link]", {
options: {
value: 0,
max: 100
},

min: 0,

_create: function() {
[Link]
.addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-
all" )
.attr({
role: "progressbar",
"aria-valuemin": [Link],
"aria-valuemax": [Link],
"aria-valuenow": this._value()
});

[Link] = $( "<div class='ui-progressbar-value ui-widget-header

ui-corner-left'></div>" )
.appendTo( [Link] );

[Link] = this._value();
 this._refreshValue();
},

destroy: function() {
[Link]
.removeClass( "ui-progressbar ui-widget ui-widget-content ui-
corner-all" )
.removeAttr( "role" )
.removeAttr( "aria-valuemin" )
.removeAttr( "aria-valuemax" )
.removeAttr( "aria-valuenow" );

[Link]();

$.[Link]( this, arguments );

},

value: function( newValue ) {

if ( newValue === undefined ) {
return this._value();
}

this._setOption( "value", newValue );

return this;
},

_setOption: function( key, value ) {

if ( key === "value" ) {
[Link] = value;
this._refreshValue();
if ( this._value() === [Link] ) {
this._trigger( "complete" );
}
}

$.[Link]._setOption.apply( this, arguments );

},

_value: function() {
var val = [Link];
// normalize invalid value
if ( typeof val !== "number" ) {
val = 0;
}
return [Link]( [Link], [Link]( [Link], val ) );
},

_percentage: function() {
return 100 * this._value() / [Link];
},

_refreshValue: function() {
var value = [Link]();
var percentage = this._percentage();

if ( [Link] !== value ) {

[Link] = value;
this._trigger( "change" );
}
 [Link]
.toggle( value > [Link] )
.toggleClass( "ui-corner-right", value === [Link] )
.width( [Link](0) + "%" );
[Link]( "aria-valuenow", value );
}
});

$.extend( $.[Link], {
version: "1.8.24"
});

})( jQuery );

(function( $, undefined ) {

// number of pages in a slider

// (how many times can you page up/down to go through the whole range)
var numPages = 5;

$.widget( "[Link]", $.[Link], {

widgetEventPrefix: "slide",

options: {
animate: false,
distance: 0,
max: 100,
min: 0,
orientation: "horizontal",
range: false,
step: 1,
value: 0,
values: null
},

_create: function() {
var self = this,
o = [Link],
existingHandles = [Link]( ".ui-slider-
handle" ).addClass( "ui-state-default ui-corner-all" ),
handle = "<a class='ui-slider-handle ui-state-default ui-corner-
all' href='#'></a>",
handleCount = ( [Link] && [Link] ) || 1,
handles = [];

this._keySliding = false;
this._mouseSliding = false;
this._animateOff = true;
this._handleIndex = null;
this._detectOrientation();
this._mouseInit();

[Link]
.addClass( "ui-slider" +
" ui-slider-" + [Link] +
" ui-widget" +
" ui-widget-content" +
 " ui-corner-all" +
( [Link] ? " ui-slider-disabled ui-disabled" : "" ) );

[Link] = $([]);

if ( [Link] ) {
if ( [Link] === true ) {
if ( ![Link] ) {
[Link] = [ this._valueMin(), this._valueMin() ];
}
if ( [Link] && [Link] !== 2 ) {
[Link] = [ [Link][0], [Link][0] ];
}
}

[Link] = $( "<div></div>" )
.appendTo( [Link] )
.addClass( "ui-slider-range" +
// note: this isn't the most fittingly semantic framework
class for this element,
// but worked best visually with a variety of themes
" ui-widget-header" +
( ( [Link] === "min" || [Link] === "max" ) ? " ui-slider-
range-" + [Link] : "" ) );
}

for ( var i = [Link]; i < handleCount; i += 1 ) {

[Link]( handle );
}

[Link] = [Link]( $
( [Link]( "" ) ).appendTo( [Link] ) );

[Link] = [Link]( 0 );

[Link]( [Link] ).filter( "a" )

.click(function( event ) {
[Link]();
})
.hover(function() {
if ( ![Link] ) {
$( this ).addClass( "ui-state-hover" );
}
}, function() {
$( this ).removeClass( "ui-state-hover" );
})
.focus(function() {
if ( ![Link] ) {
$( ".ui-slider .ui-state-focus" ).removeClass( "ui-
state-focus" );
$( this ).addClass( "ui-state-focus" );
} else {
$( this ).blur();
}
})
.blur(function() {
$( this ).removeClass( "ui-state-focus" );
});
 [Link](function( i ) {
$( this ).data( "[Link]-slider-handle", i );
});

[Link]
.keydown(function( event ) {
var index = $( this ).data( "[Link]-slider-handle" ),
allowed,
curVal,
newVal,
step;

if ( [Link] ) {
return;
}

switch ( [Link] ) {
case $.[Link]:
case $.[Link]:
case $.[Link].PAGE_UP:
case $.[Link].PAGE_DOWN:
case $.[Link]:
case $.[Link]:
case $.[Link]:
case $.[Link]:
[Link]();
if ( !self._keySliding ) {
self._keySliding = true;
$( this ).addClass( "ui-state-active" );
allowed = self._start( event, index );
if ( allowed === false ) {
return;
}
}
break;
}

step = [Link];
if ( [Link] && [Link] ) {
curVal = newVal = [Link]( index );
} else {
curVal = newVal = [Link]();
}

switch ( [Link] ) {
case $.[Link]:
newVal = self._valueMin();
break;
case $.[Link]:
newVal = self._valueMax();
break;
case $.[Link].PAGE_UP:
newVal = self._trimAlignValue( curVal +
( (self._valueMax() - self._valueMin()) / numPages ) );
break;
case $.[Link].PAGE_DOWN:
newVal = self._trimAlignValue( curVal -
( (self._valueMax() - self._valueMin()) / numPages ) );
break;
 case $.[Link]:
case $.[Link]:
if ( curVal === self._valueMax() ) {
return;
}
newVal = self._trimAlignValue( curVal + step );
break;
case $.[Link]:
case $.[Link]:
if ( curVal === self._valueMin() ) {
return;
}
newVal = self._trimAlignValue( curVal - step );
break;
}

self._slide( event, index, newVal );

})
.keyup(function( event ) {
var index = $( this ).data( "[Link]-slider-handle" );

if ( self._keySliding ) {
self._keySliding = false;
self._stop( event, index );
self._change( event, index );
$( this ).removeClass( "ui-state-active" );
}

});

this._refreshValue();

this._animateOff = false;
},

destroy: function() {
[Link]();
[Link]();

[Link]
.removeClass( "ui-slider" +
" ui-slider-horizontal" +
" ui-slider-vertical" +
" ui-slider-disabled" +
" ui-widget" +
" ui-widget-content" +
" ui-corner-all" )
.removeData( "slider" )
.unbind( ".slider" );

this._mouseDestroy();

return this;
},

_mouseCapture: function( event ) {

var o = [Link],
position,
normValue,
 distance,
closestHandle,
self,
index,
allowed,
offset,
mouseOverHandle;

if ( [Link] ) {
return false;
}

[Link] = {
width: [Link](),
height: [Link]()
};
[Link] = [Link]();

position = { x: [Link], y: [Link] };

normValue = this._normValueFromMouse( position );
distance = this._valueMax() - this._valueMin() + 1;
self = this;
[Link](function( i ) {
var thisDistance = [Link]( normValue - [Link](i) );
if ( distance > thisDistance ) {
distance = thisDistance;
closestHandle = $( this );
index = i;
}
});

// workaround for bug #3736 (if both handles of a range are at 0,

// the first is always used as the one with least distance,
// and moving it is obviously prevented by preventing negative ranges)
if( [Link] === true && [Link](1) === [Link] ) {
index += 1;
closestHandle = $( [Link][index] );
}

allowed = this._start( event, index );

if ( allowed === false ) {
return false;
}
this._mouseSliding = true;

self._handleIndex = index;

closestHandle
.addClass( "ui-state-active" )
.focus();

offset = [Link]();
mouseOverHandle = !$( [Link] ).parents().andSelf().is( ".ui-
slider-handle" );
this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
left: [Link] - [Link] - ( [Link]() / 2 ),
top: [Link] - [Link] -
( [Link]() / 2 ) -
( parseInt( [Link]("borderTopWidth"), 10 ) ||
0 ) -
( parseInt( [Link]("borderBottomWidth"), 10 ) ||
0) +
( parseInt( [Link]("marginTop"), 10 ) || 0)
};

if ( ![Link]( "ui-state-hover" ) ) {
this._slide( event, index, normValue );
}
this._animateOff = true;
return true;
},

_mouseStart: function( event ) {

return true;
},

_mouseDrag: function( event ) {

var position = { x: [Link], y: [Link] },
normValue = this._normValueFromMouse( position );

this._slide( event, this._handleIndex, normValue );

return false;
},

_mouseStop: function( event ) {

[Link]( "ui-state-active" );
this._mouseSliding = false;

this._stop( event, this._handleIndex );

this._change( event, this._handleIndex );

this._handleIndex = null;
this._clickOffset = null;
this._animateOff = false;

return false;
},

_detectOrientation: function() {
[Link] = ( [Link] === "vertical" ) ?
"vertical" : "horizontal";
},

_normValueFromMouse: function( position ) {

var pixelTotal,
pixelMouse,
percentMouse,
valueTotal,
valueMouse;

if ( [Link] === "horizontal" ) {

pixelTotal = [Link];
pixelMouse = position.x - [Link] -
( this._clickOffset ? this._clickOffset.left : 0 );
} else {
pixelTotal = [Link];
pixelMouse = position.y - [Link] -
( this._clickOffset ? this._clickOffset.top : 0 );
}

percentMouse = ( pixelMouse / pixelTotal );

if ( percentMouse > 1 ) {
percentMouse = 1;
}
if ( percentMouse < 0 ) {
percentMouse = 0;
}
if ( [Link] === "vertical" ) {
percentMouse = 1 - percentMouse;
}

valueTotal = this._valueMax() - this._valueMin();

valueMouse = this._valueMin() + percentMouse * valueTotal;

return this._trimAlignValue( valueMouse );

},

_start: function( event, index ) {

var uiHash = {
handle: [Link][ index ],
value: [Link]()
};
if ( [Link] && [Link] ) {
[Link] = [Link]( index );
[Link] = [Link]();
}
return this._trigger( "start", event, uiHash );
},

_slide: function( event, index, newVal ) {

var otherVal,
newValues,
allowed;

if ( [Link] && [Link] ) {

otherVal = [Link]( index ? 0 : 1 );

if ( ( [Link] === 2 && [Link] ===

true ) &&
( ( index === 0 && newVal > otherVal) || ( index ===
1 && newVal < otherVal ) )
) {
newVal = otherVal;
}

if ( newVal !== [Link]( index ) ) {

newValues = [Link]();
newValues[ index ] = newVal;
// A slide can be canceled by returning false from the
slide callback
allowed = this._trigger( "slide", event, {
handle: [Link][ index ],
value: newVal,
values: newValues
} );
otherVal = [Link]( index ? 0 : 1 );
 if ( allowed !== false ) {
[Link]( index, newVal, true );
}
}
} else {
if ( newVal !== [Link]() ) {
// A slide can be canceled by returning false from the
slide callback
allowed = this._trigger( "slide", event, {
handle: [Link][ index ],
value: newVal
} );
if ( allowed !== false ) {
[Link]( newVal );
}
}
}
},

_stop: function( event, index ) {

var uiHash = {
handle: [Link][ index ],
value: [Link]()
};
if ( [Link] && [Link] ) {
[Link] = [Link]( index );
[Link] = [Link]();
}

this._trigger( "stop", event, uiHash );

},

_change: function( event, index ) {

if ( !this._keySliding && !this._mouseSliding ) {
var uiHash = {
handle: [Link][ index ],
value: [Link]()
};
if ( [Link] && [Link] ) {
[Link] = [Link]( index );
[Link] = [Link]();
}

this._trigger( "change", event, uiHash );

}
},

value: function( newValue ) {

if ( [Link] ) {
[Link] = this._trimAlignValue( newValue );
this._refreshValue();
this._change( null, 0 );
return;
}

return this._value();
},

values: function( index, newValue ) {

 var vals,
newValues,
i;

if ( [Link] > 1 ) {
[Link][ index ] = this._trimAlignValue( newValue );
this._refreshValue();
this._change( null, index );
return;
}

if ( [Link] ) {
if ( $.isArray( arguments[ 0 ] ) ) {
vals = [Link];
newValues = arguments[ 0 ];
for ( i = 0; i < [Link]; i += 1 ) {
vals[ i ] = this._trimAlignValue( newValues[ i ] );
this._change( null, i );
}
this._refreshValue();
} else {
if ( [Link] && [Link] ) {
return this._values( index );
} else {
return [Link]();
}
}
} else {
return this._values();
}
},

_setOption: function( key, value ) {

var i,
valsLength = 0;

if ( $.isArray( [Link] ) ) {
valsLength = [Link];
}

$.[Link]._setOption.apply( this, arguments );

switch ( key ) {
case "disabled":
if ( value ) {
[Link]( ".ui-state-focus" ).blur();
[Link]( "ui-state-hover" );
[Link]( "disabled", true );
[Link]( "ui-disabled" );
} else {
[Link]( "disabled", false );
[Link]( "ui-disabled" );
}
break;
case "orientation":
this._detectOrientation();
[Link]
.removeClass( "ui-slider-horizontal ui-slider-
vertical" )
 .addClass( "ui-slider-" + [Link] );
this._refreshValue();
break;
case "value":
this._animateOff = true;
this._refreshValue();
this._change( null, 0 );
this._animateOff = false;
break;
case "values":
this._animateOff = true;
this._refreshValue();
for ( i = 0; i < valsLength; i += 1 ) {
this._change( null, i );
}
this._animateOff = false;
break;
}
},

//internal value getter

// _value() returns value trimmed by min and max, aligned by step
_value: function() {
var val = [Link];
val = this._trimAlignValue( val );

return val;
},

//internal values getter

// _values() returns array of values trimmed by min and max, aligned by step
// _values( index ) returns single value trimmed by min and max, aligned by
step
_values: function( index ) {
var val,
vals,
i;

if ( [Link] ) {
val = [Link][ index ];
val = this._trimAlignValue( val );

return val;
} else {
// .slice() creates a copy of the array
// this copy gets trimmed by min and max and then returned
vals = [Link]();
for ( i = 0; i < [Link]; i+= 1) {
vals[ i ] = this._trimAlignValue( vals[ i ] );
}

return vals;
}
},

// returns the step-aligned value that val is closest to, between (inclusive)
min and max
_trimAlignValue: function( val ) {
if ( val <= this._valueMin() ) {
 return this._valueMin();
}
if ( val >= this._valueMax() ) {
return this._valueMax();
}
var step = ( [Link] > 0 ) ? [Link] : 1,
valModStep = (val - this._valueMin()) % step,
alignValue = val - valModStep;

if ( [Link](valModStep) * 2 >= step ) {

alignValue += ( valModStep > 0 ) ? step : ( -step );
}

// Since JavaScript has problems with large floats, round

// the final value to 5 digits after the decimal point (see #4124)
return parseFloat( [Link](5) );
},

_valueMin: function() {
return [Link];
},

_valueMax: function() {
return [Link];
},

_refreshValue: function() {
var oRange = [Link],
o = [Link],
self = this,
animate = ( !this._animateOff ) ? [Link] : false,
valPercent,
_set = {},
lastValPercent,
value,
valueMin,
valueMax;

if ( [Link] && [Link] ) {

[Link](function( i, j ) {
valPercent = ( [Link](i) - self._valueMin() ) /
( self._valueMax() - self._valueMin() ) * 100;
_set[ [Link] === "horizontal" ? "left" : "bottom"
] = valPercent + "%";
$( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]
( _set, [Link] );
if ( [Link] === true ) {
if ( [Link] === "horizontal" ) {
if ( i === 0 ) {
[Link]( 1, 1 )[ animate ?
"animate" : "css" ]( { left: valPercent + "%" }, [Link] );
}
if ( i === 1 ) {
[Link][ animate ? "animate" : "css" ]
( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration:
[Link] } );
}
} else {
if ( i === 0 ) {
 [Link]( 1, 1 )[ animate ?
"animate" : "css" ]( { bottom: ( valPercent ) + "%" }, [Link] );
}
if ( i === 1 ) {
[Link][ animate ? "animate" : "css" ]
( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration:
[Link] } );
}
}
}
lastValPercent = valPercent;
});
} else {
value = [Link]();
valueMin = this._valueMin();
valueMax = this._valueMax();
valPercent = ( valueMax !== valueMin ) ?
( value - valueMin ) / ( valueMax - valueMin ) *
100 :
0;
_set[ [Link] === "horizontal" ? "left" : "bottom" ] =
valPercent + "%";
[Link]( 1, 1 )[ animate ? "animate" : "css" ]( _set,
[Link] );

if ( oRange === "min" && [Link] === "horizontal" ) {

[Link]( 1, 1 )[ animate ? "animate" : "css" ]
( { width: valPercent + "%" }, [Link] );
}
if ( oRange === "max" && [Link] === "horizontal" ) {
[Link][ animate ? "animate" : "css" ]( { width: ( 100 -
valPercent ) + "%" }, { queue: false, duration: [Link] } );
}
if ( oRange === "min" && [Link] === "vertical" ) {
[Link]( 1, 1 )[ animate ? "animate" : "css" ]
( { height: valPercent + "%" }, [Link] );
}
if ( oRange === "max" && [Link] === "vertical" ) {
[Link][ animate ? "animate" : "css" ]( { height: ( 100
- valPercent ) + "%" }, { queue: false, duration: [Link] } );
}
}
}

});

$.extend( $.[Link], {
version: "1.8.24"
});

}(jQuery));

(function( $, undefined ) {

var tabId = 0,
listId = 0;

function getNextTabId() {
return ++tabId;
}

function getNextListId() {
return ++listId;
}

$.widget( "[Link]", {
options: {
add: null,
ajaxOptions: null,
cache: false,
cookie: null, // e.g. { expires: 7, path: '/', domain: '[Link]',
secure: true }
collapsible: false,
disable: null,
disabled: [],
enable: null,
event: "click",
fx: null, // e.g. { height: 'toggle', opacity: 'toggle', duration:
200 }
idPrefix: "ui-tabs-",
load: null,
panelTemplate: "<div></div>",
remove: null,
select: null,
show: null,
spinner: "<em>Loading&#8230;</em>",
tabTemplate: "<li><a href='#{href}'><span>#{label}</span></a></li>"
},

_create: function() {
this._tabify( true );
},

_setOption: function( key, value ) {

if ( key == "selected" ) {
if ([Link] && value == [Link] )
{
return;
}
[Link]( value );
} else {
[Link][ key ] = value;
this._tabify();
}
},

_tabId: function( a ) {
return [Link] && [Link]( /\s/g, "_" ).replace( /[^\w\u00c0-\
uFFFF-]/g, "" ) ||
[Link] + getNextTabId();
},

_sanitizeSelector: function( hash ) {

// we need this because an id may contain a ":"
return [Link]( /:/g, "\\:" );
},

_cookie: function() {
 var cookie = [Link] ||
( [Link] = [Link] || "ui-tabs-" +
getNextListId() );
return $.[Link]( null,
[ cookie ].concat( $.makeArray( arguments ) ) );
},

_ui: function( tab, panel ) {

return {
tab: tab,
panel: panel,
index: [Link]( tab )
};
},

_cleanup: function() {
// restore all former loading tabs labels
[Link]( ".ui-state-processing" )
.removeClass( "ui-state-processing" )
.find( "span:data([Link])" )
.each(function() {
var el = $( this );

[Link]( [Link]( "[Link]" ) ).removeData( "[Link]" );

});
},

_tabify: function( init ) {

var self = this,
o = [Link],
fragmentId = /^#.+/; // Safari 2 reports '#' for an empty hash

[Link] = [Link]( "ol,ul" ).eq( 0 );

[Link] = $( " > li:has(a[href])", [Link] );
[Link] = [Link](function() {
return $( "a", this )[ 0 ];
});
[Link] = $( [] );

[Link](function( i, a ) {
var href = $( a ).attr( "href" );
// For dynamically created HTML that contains a hash as href IE <
8 expands
// such href to the full page url with hash and then
misinterprets tab as ajax.
// Same consideration applies for an added tab with a fragment
identifier
// since a[href=#fragment-identifier] does unexpectedly not
match.
// Thus normalize href attribute...
var hrefBase = [Link]( "#" )[ 0 ],
baseEl;
if ( hrefBase && ( hrefBase === [Link]().split( "#" )[
0 ] ||
( baseEl = $( "base" )[ 0 ]) && hrefBase ===
[Link] ) ) {
href = [Link];
[Link] = href;
}
 // inline tab
if ( [Link]( href ) ) {
[Link] =
[Link]( [Link]( self._sanitizeSelector( href ) ) );
// remote tab
// prevent loading the page itself if href is just "#"
} else if ( href && href !== "#" ) {
// required for restore on destroy
$.data( a, "[Link]", href );

// TODO until #3808 is fixed strip fragment identifier from

url
// (IE fails to load from such url)
$.data( a, "[Link]", [Link]( /#.*$/, "" ) );

var id = self._tabId( a );
[Link] = "#" + id;
var $panel = [Link]( "#" + id );
if ( !$[Link] ) {
$panel = $( [Link] )
.attr( "id", id )
.addClass( "ui-tabs-panel ui-widget-content ui-
corner-bottom" )
.insertAfter( [Link][ i - 1 ] || [Link]
);
$[Link]( "[Link]", true );
}
[Link] = [Link]( $panel );
// invalid tab href
} else {
[Link]( i );
}
});

// initialization from scratch

if ( init ) {
// attach necessary classes for styling
[Link]( "ui-tabs ui-widget ui-widget-content ui-
corner-all" );
[Link]( "ui-tabs-nav ui-helper-reset ui-helper-
clearfix ui-widget-header ui-corner-all" );
[Link]( "ui-state-default ui-corner-top" );
[Link]( "ui-tabs-panel ui-widget-content ui-corner-
bottom" );

// Selected tab
// use "selected" option or try to retrieve:
// 1. from fragment identifier in url
// 2. from cookie
// 3. from selected class attribute on <li>
if ( [Link] === undefined ) {
if ( [Link] ) {
[Link](function( i, a ) {
if ( [Link] == [Link] ) {
[Link] = i;
return false;
}
});
 }
if ( typeof [Link] !== "number" && [Link] ) {
[Link] = parseInt( self._cookie(), 10 );
}
if ( typeof [Link] !== "number" &&
[Link]( ".ui-tabs-selected" ).length ) {
[Link] = [Link]( [Link]( ".ui-
tabs-selected" ) );
}
[Link] = [Link] || ( [Link] ? 0 : -1 );
} else if ( [Link] === null ) { // usage of null is
deprecated, TODO remove in next release
[Link] = -1;
}

// sanity check - default to first tab...

[Link] = ( ( [Link] >= 0 && [Link][ [Link] ] )
|| [Link] < 0 )
? [Link]
: 0;

// Take disabling tabs via class attribute from HTML

// into account and update option properly.
// A selected tab cannot become disabled.
[Link] = $.unique( [Link](
$.map( [Link]( ".ui-state-disabled" ),
function( n, i ) {
return [Link]( n );
})
) ).sort();

if ( $.inArray( [Link], [Link] ) != -1 ) {

[Link]( $.inArray( [Link], [Link] ),
1 );
}

// highlight selected tab

[Link]( "ui-tabs-hide" );
[Link]( "ui-tabs-selected ui-state-active" );
// check for length avoids error when initializing empty list
if ( [Link] >= 0 && [Link] ) {

[Link]( self._sanitizeSelector( [Link][ [Link] ].hash ) ).remo

veClass( "ui-tabs-hide" );
[Link]( [Link] ).addClass( "ui-tabs-selected ui-
state-active" );

// seems to be expected behavior that the show callback is

fired
[Link]( "tabs", function() {
self._trigger( "show", null,
self._ui( [Link][ [Link] ],
[Link]( self._sanitizeSelector( [Link][ [Link] ].hash ) )[ 0 ]
) );
});

[Link]( [Link] );
}
 // clean up to avoid memory leaks in certain versions of IE 6
// TODO: namespace this event
$( window ).bind( "unload", function() {
[Link]( [Link] ).unbind( ".tabs" );
[Link] = [Link] = [Link] = null;
});
// update selected after add/remove
} else {
[Link] = [Link]( [Link]( ".ui-tabs-selected"
) );
}

// update collapsible
// TODO: use .toggleClass()
[Link][ [Link] ? "addClass" : "removeClass" ]( "ui-tabs-
collapsible" );

// set or update cookie after init and add/remove respectively

if ( [Link] ) {
this._cookie( [Link], [Link] );
}

// disable tabs
for ( var i = 0, li; ( li = [Link][ i ] ); i++ ) {
$( li )[ $.inArray( i, [Link] ) != -1 &&
// TODO: use .toggleClass()
!$( li ).hasClass( "ui-tabs-selected" ) ? "addClass" :
"removeClass" ]( "ui-state-disabled" );
}

// reset cache if switching from cached to not cached

if ( [Link] === false ) {
[Link]( "[Link]" );
}

// remove all handlers before, tabify may run on existing tabs after
add or option change
[Link]( [Link] ).unbind( ".tabs" );

if ( [Link] !== "mouseover" ) {

var addState = function( state, el ) {
if ( [Link]( ":not(.ui-state-disabled)" ) ) {
[Link]( "ui-state-" + state );
}
};
var removeState = function( state, el ) {
[Link]( "ui-state-" + state );
};
[Link]( "[Link]" , function() {
addState( "hover", $( this ) );
});
[Link]( "[Link]", function() {
removeState( "hover", $( this ) );
});
[Link]( "[Link]", function() {
addState( "focus", $( this ).closest( "li" ) );
});
[Link]( "[Link]", function() {
 removeState( "focus", $( this ).closest( "li" ) );
});
}

// set up animations
var hideFx, showFx;
if ( [Link] ) {
if ( $.isArray( [Link] ) ) {
hideFx = [Link][ 0 ];
showFx = [Link][ 1 ];
} else {
hideFx = showFx = [Link];
}
}

// Reset certain styles left over from animation

// and prevent IE's ClearType bug...
function resetStyle( $el, fx ) {
$[Link]( "display", "" );
if ( !$.[Link] && [Link] ) {
$el[ 0 ].[Link]( "filter" );
}
}

// Show a tab...
var showTab = showFx
? function( clicked, $show ) {
$( clicked ).closest( "li" ).addClass( "ui-tabs-selected
ui-state-active" );
$[Link]().removeClass( "ui-tabs-hide" ) // avoid flicker
that way
.animate( showFx, [Link] || "normal",
function() {
resetStyle( $show, showFx );
self._trigger( "show", null, self._ui( clicked,
$show[ 0 ] ) );
});
}
: function( clicked, $show ) {
$( clicked ).closest( "li" ).addClass( "ui-tabs-selected
ui-state-active" );
$[Link]( "ui-tabs-hide" );
self._trigger( "show", null, self._ui( clicked,
$show[ 0 ] ) );
};

// Hide a tab, $show is optional...

var hideTab = hideFx
? function( clicked, $hide ) {
$[Link]( hideFx, [Link] || "normal",
function() {
[Link]( "ui-tabs-selected ui-state-
active" );
$[Link]( "ui-tabs-hide" );
resetStyle( $hide, hideFx );
[Link]( "tabs" );
});
}
: function( clicked, $hide, $show ) {
 [Link]( "ui-tabs-selected ui-state-active" );
$[Link]( "ui-tabs-hide" );
[Link]( "tabs" );
};

// attach tab event handler, unbind to avoid duplicates from former

tabifying...
[Link]( [Link] + ".tabs", function() {
var el = this,
$li = $(el).closest( "li" ),
$hide = [Link]( ":not(.ui-tabs-hide)" ),
$show =
[Link]( self._sanitizeSelector( [Link] ) );

// If tab is already selected and not collapsible or tab disabled

or
// or is already loading or click callback returns false stop
here.
// Check if click handler returns false last so that it is not
executed
// for a disabled or loading tab!
if ( ( $[Link]( "ui-tabs-selected" ) && ![Link]) ||
$[Link]( "ui-state-disabled" ) ||
$[Link]( "ui-state-processing" ) ||
[Link]( ":animated" ).length ||
self._trigger( "select", null, self._ui( this, $show[ 0 ] )
) === false ) {
[Link]();
return false;
}

[Link] = [Link]( this );

[Link]();

// if tab may be closed

if ( [Link] ) {
if ( $[Link]( "ui-tabs-selected" ) ) {
[Link] = -1;

if ( [Link] ) {
self._cookie( [Link], [Link] );
}

[Link]( "tabs", function() {

hideTab( el, $hide );
}).dequeue( "tabs" );

[Link]();
return false;
} else if ( !$[Link] ) {
if ( [Link] ) {
self._cookie( [Link], [Link] );
}

[Link]( "tabs", function() {

showTab( el, $show );
});
 // TODO make passing in node possible, see also
[Link]
[Link]( [Link]( this ) );

[Link]();
return false;
}
}

if ( [Link] ) {
self._cookie( [Link], [Link] );
}

// show new tab

if ( $[Link] ) {
if ( $[Link] ) {
[Link]( "tabs", function() {
hideTab( el, $hide );
});
}
[Link]( "tabs", function() {
showTab( el, $show );
});

[Link]( [Link]( this ) );

} else {
throw "jQuery UI Tabs: Mismatching fragment identifier.";
}

// Prevent IE from keeping other link focussed when using the

back button
// and remove dotted border from clicked link. This is controlled
via CSS
// in modern browsers; blur() removes focus from address bar in
Firefox
// which can become a usability and annoying problem with
tabs('rotate').
if ( $.[Link] ) {
[Link]();
}
});

// disable click in any case

[Link]( "[Link]", function(){
return false;
});
},

_getIndex: function( index ) {

// meta-function to give users option to provide a href string instead
of a numerical index.
// also sanitizes numerical indexes to valid values.
if ( typeof index == "string" ) {
index = [Link]( [Link]( "[href$='" +
index + "']" ) );
}

return index;
},
 destroy: function() {
var o = [Link];

[Link]();

[Link]
.unbind( ".tabs" )
.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all
ui-tabs-collapsible" )
.removeData( "tabs" );

[Link]( "ui-tabs-nav ui-helper-reset ui-helper-clearfix

ui-widget-header ui-corner-all" );

[Link](function() {
var href = $.data( this, "[Link]" );
if ( href ) {
[Link] = href;
}
var $this = $( this ).unbind( ".tabs" );
$.each( [ "href", "load", "cache" ], function( i, prefix ) {
$[Link]( prefix + ".tabs" );
});
});

[Link]( ".tabs" ).add( [Link] ).each(function() {

if ( $.data( this, "[Link]" ) ) {
$( this ).remove();
} else {
$( this ).removeClass([
"ui-state-default",
"ui-corner-top",
"ui-tabs-selected",
"ui-state-active",
"ui-state-hover",
"ui-state-focus",
"ui-state-disabled",
"ui-tabs-panel",
"ui-widget-content",
"ui-corner-bottom",
"ui-tabs-hide"
].join( " " ) );
}
});

if ( [Link] ) {
this._cookie( null, [Link] );
}

return this;
},

add: function( url, label, index ) {

if ( index === undefined ) {
index = [Link];
}

var self = this,

 o = [Link],
$li = $( [Link]( /#\{href\}/g, url ).replace( /#\
{label\}/g, label ) ),
id = ![Link]( "#" ) ? [Link]( "#", "" ) :
this._tabId( $( "a", $li )[ 0 ] );

$[Link]( "ui-state-default ui-corner-top" ).data( "[Link]",

true );

// try to find an existing element before creating a new one

var $panel = [Link]( "#" + id );
if ( !$[Link] ) {
$panel = $( [Link] )
.attr( "id", id )
.data( "[Link]", true );
}
$[Link]( "ui-tabs-panel ui-widget-content ui-corner-bottom ui-
tabs-hide" );

if ( index >= [Link] ) {

$[Link]( [Link] );
$[Link]( [Link][ 0 ].parentNode );
} else {
$[Link]( [Link][ index ] );
$[Link]( [Link][ index ] );
}

[Link] = $.map( [Link], function( n, i ) {

return n >= index ? ++n : n;
});

this._tabify();

if ( [Link] == 1 ) {
[Link] = 0;
$[Link]( "ui-tabs-selected ui-state-active" );
$[Link]( "ui-tabs-hide" );
[Link]( "tabs", function() {
self._trigger( "show", null, self._ui( [Link][ 0 ],
[Link][ 0 ] ) );
});

[Link]( 0 );
}

this._trigger( "add", null, this._ui( [Link][ index ],

[Link][ index ] ) );
return this;
},

remove: function( index ) {

index = this._getIndex( index );
var o = [Link],
$li = [Link]( index ).remove(),
$panel = [Link]( index ).remove();

// If selected tab was removed focus tab to the right or

// in case the last tab was removed the tab to the left.
if ( $[Link]( "ui-tabs-selected" ) && [Link] > 1) {
 [Link]( index + ( index + 1 < [Link] ? 1 : -1 )
);
}

[Link] = $.map(
$.grep( [Link], function(n, i) {
return n != index;
}),
function( n, i ) {
return n >= index ? --n : n;
});

this._tabify();

this._trigger( "remove", null, this._ui( $[Link]( "a" )[ 0 ],

$panel[ 0 ] ) );
return this;
},

enable: function( index ) {

index = this._getIndex( index );
var o = [Link];
if ( $.inArray( index, [Link] ) == -1 ) {
return;
}

[Link]( index ).removeClass( "ui-state-disabled" );

[Link] = $.grep( [Link], function( n, i ) {
return n != index;
});

this._trigger( "enable", null, this._ui( [Link][ index ],

[Link][ index ] ) );
return this;
},

disable: function( index ) {

index = this._getIndex( index );
var self = this, o = [Link];
// cannot disable already selected tab
if ( index != [Link] ) {
[Link]( index ).addClass( "ui-state-disabled" );

[Link]( index );
[Link]();

this._trigger( "disable", null, this._ui( [Link][ index ],

[Link][ index ] ) );
}

return this;
},

select: function( index ) {

index = this._getIndex( index );
if ( index == -1 ) {
if ( [Link] && [Link] != -1 ) {
index = [Link];
} else {
 return this;
}
}
[Link]( index ).trigger( [Link] + ".tabs" );
return this;
},

load: function( index ) {

index = this._getIndex( index );
var self = this,
o = [Link],
a = [Link]( index )[ 0 ],
url = $.data( a, "[Link]" );

[Link]();

// not remote or from cache

if ( !url || [Link]( "tabs" ).length !== 0 && $.data( a,
"[Link]" ) ) {
[Link]( "tabs" );
return;
}

// load remote from here on

[Link]( index ).addClass( "ui-state-processing" );

if ( [Link] ) {
var span = $( "span", a );
[Link]( "[Link]", [Link]() ).html( [Link] );
}

[Link] = $.ajax( $.extend( {}, [Link], {

url: url,
success: function( r, s ) {
[Link]( self._sanitizeSelector( [Link] ) ).html(
r );

// take care of tab labels

self._cleanup();

if ( [Link] ) {
$.data( a, "[Link]", true );
}

self._trigger( "load", null,

self._ui( [Link][ index ], [Link][ index ] ) );
try {
[Link]( r, s );
}
catch ( e ) {}
},
error: function( xhr, s, e ) {
// take care of tab labels
self._cleanup();

self._trigger( "load", null,

self._ui( [Link][ index ], [Link][ index ] ) );
try {
// Passing index avoid a race condition when this
method is
// called after the user has selected another tab.
// Pass the anchor that initiated this request allows
// loadError to manipulate the tab content panel via
$([Link])
[Link]( xhr, s, index, a );
}
catch ( e ) {}
}
} ) );

// last, so that load event is fired before show...

[Link]( "tabs" );

return this;
},

abort: function() {
// stop possibly running animations
[Link]( [] );
[Link]( false, true );

// "tabs" queue must not contain more than two elements,

// which are the callbacks for the latest clicked tab...
[Link]( "tabs", [Link]( "tabs" ).splice( -2,
2 ) );

// terminate pending requests from other tabs

if ( [Link] ) {
[Link]();
delete [Link];
}

// take care of tab labels

this._cleanup();
return this;
},

url: function( index, url ) {

[Link]( index ).removeData( "[Link]" ).data( "[Link]",
url );
return this;
},

length: function() {
return [Link];
}
});

$.extend( $.[Link], {
version: "1.8.24"
});

/*
* Tabs Extensions
*/

/*
* Rotate
 */
$.extend( $.[Link], {
rotation: null,
rotate: function( ms, continuing ) {
var self = this,
o = [Link];

var rotate = self._rotate || ( self._rotate = function( e ) {

clearTimeout( [Link] );
[Link] = setTimeout(function() {
var t = [Link];
[Link]( ++t < [Link] ? t : 0 );
}, ms );

if ( e ) {
[Link]();
}
});

var stop = self._unrotate || ( self._unrotate = !continuing

? function(e) {
if ([Link]) { // in case of a true click
[Link](null);
}
}
: function( e ) {
rotate();
});

// start rotation
if ( ms ) {
[Link]( "tabsshow", rotate );
[Link]( [Link] + ".tabs", stop );
rotate();
// stop rotation
} else {
clearTimeout( [Link] );
[Link]( "tabsshow", rotate );
[Link]( [Link] + ".tabs", stop );
delete this._rotate;
delete this._unrotate;
}

return this;
}
});

})( jQuery );