redCOMPONENT-COM / redCORE

(function( $, undefined ) {

var uuid = 0,

	runiqueId = /^ui-id-\d+$/;

// $.ui might exist from components with no dependencies, e.g., $.ui.position

$.ui = $.ui || {};

$.extend( $.ui, {

	version: "1.10.4",

	keyCode: {

		BACKSPACE: 8,

		COMMA: 188,

		DELETE: 46,

		DOWN: 40,

		END: 35,

		ENTER: 13,

		ESCAPE: 27,

		HOME: 36,

		LEFT: 37,

		NUMPAD_ADD: 107,

		NUMPAD_DECIMAL: 110,

		NUMPAD_DIVIDE: 111,

		NUMPAD_ENTER: 108,

		NUMPAD_MULTIPLY: 106,

		NUMPAD_SUBTRACT: 109,

		PAGE_DOWN: 34,

		PAGE_UP: 33,

		PERIOD: 190,

		RIGHT: 39,

		SPACE: 32,

		TAB: 9,

		UP: 38

	}

});

// plugins

$.fn.extend({

	focus: (function( orig ) {

		return function( delay, fn ) {

			return typeof delay === "number" ?

				this.each(function() {

					var elem = this;

					setTimeout(function() {

						$( elem ).focus();

						if ( fn ) {

							fn.call( elem );

						}

					}, delay );

				}) :

				orig.apply( this, arguments );

		};

	})( $.fn.focus ),

	scrollParent: function() {

		var scrollParent;

		if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {

			scrollParent = this.parents().filter(function() {

				return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));

			}).eq(0);

		} else {

			scrollParent = this.parents().filter(function() {

				return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));

			}).eq(0);

		}

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

	},

	zIndex: function( zIndex ) {

		if ( zIndex !== undefined ) {

			return this.css( "zIndex", zIndex );

		}

		if ( this.length ) {

			var elem = $( this[ 0 ] ), position, value;

			while ( elem.length && elem[ 0 ] !== document ) {

				// Ignore z-index if position is set to a value where z-index is ignored by the browser

				// This makes behavior of this function consistent across browsers

				// WebKit always returns auto if the element is positioned

				position = elem.css( "position" );

				if ( position === "absolute" || position === "relative" || position === "fixed" ) {

					// IE returns 0 when zIndex is not specified

					// other browsers return a string

					// we ignore the case of nested elements with an explicit value of 0

					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>

					value = parseInt( elem.css( "zIndex" ), 10 );

					if ( !isNaN( value ) && value !== 0 ) {

						return value;

					}

				}

				elem = elem.parent();

			}

		}

		return 0;

	},

	uniqueId: function() {

		return this.each(function() {

			if ( !this.id ) {

				this.id = "ui-id-" + (++uuid);

			}

		});

	},

	removeUniqueId: function() {

		return this.each(function() {

			if ( runiqueId.test( this.id ) ) {

				$( this ).removeAttr( "id" );

			}

		});

	}

});

// selectors

function focusable( element, isTabIndexNotNaN ) {

	var map, mapName, img,

		nodeName = element.nodeName.toLowerCase();

	if ( "area" === nodeName ) {

		map = element.parentNode;

		mapName = map.name;

		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {

			return false;

		}

		img = $( "img[usemap=#" + mapName + "]" )[0];

		return !!img && visible( img );

	}

	return ( /input|select|textarea|button|object/.test( nodeName ) ?

		!element.disabled :

		"a" === nodeName ?

			element.href || isTabIndexNotNaN :

			isTabIndexNotNaN) &&

		// the element and all of its ancestors must be visible

		visible( element );

}

function visible( element ) {

	return $.expr.filters.visible( element ) &&

		!$( element ).parents().addBack().filter(function() {

			return $.css( this, "visibility" ) === "hidden";

		}).length;

}

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

	data: $.expr.createPseudo ?

		$.expr.createPseudo(function( dataName ) {

			return function( elem ) {

				return !!$.data( elem, dataName );

			};

		}) :

		// support: jQuery <1.8

		function( elem, i, match ) {

			return !!$.data( elem, match[ 3 ] );

		},

	focusable: function( element ) {

		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );

	},

	tabbable: function( element ) {

		var tabIndex = $.attr( element, "tabindex" ),

			isTabIndexNaN = isNaN( tabIndex );

		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );

	}

});

// support: jQuery <1.8

if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {

	$.each( [ "Width", "Height" ], function( i, name ) {

		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],

			type = name.toLowerCase(),

			orig = {

				innerWidth: $.fn.innerWidth,

				innerHeight: $.fn.innerHeight,

				outerWidth: $.fn.outerWidth,

				outerHeight: $.fn.outerHeight

			};

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

			$.each( side, function() {

				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;

				if ( border ) {

					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;

				}

				if ( margin ) {

					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;

				}

			});

			return size;

		}

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

			if ( size === undefined ) {

				return orig[ "inner" + name ].call( this );

			}

			return this.each(function() {

				$( this ).css( type, reduce( this, size ) + "px" );

			});

		};

		$.fn[ "outer" + name] = function( size, margin ) {

			if ( typeof size !== "number" ) {

				return orig[ "outer" + name ].call( this, size );

			}

			return this.each(function() {

				$( this).css( type, reduce( this, size, true, margin ) + "px" );

			});

		};

	});

}

// support: jQuery <1.8

if ( !$.fn.addBack ) {

	$.fn.addBack = function( selector ) {

		return this.add( selector == null ?

			this.prevObject : this.prevObject.filter( selector )

		);

	};

}

// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)

if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {

	$.fn.removeData = (function( removeData ) {

		return function( key ) {

			if ( arguments.length ) {

				return removeData.call( this, $.camelCase( key ) );

			} else {

				return removeData.call( this );

			}

		};

	})( $.fn.removeData );

}

// deprecated

$.support.selectstart = "onselectstart" in document.createElement( "div" );

$.fn.extend({

	disableSelection: function() {

		return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +

			".ui-disableSelection", function( event ) {

				event.preventDefault();

			});

	},

	enableSelection: function() {

		return this.unbind( ".ui-disableSelection" );

	}

});

$.extend( $.ui, {

	// $.ui.plugin is deprecated. Use $.widget() extensions instead.

	plugin: {

		add: function( module, option, set ) {

			var i,

				proto = $.ui[ module ].prototype;

			for ( i in set ) {

				proto.plugins[ i ] = proto.plugins[ i ] || [];

				proto.plugins[ i ].push( [ option, set[ i ] ] );

			}

		},

		call: function( instance, name, args ) {

			var i,

				set = instance.plugins[ name ];

			if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {

				return;

			}

			for ( i = 0; i < set.length; i++ ) {

				if ( instance.options[ set[ i ][ 0 ] ] ) {

					set[ i ][ 1 ].apply( instance.element, args );

				}

			}

		}

	},

	// 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",

		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;

	}

});

})( jQuery );

(function( $, undefined ) {

var uuid = 0,

	slice = Array.prototype.slice,

	_cleanData = $.cleanData;

$.cleanData = function( elems ) {

	for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {

		try {

			$( elem ).triggerHandler( "remove" );

		// http://bugs.jquery.com/ticket/8235

		} catch( e ) {}

	}

	_cleanData( elems );

};

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

	var fullName, existingConstructor, constructor, basePrototype,

		// proxiedPrototype allows the provided prototype to remain unmodified

		// so that it can be used as a mixin for multiple widgets (#8876)

		proxiedPrototype = {},

		namespace = name.split( "." )[ 0 ];

	name = name.split( "." )[ 1 ];

	fullName = namespace + "-" + name;

	if ( !prototype ) {

		prototype = base;

		base = $.Widget;

	}

	// create selector for plugin

	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {

		return !!$.data( elem, fullName );

	};

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

	existingConstructor = $[ namespace ][ name ];

	constructor = $[ namespace ][ name ] = function( options, element ) {

		// allow instantiation without "new" keyword

		if ( !this._createWidget ) {

		}

		// allow instantiation without initializing for simple inheritance

		// must use "new" keyword (the code above always passes args)

		}

	};

	// extend with the existing constructor to carry over any static properties

	$.extend( constructor, existingConstructor, {

		version: prototype.version,

		// copy the object used to create the prototype in case we need to

		// redefine the widget later

		_proto: $.extend( {}, prototype ),

		// track widgets that inherit from this widget in case this widget is

		// redefined after a widget inherits from it

		_childConstructors: []

	});

	// we need to make the options hash a property directly on the new instance

	// otherwise we'll modify the options hash on the prototype that we're

	// inheriting from

	basePrototype.options = $.widget.extend( {}, basePrototype.options );

	$.each( prototype, function( prop, value ) {

		if ( !$.isFunction( value ) ) {

			proxiedPrototype[ prop ] = value;

			return;

		}

		proxiedPrototype[ prop ] = (function() {

			var _super = function() {

					return base.prototype[ prop ].apply( this, arguments );

				},

				_superApply = function( args ) {

					return base.prototype[ prop ].apply( this, args );

				};

			return function() {

				var __super = this._super,

					__superApply = this._superApply,

					returnValue;

				this._super = _super;

				this._superApply = _superApply;

				returnValue = value.apply( this, arguments );

				this._super = __super;

				this._superApply = __superApply;

				return returnValue;

			};

		})();

	});

	constructor.prototype = $.widget.extend( basePrototype, {

		// TODO: remove support for widgetEventPrefix

		// always use the name + a colon as the prefix, e.g., draggable:start

		// don't prefix for widgets that aren't DOM-based

		widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name

	}, proxiedPrototype, {

		constructor: constructor,

		namespace: namespace,

		widgetName: name,

		widgetFullName: fullName

	});

	// If this widget is being redefined then we need to find all widgets that

	// are inheriting from it and redefine all of them so that they inherit from

	// the new version of this widget. We're essentially trying to replace one

	// level in the prototype chain.

	if ( existingConstructor ) {

		$.each( existingConstructor._childConstructors, function( i, child ) {

			var childPrototype = child.prototype;

			// redefine the child widget using the same prototype that was

			// originally used, but inherit from the new version of the base

			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );

		});

		// remove the list of existing child constructors from the old constructor

		// so the old child constructors can be garbage collected

		delete existingConstructor._childConstructors;

	} else {

		base._childConstructors.push( constructor );

	}

	$.widget.bridge( name, constructor );

};

$.widget.extend = function( target ) {

	var input = slice.call( arguments, 1 ),

		inputIndex = 0,

		inputLength = input.length,

		key,

		value;

	for ( ; inputIndex < inputLength; inputIndex++ ) {

		for ( key in input[ inputIndex ] ) {

			value = input[ inputIndex ][ key ];

			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {

				// Clone objects

				if ( $.isPlainObject( value ) ) {

					target[ key ] = $.isPlainObject( target[ key ] ) ?

						$.widget.extend( {}, target[ key ], value ) :

						// Don't extend strings, arrays, etc. with objects

						$.widget.extend( {}, value );

				// Copy everything else by reference

				} else {

					target[ key ] = value;

				}

			}

		}

	}

	return target;

};

$.widget.bridge = function( name, object ) {

	var fullName = object.prototype.widgetFullName || name;

	$.fn[ name ] = function( options ) {

		var isMethodCall = typeof options === "string",

			args = slice.call( arguments, 1 ),

			returnValue = this;

		// allow multiple hashes to be passed on init

		options = !isMethodCall && args.length ?

			$.widget.extend.apply( null, [ options ].concat(args) ) :