spree_suppliers 0.1.0 → 0.60.3

data/public/javascripts/jquery-ui.js

@@ -0,0 +1,312 @@
+/*!
+ * jQuery UI 1.8.13
+ *
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI
+ */
+(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 ( $.ui.version ) {
+	return;
+}
+
+$.extend( $.ui, {
+	version: "1.8.13",
+
+	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
+$.fn.extend({
+	_focus: $.fn.focus,
+	focus: function( delay, fn ) {
+		return typeof delay === "number" ?
+			this.each(function() {
+				var elem = this;
+				setTimeout(function() {
+					$( elem ).focus();
+					if ( fn ) {
+						fn.call( elem );
+					}
+				}, delay );
+			}) :
+			this._focus.apply( this, arguments );
+	},
+
+	scrollParent: function() {
+		var scrollParent;
+		if (($.browser.msie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {
+			scrollParent = this.parents().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 = this.parents().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(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;
+	},
+
+	disableSelection: function() {
+		return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
+			".ui-disableSelection", function( event ) {
+				event.preventDefault();
+			});
+	},
+
+	enableSelection: function() {
+		return this.unbind( ".ui-disableSelection" );
+	}
+});
+
+$.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( $.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 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" );
+		});
+	};
+});
+
+// selectors
+function focusable( element, isTabIndexNotNaN ) {
+	var nodeName = element.nodeName.toLowerCase();
+	if ( "area" === nodeName ) {
+		var map = element.parentNode,
+			mapName = map.name,
+			img;
+		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 !$( element ).parents().andSelf().filter(function() {
+		return $.curCSS( this, "visibility" ) === "hidden" ||
+			$.expr.filters.hidden( this );
+	}).length;
+}
+
+$.extend( $.expr[ ":" ], {
+	data: function( elem, i, match ) {
+		return !!$.data( elem, match[ 3 ] );
+	},
+
+	focusable: function( element ) {
+		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
+	},
+
+	tabbable: function( element ) {
+		var tabIndex = $.attr( element, "tabindex" ),
+			isTabIndexNaN = isNaN( tabIndex );
+		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
+	}
+});
+
+// support
+$(function() {
+	var body = document.body,
+		div = body.appendChild( div = document.createElement( "div" ) );
+
+	$.extend( div.style, {
+		minHeight: "100px",
+		height: "auto",
+		padding: 0,
+		borderWidth: 0
+	});
+
+	$.support.minHeight = div.offsetHeight === 100;
+	$.support.selectstart = "onselectstart" in div;
+
+	// set display to none to avoid a layout bug in IE
+	// http://dev.jquery.com/ticket/4014
+	body.removeChild( div ).style.display = "none";
+});
+
+
+
+
+
+// deprecated
+$.extend( $.ui, {
+	// $.ui.plugin is deprecated.  Use the proxy pattern instead.
+	plugin: {
+		add: function( module, option, set ) {
+			var proto = $.ui[ module ].prototype;
+			for ( var i in set ) {
+				proto.plugins[ i ] = proto.plugins[ i ] || [];
+				proto.plugins[ i ].push( [ option, set[ i ] ] );
+			}
+		},
+		call: function( instance, name, args ) {
+			var set = instance.plugins[ name ];
+			if ( !set || !instance.element[ 0 ].parentNode ) {
+				return;
+			}
+	
+			for ( var i = 0; i < set.length; i++ ) {
+				if ( instance.options[ set[ i ][ 0 ] ] ) {
+					set[ i ][ 1 ].apply( instance.element, args );
+				}
+			}
+		}
+	},
+	
+	// will be deprecated when we switch to jQuery 1.4 - use jQuery.contains()
+	contains: function( a, b ) {
+		return document.compareDocumentPosition ?
+			a.compareDocumentPosition( b ) & 16 :
+			a !== b && a.contains( 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 $.ui.isOverAxis( y, top, height ) && $.ui.isOverAxis( x, left, width );
+	}
+});
+
+})( jQuery );

data/public/javascripts/jquery-ui.multidatespicker.js

@@ -0,0 +1,398 @@
+/*
+ * MultiDatesPicker v1.5.2
+ * http://multidatespickr.sourceforge.net/
+ * 
+ * Copyright 2011, Luca Lauretta
+ * Dual licensed under the MIT or GPL version 2 licenses.
+ */
+(function( $ ){
+	$.extend($.ui, { multiDatesPicker: { version: "1.5.2" } });
+	
+	$.fn.multiDatesPicker = function(method) {
+		var mdp_arguments = arguments;
+		var ret = this;
+		var today_date = new Date();
+		var day_zero = new Date(0);
+		var mdp_events = {};
+		
+		function removeDate(index, type) {
+			if(!type) type = 'picked';
+			this.multiDatesPicker.dates[type].splice(index, 1);
+		}
+		function addDate(date, type, no_sort) {
+			if(!type) type = 'picked';
+			if (methods.gotDate.call(this, date, type) === false) {
+				this.multiDatesPicker.dates[type].push(dateConvert.call(this, date));
+				if(!no_sort) this.multiDatesPicker.dates[type].sort(methods.compareDates);
+			} 
+		}
+		function sortDates(type) {
+			if(!type) type = 'picked';
+			this.multiDatesPicker.dates[type].sort(methods.compareDates);
+		}
+		function dateConvert(date, desired_type, date_format) {
+			if(!desired_type) desired_type = 'object';
+			if(!date_format && (typeof date == 'string')) {
+				date_format = $(this).datepicker('option', 'dateFormat');
+				if(!date_format) date_format = $.datepicker._defaults.dateFormat;
+			}
+			
+			return methods.dateConvert.call(this, date, desired_type, date_format);
+		}
+		
+		var methods = {
+			init : function( options ) {
+				var $this = $(this);
+				this.multiDatesPicker.changed = false;
+				
+				var mdp_events = {
+					beforeShow: function(input, inst) {
+						this.multiDatesPicker.changed = false;
+						if(this.multiDatesPicker.originalBeforeShow) this.multiDatesPicker.originalBeforeShow.call(this, input, inst);
+					},
+					onSelect : function(dateText, inst) {
+						var $this = $(this);
+						this.multiDatesPicker.changed = true;
+						
+						if (dateText) {
+							$this.multiDatesPicker('toggleDate', dateText);
+							var current_date = dateConvert.call(this, dateText);
+						}
+						var dates_picked = $this.multiDatesPicker('getDates');
+						var datos = this.multiDatesPicker.mode.options;
+						
+						if (dates_picked.length > 0) {
+							if (this.multiDatesPicker.mode.modeName == 'normal') {
+								if (datos.pickableRange) {
+									var min_date = methods.compareDates(dateConvert.call(this, this.multiDatesPicker.minDate, 'object'), today_date);
+									var max_date = min_date + datos.pickableRangeDelay + pickableRange;
+									
+									// min
+									var n_min_date = methods.compareDates(dateConvert.call(this, dates_picked[0], 'object'), dateConvert.call(this, min_date, 'object'));
+									
+									// max
+									var n_max_date = n_min_date + datos.pickableRange;
+									
+									// adjust
+									if (n_max_date > max_date) min_date = max_date - datos.pickableRange + 1;
+									else {
+										max_date = n_max_date;
+										min_date = n_min_date;
+									}
+										
+									// counts the number of disabled dates in the range
+									var c_disabled;
+									do {
+										c_disabled = 0;
+										for(var i in this.multiDatesPicker.dates.disabled) {
+											var avdatei = dateConvert.call(this, this.multiDatesPicker.dates.disabled[i], 'object');
+											if(methods.compareDates(avdatei, min_date) >= 0 &&
+													methods.compareDates(avdatei, max_date) <= 0)
+												c_disabled++;
+										}
+										max_date = max_date + c_disabled;
+									} while(c_disabled != 0);
+									
+									$this.datepicker("option", "minDate", min_date);
+									$this.datepicker("option", "maxDate", max_date);
+								}
+							}
+						}
+						
+						if(this.tagName == 'INPUT') { // for inputs
+							$this.val(
+								$this.multiDatesPicker('getDates', 'string')
+							);
+						}
+						
+						if(this.multiDatesPicker.originalOnSelect && dateText)
+							this.multiDatesPicker.originalOnSelect.call(this, dateText, inst);
+						
+						// thanks to bibendus83 -> http://sourceforge.net/tracker/?func=detail&atid=1495384&aid=3403159&group_id=358205
+						if ($this.datepicker('option', 'altField') != undefined && $this.datepicker('option', 'altField') != "") {
+							$($this.datepicker('option', 'altField')).val(
+								$this.multiDatesPicker('getDates', 'string')
+							);
+						}
+					},
+					beforeShowDay : function(date) {
+						var $this = $(this);
+						var gotThisDate = $this.multiDatesPicker('gotDate', date) !== false;
+						var highlight_class = gotThisDate
+							? 'ui-state-highlight'
+							: '';
+							
+						var isDisabledDate = $this.multiDatesPicker('gotDate', date, 'disabled') !== false;
+						var allSelected = this.multiDatesPicker.mode.options.maxPicks == $this.multiDatesPicker('getDates').length;
+						var selectable_date = (isDisabledDate || (allSelected && !highlight_class))
+							? false
+							: true;
+							
+						if(this.multiDatesPicker.originalBeforeShowDay) this.multiDatesPicker.originalBeforeShowDay.call(this, date);
+						
+						return [selectable_date, highlight_class];
+					},
+					onClose: function(dateText, inst) {
+						if(this.tagName == 'INPUT' && this.multiDatesPicker.changed) {
+							$(inst.dpDiv[0]).stop(false,true);
+							setTimeout('$("#'+inst.id+'").datepicker("show")',50);
+						}
+						if(this.multiDatesPicker.originalOnClose) this.multiDatesPicker.originalOnClose.call(this, dateText, inst);
+					}
+				};
+				
+				if(options) {
+					this.multiDatesPicker.originalBeforeShow = options.beforeShow;
+					this.multiDatesPicker.originalOnSelect = options.onSelect;
+					this.multiDatesPicker.originalBeforeShowDay = options.beforeShowDay;
+					this.multiDatesPicker.originalOnClose = options.onClose;
+					
+					$this.datepicker(options);
+					
+					this.multiDatesPicker.minDate = $.datepicker._determineDate(this, options.minDate, day_zero);
+					this.multiDatesPicker.firstAvailableDay = methods.compareDates(this.multiDatesPicker.minDate, day_zero);
+					
+					if(options.addDates) methods.addDates.call(this, options.addDates);
+					if(options.addDisabledDates)
+						methods.addDates.call(this, options.addDisabledDates, 'disabled');
+					
+					if(options.mode)
+						methods.setMode.call(this, options.mode);
+				} else {
+					$this.datepicker();
+				}
+				
+				$this.datepicker('option', mdp_events);
+				
+				if(this.tagName == 'INPUT') $this.val($this.multiDatesPicker('getDates', 'string'));
+				
+				// Fixes the altField filled with defaultDate by default
+				var altFieldOption = $this.datepicker('option', 'altField');
+				if (altFieldOption) $(altFieldOption).val($this.multiDatesPicker('getDates', 'string'));
+			},
+			compareDates : function(date1, date2) {
+				var one_day = 1000*60*60*24;
+				// return > 0 means date1 is later than date2 
+				// return == 0 means date1 is the same day as date2 
+				// return < 0 means date1 is earlier than date2 
+				return Math.ceil(date1.getTime()/one_day) - Math.ceil(date2.getTime()/one_day);
+			},
+			sumDays : function( date, n_days ) {
+				var origDateType = typeof date;
+				obj_date = dateConvert.call(this, date);
+				obj_date.setDate(obj_date.getDate() + n_days);
+				return dateConvert.call(this, obj_date, origDateType);
+			},
+			dateConvert : function( date, desired_format, dateFormat ) {
+				if(typeof date == desired_format) return date;
+				
+				var $this = $(this);
+				if(typeof date == 'undefined') date = new Date(0);
+				
+				if(desired_format != 'string' && desired_format != 'object')
+					$.error('Date format "'+ desired_format +'" not supported on jQuery.multiDatesPicker');
+				
+				var conversion = typeof date + '->' + desired_format;
+				if(!dateFormat) {
+					dateFormat = $.datepicker._defaults.dateFormat;
+					
+					// thanks to bibendus83 -> http://sourceforge.net/tracker/index.php?func=detail&aid=3213174&group_id=358205&atid=1495382
+					var dp_dateFormat = $this.datepicker('option', 'dateFormat');
+					if (dp_dateFormat) {
+						dateFormat = dp_dateFormat;
+					}
+				}
+				switch(conversion) {
+					case 'object->string':
+						return $.datepicker.formatDate(dateFormat, date);
+					case 'string->object':
+						return $.datepicker.parseDate(dateFormat, date);
+					default:
+						$.error('Conversion "'+ conversion +'" not allowed on jQuery.multiDatesPicker');
+				}
+				return false;
+			},
+			gotDate : function( date, type ) {
+				if(!type) type = 'picked';
+				for(var i = 0; i < this.multiDatesPicker.dates[type].length; i++) {
+					if(methods.compareDates(dateConvert.call(this, this.multiDatesPicker.dates[type][i]), dateConvert.call(this, date)) == 0) {
+						return i;
+					}
+				}
+				return false;
+			},
+			getDates : function( format, type ) {
+				if(!type) type = 'picked';
+				switch (format) {
+					case 'object':
+						return this.multiDatesPicker.dates[type];
+					default:
+						var o_dates = new Array();
+						for(var i in this.multiDatesPicker.dates[type])
+							o_dates.push(
+								dateConvert.call(
+									this, 
+									this.multiDatesPicker.dates[type][i], 
+									'string'
+								)
+							);
+						return o_dates;
+				}
+			},
+			addDates : function( dates, type ) {
+				if(!type) type = 'picked';
+				switch(typeof dates) {
+					case 'object':
+					case 'array':
+						if(dates.length) {
+							for(var i in dates)
+								addDate.call(this, dates[i], type, true);
+							sortDates.call(this, type);
+							break;
+						} // else does the same as 'string'
+					case 'string':
+						addDate.call(this, dates, type);
+						break;
+					default: 
+						$.error('Date format "'+ typeof dates +'" not allowed on jQuery.multiDatesPicker');
+				}
+				$(this).datepicker('refresh');
+			},
+			removeDates : function( indexes, type ) {
+				if(!type) type = 'picked';
+				if(typeof indexes == 'array')
+					for(var i in indexes) removeDate.call(this, i, type);
+				else
+					removeDate.call(this, indexes, type);
+				$(this).datepicker('refresh');
+			},
+			resetDates : function ( type ) {
+				if(!type) type = 'picked';
+				this.multiDatesPicker.dates[type] = [];
+				$(this).datepicker('refresh');
+			},
+			toggleDate : function( date, type ) {
+				if(!type) type = 'picked';
+				var index = methods.gotDate.call(this, date);
+				var mode = this.multiDatesPicker.mode;
+				
+				switch(mode.modeName) {
+					case 'daysRange':
+						this.multiDatesPicker.dates[type] = []; // deletes all picked/disabled dates
+						var end = mode.options.autoselectRange[1];
+						var begin = mode.options.autoselectRange[0];
+						if(end < begin) { // switch
+							end = mode.options.autoselectRange[0];
+							begin = mode.options.autoselectRange[1];
+						}
+						for(var i = begin; i < end; i++) 
+							methods.addDates.call(this, methods.sumDays(date, i), type);
+						break;
+					default:
+						if(index === false) // adds dates
+							methods.addDates.call(this, date, type);
+						else // removes dates
+							methods.removeDates.call(this, index, type);
+						break;
+				}
+			}, 
+			setMode : function( mode ) {
+				this.multiDatesPicker.mode.modeName = mode.modeName;
+				var option;
+				switch(mode.modeName) {
+					case 'normal':
+						for(option in mode.options)
+							switch(option) {
+								case 'maxPicks':
+								case 'minPicks':
+								case 'pickableRange':
+								case 'pickableRangeDelay':
+								case 'adjustRangeToDisabled':
+									this.multiDatesPicker.mode.options[option] = mode.options[option];
+									break;
+								default: $.error('Option ' + option + ' does not exist for setMode on jQuery.multiDatesPicker');
+							}
+					break;
+					case 'daysRange':
+					case 'weeksRange':
+						var mandatory = 1;
+						for(option in mode.options)
+							switch(option) {
+								case 'autoselectRange':
+									mandatory--;
+								case 'pickableRange':
+								case 'pickableRangeDelay':
+								case 'adjustRangeToDisabled':
+									this.multiDatesPicker.mode.options[option] = mode.options[option];
+									break;
+								default: $.error('Option ' + option + ' does not exist for setMode on jQuery.multiDatesPicker');
+							}
+						if(mandatory > 0) $.error('Some mandatory options not specified!');
+					break;
+				}
+				
+				if(mode.options.pickableRange) {
+					$(this).datepicker("option", "maxDate", mode.options.pickableRange + (mode.options.pickableRangeDelay || 0));
+					$(this).datepicker("option", "minDate", this.multiDatesPicker.minDate);
+				}
+				
+				if(mdp_events.onSelect) mdp_events.onSelect();
+				$(this).datepicker('refresh');
+			}
+		};
+		
+		this.each(function() {
+			if (!this.multiDatesPicker) 
+				this.multiDatesPicker = {
+					dates: {
+						picked: [],
+						disabled: []
+					},
+					mode: {
+						modeName: 'normal',
+						options: {
+							adjustRangeToDisabled: true
+						}
+					}
+				};
+			
+			if(methods[method]) {
+				var exec_result = methods[method].apply(this, Array.prototype.slice.call(mdp_arguments, 1));
+				switch(method) {
+					case 'getDates':
+					case 'gotDate':
+					case 'sumDays':
+					case 'compareDates':
+					case 'dateConvert':
+						ret = exec_result;
+				}
+				return exec_result;
+			} else if( typeof method === 'object' || ! method ) {
+				return methods.init.apply(this, mdp_arguments);
+			} else {
+				$.error('Method ' +  method + ' does not exist on jQuery.multiDatesPicker');
+			}
+			return false;
+		});
+		
+		if(method != 'gotDate' && method != 'getDates') {
+			aaaa = 1;
+		}
+		
+		return ret;
+	};
+
+	var PROP_NAME = 'multiDatesPicker';
+	var dpuuid = new Date().getTime();
+	var instActive;
+
+	$.multiDatesPicker = {version: false};
+	//$.multiDatesPicker = new MultiDatesPicker(); // singleton instance
+	$.multiDatesPicker.initialized = false;
+	$.multiDatesPicker.uuid = new Date().getTime();
+	$.multiDatesPicker.version = $.ui.multiDatesPicker.version;
+
+	// Workaround for #4055
+	// Add another global to avoid noConflict issues with inline event handlers
+	window['DP_jQuery_' + dpuuid] = $;
+})( jQuery );