/*
Copyright (c) 2007, Yahoo! Inc. All rights reserved.
Code licensed under the BSD License:
http://developer.yahoo.net/yui/license.txt
version: 2.3.0
*/
(function () {
	YAHOO.util.Config = function (owner) {
		if (owner) {
			this.init(owner);
		}

		if (!owner) {
		}
	};

	var Lang = YAHOO.lang,
		CustomEvent = YAHOO.util.CustomEvent,
		Config = YAHOO.util.Config;

	Config.CONFIG_CHANGED_EVENT = "configChanged";

	Config.BOOLEAN_TYPE = "boolean";

	Config.prototype = {
		owner: null,
		queueInProgress: false,
		config: null,
		initialConfig: null,
		eventQueue: null,
		configChangedEvent: null,

		init: function (owner) {
			this.owner = owner;

			this.configChangedEvent =
				this.createEvent(Config.CONFIG_CHANGED_EVENT);

			this.configChangedEvent.signature = CustomEvent.LIST;
			this.queueInProgress = false;
			this.config = {};
			this.initialConfig = {};
			this.eventQueue = [];
		},

		checkBoolean: function (val) {
			return (typeof val == Config.BOOLEAN_TYPE);
		},

		checkNumber: function (val) {
			return (!isNaN(val));
		},

		fireEvent: function ( key, value ) {
			var property = this.config[key];

			if (property && property.event) {
				property.event.fire(value);
			}
		},

		addProperty: function ( key, propertyObject ) {
			key = key.toLowerCase();

			this.config[key] = propertyObject;

			propertyObject.event = this.createEvent(key, { scope: this.owner });
			propertyObject.event.signature = CustomEvent.LIST;

			propertyObject.key = key;

			if (propertyObject.handler) {
				propertyObject.event.subscribe(propertyObject.handler,
					this.owner);
			}

			this.setProperty(key, propertyObject.value, true);

			if (! propertyObject.suppressEvent) {
				this.queueProperty(key, propertyObject.value);
			}
		},

		getConfig: function () {
			var cfg = {},
				prop,
				property;

			for (prop in this.config) {
				property = this.config[prop];
				if (property && property.event) {
					cfg[prop] = property.value;
				}
			}

			return cfg;
		},

		getProperty: function (key) {
			var property = this.config[key.toLowerCase()];
			if (property && property.event) {
				return property.value;
			} else {
				return undefined;
			}
		},

		resetProperty: function (key) {
			key = key.toLowerCase();

			var property = this.config[key];

			if (property && property.event) {
				if (this.initialConfig[key] &&
					!Lang.isUndefined(this.initialConfig[key])) {
					this.setProperty(key, this.initialConfig[key]);
				}

				return true;
			} else {
				return false;
			}
		},

		setProperty: function (key, value, silent) {
			var property;

			key = key.toLowerCase();

			if (this.queueInProgress && ! silent) {
				this.queueProperty(key,value);
				return true;
			} else {
				property = this.config[key];
				if (property && property.event) {
					if (property.validator && !property.validator(value)) {
						return false;
					} else {
						property.value = value;
						if (! silent) {
							this.fireEvent(key, value);
							this.configChangedEvent.fire([key, value]);
						}
						return true;
					}
				} else {
					return false;
				}
			}
		},

		queueProperty: function (key, value) {
			key = key.toLowerCase();

			var property = this.config[key],
				foundDuplicate = false,
				iLen,
				queueItem,
				queueItemKey,
				queueItemValue,
				sLen,
				supercedesCheck,
				qLen,
				queueItemCheck,
				queueItemCheckKey,
				queueItemCheckValue,
				i,
				s,
				q;

			if (property && property.event) {
				if (!Lang.isUndefined(value) && property.validator &&
					!property.validator(value)) {
					return false;
				} else {
					if (!Lang.isUndefined(value)) {
						property.value = value;
					} else {
						value = property.value;
					}

					foundDuplicate = false;
					iLen = this.eventQueue.length;

					for (i = 0; i < iLen; i++) {
						queueItem = this.eventQueue[i];

						if (queueItem) {
							queueItemKey = queueItem[0];
							queueItemValue = queueItem[1];

							if (queueItemKey == key) {
								this.eventQueue[i] = null;

								this.eventQueue.push(
									[key, (!Lang.isUndefined(value) ?
									value : queueItemValue)]);

								foundDuplicate = true;
								break;
							}
						}
					}

					if (! foundDuplicate && !Lang.isUndefined(value)) {
						this.eventQueue.push([key, value]);
					}
				}

				if (property.supercedes) {
					sLen = property.supercedes.length;

					for (s = 0; s < sLen; s++) {
						supercedesCheck = property.supercedes[s];
						qLen = this.eventQueue.length;

						for (q = 0; q < qLen; q++) {
							queueItemCheck = this.eventQueue[q];

							if (queueItemCheck) {
								queueItemCheckKey = queueItemCheck[0];
								queueItemCheckValue = queueItemCheck[1];

								if (queueItemCheckKey ==
									supercedesCheck.toLowerCase() ) {
									this.eventQueue.push([queueItemCheckKey,
										queueItemCheckValue]);

									this.eventQueue[q] = null;
									break;
								}
							}
						}
					}
				}

				return true;
			} else {
				return false;
			}
		},

		refireEvent: function (key) {
			key = key.toLowerCase();

			var property = this.config[key];

			if (property && property.event &&

				!Lang.isUndefined(property.value)) {
				if (this.queueInProgress) {
					this.queueProperty(key);
				} else {
					this.fireEvent(key, property.value);
				}
			}
		},

		applyConfig: function (userConfig, init) {
			var prop;

			if (init) {
				this.initialConfig = userConfig;
			}
			for (prop in userConfig) {
				this.queueProperty(prop, userConfig[prop]);
			}
		},

		refresh: function () {
			var prop;

			for (prop in this.config) {
				this.refireEvent(prop);
			}
		},

		fireQueue: function () {
			var i,
				queueItem,
				key,
				value,
				property;

			this.queueInProgress = true;
			for (i = 0;i < this.eventQueue.length; i++) {
				queueItem = this.eventQueue[i];
				if (queueItem) {
					key = queueItem[0];
					value = queueItem[1];
					property = this.config[key];

					property.value = value;

					this.fireEvent(key,value);
				}
			}

			this.queueInProgress = false;
			this.eventQueue = [];
		},

		subscribeToConfigEvent: function (key, handler, obj, override) {
			var property = this.config[key.toLowerCase()];

			if (property && property.event) {
				if (!Config.alreadySubscribed(property.event, handler, obj)) {
					property.event.subscribe(handler, obj, override);
				}

				return true;
			} else {
				return false;
			}
		},

		unsubscribeFromConfigEvent: function (key, handler, obj) {
			var property = this.config[key.toLowerCase()];
			if (property && property.event) {
				return property.event.unsubscribe(handler, obj);
			} else {
				return false;
			}
		},

		toString: function () {
			var output = "Config";
			if (this.owner) {
				output += " [" + this.owner.toString() + "]";
			}
			return output;
		},

		outputEventQueue: function () {
			var output = "",
				queueItem,
				q,
				nQueue = this.eventQueue.length;

			for (q = 0; q < nQueue; q++) {
				queueItem = this.eventQueue[q];
				if (queueItem) {
					output += queueItem[0] + "=" + queueItem[1] + ", ";
				}
			}
			return output;
		},

		destroy: function () {
			var oConfig = this.config,
				sProperty,
				oProperty;

			for (sProperty in oConfig) {
				if (Lang.hasOwnProperty(oConfig, sProperty)) {
					oProperty = oConfig[sProperty];

					oProperty.event.unsubscribeAll();
					oProperty.event = null;
				}
			}

			this.configChangedEvent.unsubscribeAll();

			this.configChangedEvent = null;
			this.owner = null;
			this.config = null;
			this.initialConfig = null;
			this.eventQueue = null;
		}
	};

	Config.alreadySubscribed = function (evt, fn, obj) {
		var nSubscribers = evt.subscribers.length,
			subsc,
			i;

		if (nSubscribers > 0) {
			i = nSubscribers - 1;

			do {
				subsc = evt.subscribers[i];

				if (subsc && subsc.obj == obj && subsc.fn == fn) {
					return true;
				}
			}
			while (i--);
		}

		return false;
	};

	YAHOO.lang.augmentProto(Config, YAHOO.util.EventProvider);

}());

YAHOO.widget.DateMath = {
	DAY : "D",
	WEEK : "W",
	YEAR : "Y",
	MONTH : "M",
	ONE_DAY_MS : 1000*60*60*24,

	add : function(date, field, amount) {
		var d = new Date(date.getTime());
		switch (field) {
			case this.MONTH:
				var newMonth = date.getMonth() + amount;
				var years = 0;

				if (newMonth < 0) {
					while (newMonth < 0) {
						newMonth += 12;
						years -= 1;
					}
				} else if (newMonth > 11) {
					while (newMonth > 11) {
						newMonth -= 12;
						years += 1;
					}
				}

				d.setMonth(newMonth);
				d.setFullYear(date.getFullYear() + years);
				break;
			case this.DAY:
				d.setDate(date.getDate() + amount);
				break;
			case this.YEAR:
				d.setFullYear(date.getFullYear() + amount);
				break;
			case this.WEEK:
				d.setDate(date.getDate() + (amount * 7));
				break;
		}
		return d;
	},

	subtract : function(date, field, amount) {
		return this.add(date, field, (amount*-1));
	},

	before : function(date, compareTo) {
		var ms = compareTo.getTime();
		if (date.getTime() < ms) {
			return true;
		} else {
			return false;
		}
	},

	after : function(date, compareTo) {
		var ms = compareTo.getTime();
		if (date.getTime() > ms) {
			return true;
		} else {
			return false;
		}
	},

	between : function(date, dateBegin, dateEnd) {
		if (this.after(date, dateBegin) && this.before(date, dateEnd)) {
			return true;
		} else {
			return false;
		}
	},

	getJan1 : function(calendarYear) {
		return new Date(calendarYear,0,1);
	},

	getDayOffset : function(date, calendarYear) {
		var beginYear = this.getJan1(calendarYear);

		var dayOffset = Math.ceil((date.getTime()-beginYear.getTime()) / this.ONE_DAY_MS);
		return dayOffset;
	},

	getWeekNumber : function(date, calendarYear) {
		date = this.clearTime(date);
		var nearestThurs = new Date(date.getTime() + (4 * this.ONE_DAY_MS) - ((date.getDay()) * this.ONE_DAY_MS));

		var jan1 = new Date(nearestThurs.getFullYear(),0,1);
		var dayOfYear = ((nearestThurs.getTime() - jan1.getTime()) / this.ONE_DAY_MS) - 1;

		var weekNum = Math.ceil((dayOfYear)/ 7);
		return weekNum;
	},

	isYearOverlapWeek : function(weekBeginDate) {
		var overlaps = false;
		var nextWeek = this.add(weekBeginDate, this.DAY, 6);
		if (nextWeek.getFullYear() != weekBeginDate.getFullYear()) {
			overlaps = true;
		}
		return overlaps;
	},

	isMonthOverlapWeek : function(weekBeginDate) {
		var overlaps = false;
		var nextWeek = this.add(weekBeginDate, this.DAY, 6);
		if (nextWeek.getMonth() != weekBeginDate.getMonth()) {
			overlaps = true;
		}
		return overlaps;
	},

	findMonthStart : function(date) {
		var start = new Date(date.getFullYear(), date.getMonth(), 1);
		return start;
	},

	findMonthEnd : function(date) {
		var start = this.findMonthStart(date);
		var nextMonth = this.add(start, this.MONTH, 1);
		var end = this.subtract(nextMonth, this.DAY, 1);
		return end;
	},

	clearTime : function(date) {
		date.setHours(12,0,0,0);
		return date;
	}
};

YAHOO.widget.Calendar = function(id, containerId, config) {
	this.init(id, containerId, config);
};

YAHOO.widget.Calendar.IMG_ROOT = null;
YAHOO.widget.Calendar.DATE = "D";
YAHOO.widget.Calendar.MONTH_DAY = "MD";
YAHOO.widget.Calendar.WEEKDAY = "WD";
YAHOO.widget.Calendar.RANGE = "R";
YAHOO.widget.Calendar.MONTH = "M";
YAHOO.widget.Calendar.DISPLAY_DAYS = 42;
YAHOO.widget.Calendar.STOP_RENDER = "S";
YAHOO.widget.Calendar.SHORT = "short";
YAHOO.widget.Calendar.LONG = "long";
YAHOO.widget.Calendar.MEDIUM = "medium";
YAHOO.widget.Calendar.ONE_CHAR = "1char";
YAHOO.widget.Calendar._DEFAULT_CONFIG = {
	PAGEDATE : {key:"pagedate", value:null},
	SELECTED : {key:"selected", value:null},
	TITLE : {key:"title", value:""},
	CLOSE : {key:"close", value:false},
	IFRAME : {key:"iframe", value:(YAHOO.env.ua.ie && YAHOO.env.ua.ie <= 6) ? true : false},
	MINDATE : {key:"mindate", value:null},
	MAXDATE : {key:"maxdate", value:null},
	MULTI_SELECT : {key:"multi_select", value:false},
	START_WEEKDAY : {key:"start_weekday", value:0},
	SHOW_WEEKDAYS : {key:"show_weekdays", value:true},
	SHOW_WEEK_HEADER : {key:"show_week_header", value:false},
	SHOW_WEEK_FOOTER : {key:"show_week_footer", value:false},
	HIDE_BLANK_WEEKS : {key:"hide_blank_weeks", value:false},
	NAV_ARROW_LEFT: {key:"nav_arrow_left", value:null} ,
	NAV_ARROW_RIGHT : {key:"nav_arrow_right", value:null} ,
	MONTHS_SHORT : {key:"months_short", value:["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]},
	MONTHS_LONG: {key:"months_long", value:["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]},
	WEEKDAYS_1CHAR: {key:"weekdays_1char", value:["S", "M", "T", "W", "T", "F", "S"]},
	WEEKDAYS_SHORT: {key:"weekdays_short", value:["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]},
	WEEKDAYS_MEDIUM: {key:"weekdays_medium", value:["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]},
	WEEKDAYS_LONG: {key:"weekdays_long", value:["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]},
	LOCALE_MONTHS:{key:"locale_months", value:"long"},
	LOCALE_WEEKDAYS:{key:"locale_weekdays", value:"short"},
	DATE_DELIMITER:{key:"date_delimiter", value:","},
	DATE_FIELD_DELIMITER:{key:"date_field_delimiter", value:"/"},
	DATE_RANGE_DELIMITER:{key:"date_range_delimiter", value:"-"},
	MY_MONTH_POSITION:{key:"my_month_position", value:1},
	MY_YEAR_POSITION:{key:"my_year_position", value:2},
	MD_MONTH_POSITION:{key:"md_month_position", value:1},
	MD_DAY_POSITION:{key:"md_day_position", value:2},
	MDY_MONTH_POSITION:{key:"mdy_month_position", value:1},
	MDY_DAY_POSITION:{key:"mdy_day_position", value:2},
	MDY_YEAR_POSITION:{key:"mdy_year_position", value:3},
	MY_LABEL_MONTH_POSITION:{key:"my_label_month_position", value:1},
	MY_LABEL_YEAR_POSITION:{key:"my_label_year_position", value:2},
	MY_LABEL_MONTH_SUFFIX:{key:"my_label_month_suffix", value:" "},
	MY_LABEL_YEAR_SUFFIX:{key:"my_label_year_suffix", value:""}
};

YAHOO.widget.Calendar._EVENT_TYPES = {
	BEFORE_SELECT : "beforeSelect",
	SELECT : "select",
	BEFORE_DESELECT : "beforeDeselect",
	DESELECT : "deselect",
	CHANGE_PAGE : "changePage",
	BEFORE_RENDER : "beforeRender",
	RENDER : "render",
	RESET : "reset",
	CLEAR : "clear"
};

YAHOO.widget.Calendar._STYLES = {
	CSS_ROW_HEADER: "calrowhead",
	CSS_ROW_FOOTER: "calrowfoot",
	CSS_CELL : "calcell",
	CSS_CELL_SELECTOR : "selector",
	CSS_CELL_SELECTED : "selected",
	CSS_CELL_SELECTABLE : "selectable",
	CSS_CELL_RESTRICTED : "restricted",
	CSS_CELL_TODAY : "today",
	CSS_CELL_OOM : "oom",
	CSS_CELL_OOB : "previous",
	CSS_HEADER : "calheader",
	CSS_HEADER_TEXT : "calhead",
	CSS_BODY : "calbody",
	CSS_WEEKDAY_CELL : "calweekdaycell",
	CSS_WEEKDAY_ROW : "calweekdayrow",
	CSS_FOOTER : "calfoot",
	CSS_CALENDAR : "yui-calendar",
	CSS_SINGLE : "single",
	CSS_CONTAINER : "yui-calcontainer",
	CSS_NAV_LEFT : "calnavleft",
	CSS_NAV_RIGHT : "calnavright",
	CSS_CLOSE : "calclose",
	CSS_CELL_TOP : "calcelltop",
	CSS_CELL_LEFT : "calcellleft",
	CSS_CELL_RIGHT : "calcellright",
	CSS_CELL_BOTTOM : "calcellbottom",
	CSS_CELL_HOVER : "calcellhover",
	CSS_CELL_HIGHLIGHT1 : "highlight1",
	CSS_CELL_HIGHLIGHT2 : "highlight2",
	CSS_CELL_HIGHLIGHT3 : "highlight3",
	CSS_CELL_HIGHLIGHT4 : "highlight4"
};

YAHOO.widget.Calendar.prototype = {
	Config : null,
	parent : null,
	index : -1,
	cells : null,
	cellDates : null,
	id : null,
	oDomContainer : null,
	today : null,
	renderStack : null,
	_renderStack : null,
	_selectedDates : null,
	domEventMap : null
};

YAHOO.widget.Calendar.prototype.init = function(id, containerId, config) {
	this.initEvents();
	this.today = new Date();
	YAHOO.widget.DateMath.clearTime(this.today);

	this.id = id;
	this.oDomContainer = document.getElementById(containerId);

	this.cfg = new YAHOO.util.Config(this);

	this.Options = {};

	this.Locale = {};

	this.initStyles();

	YAHOO.util.Dom.addClass(this.oDomContainer, this.Style.CSS_CONTAINER);
	YAHOO.util.Dom.addClass(this.oDomContainer, this.Style.CSS_SINGLE);

	this.cellDates = [];
	this.cells = [];
	this.renderStack = [];
	this._renderStack = [];

	this.setupConfig();

	if (config) {
		this.cfg.applyConfig(config, true);
	}

	this.cfg.fireQueue();
};

YAHOO.widget.Calendar.prototype.configIframe = function(type, args, obj) {
	var useIframe = args[0];

	if (!this.parent) {
		if (YAHOO.util.Dom.inDocument(this.oDomContainer)) {
			if (useIframe) {
				var pos = YAHOO.util.Dom.getStyle(this.oDomContainer, "position");

				if (pos == "absolute" || pos == "relative") {
					if (!YAHOO.util.Dom.inDocument(this.iframe)) {
						this.iframe = document.createElement("iframe");
						this.iframe.src = "javascript:false;";

						YAHOO.util.Dom.setStyle(this.iframe, "opacity", "0");

						if (YAHOO.env.ua.ie && YAHOO.env.ua.ie <= 6) {
							YAHOO.util.Dom.addClass(this.iframe, "fixedsize");
						}

						this.oDomContainer.insertBefore(this.iframe, this.oDomContainer.firstChild);
					}
				}
			} else {
				if (this.iframe) {
					if (this.iframe.parentNode) {
						this.iframe.parentNode.removeChild(this.iframe);
					}
					this.iframe = null;
				}
			}
		}
	}
};

YAHOO.widget.Calendar.prototype.configTitle = function(type, args, obj) {
	var title = args[0];
	var close = this.cfg.getProperty(YAHOO.widget.Calendar._DEFAULT_CONFIG.CLOSE.key);

	var titleDiv;

	if (title && title !== "") {
		titleDiv = YAHOO.util.Dom.getElementsByClassName(YAHOO.widget.CalendarGroup.CSS_2UPTITLE, "div", this.oDomContainer)[0] || document.createElement("div");
		titleDiv.className = YAHOO.widget.CalendarGroup.CSS_2UPTITLE;
		titleDiv.innerHTML = title;
		this.oDomContainer.insertBefore(titleDiv, this.oDomContainer.firstChild);
		YAHOO.util.Dom.addClass(this.oDomContainer, "withtitle");
	} else {
		titleDiv = YAHOO.util.Dom.getElementsByClassName(YAHOO.widget.CalendarGroup.CSS_2UPTITLE, "div", this.oDomContainer)[0] || null;

		if (titleDiv) {
			YAHOO.util.Event.purgeElement(titleDiv);
			this.oDomContainer.removeChild(titleDiv);
		}
		if (! close) {
			YAHOO.util.Dom.removeClass(this.oDomContainer, "withtitle");
		}
	}
};

YAHOO.widget.Calendar.prototype.configClose = function(type, args, obj) {
	var close = args[0];
	var title = this.cfg.getProperty(YAHOO.widget.Calendar._DEFAULT_CONFIG.TITLE.key);

	var DEPR_CLOSE_PATH = "us/my/bn/x_d.gif";

	var linkClose;

	if (close === true) {
		linkClose = YAHOO.util.Dom.getElementsByClassName("link-close", "a", this.oDomContainer)[0] || document.createElement("a");
		linkClose.href = "#";
		linkClose.className = "link-close";
		YAHOO.util.Event.addListener(linkClose, "click", function(e, cal) {cal.hide(); YAHOO.util.Event.preventDefault(e); }, this);

		if (YAHOO.widget.Calendar.IMG_ROOT !== null) {
			var imgClose = document.createElement("img");
			imgClose.src = YAHOO.widget.Calendar.IMG_ROOT + DEPR_CLOSE_PATH;
			imgClose.className = YAHOO.widget.CalendarGroup.CSS_2UPCLOSE;
			linkClose.appendChild(imgClose);
		} else {
			linkClose.innerHTML = '<span class="' + YAHOO.widget.CalendarGroup.CSS_2UPCLOSE + ' ' + this.Style.CSS_CLOSE + '"></span>';
		}

		this.oDomContainer.appendChild(linkClose);
		YAHOO.util.Dom.addClass(this.oDomContainer, "withtitle");
	} else {
		linkClose = YAHOO.util.Dom.getElementsByClassName("link-close", "a", this.oDomContainer)[0] || null;
		if (linkClose) {
			YAHOO.util.Event.purgeElement(linkClose);
			this.oDomContainer.removeChild(linkClose);
		}
		if (! title || title === "") {
			YAHOO.util.Dom.removeClass(this.oDomContainer, "withtitle");
		}
	}
};

YAHOO.widget.Calendar.prototype.initEvents = function() {
	var defEvents = YAHOO.widget.Calendar._EVENT_TYPES;
	this.beforeSelectEvent = new YAHOO.util.CustomEvent(defEvents.BEFORE_SELECT);
	this.selectEvent = new YAHOO.util.CustomEvent(defEvents.SELECT);
	this.beforeDeselectEvent = new YAHOO.util.CustomEvent(defEvents.BEFORE_DESELECT);
	this.deselectEvent = new YAHOO.util.CustomEvent(defEvents.DESELECT);
	this.changePageEvent = new YAHOO.util.CustomEvent(defEvents.CHANGE_PAGE);
	this.beforeRenderEvent = new YAHOO.util.CustomEvent(defEvents.BEFORE_RENDER);
	this.renderEvent = new YAHOO.util.CustomEvent(defEvents.RENDER);
	this.resetEvent = new YAHOO.util.CustomEvent(defEvents.RESET);
	this.clearEvent = new YAHOO.util.CustomEvent(defEvents.CLEAR);
	this.beforeSelectEvent.subscribe(this.onBeforeSelect, this, true);
	this.selectEvent.subscribe(this.onSelect, this, true);
	this.beforeDeselectEvent.subscribe(this.onBeforeDeselect, this, true);
	this.deselectEvent.subscribe(this.onDeselect, this, true);
	this.changePageEvent.subscribe(this.onChangePage, this, true);
	this.renderEvent.subscribe(this.onRender, this, true);
	this.resetEvent.subscribe(this.onReset, this, true);
	this.clearEvent.subscribe(this.onClear, this, true);
};

YAHOO.widget.Calendar.prototype.doSelectCell = function(e, cal) {
	var cell,index,d,date;

	var target = YAHOO.util.Event.getTarget(e);
	var tagName = target.tagName.toLowerCase();
	var defSelector = false;

	while (tagName != "td" && ! YAHOO.util.Dom.hasClass(target, cal.Style.CSS_CELL_SELECTABLE)) {
		if (!defSelector && tagName == "a" && YAHOO.util.Dom.hasClass(target, cal.Style.CSS_CELL_SELECTOR)) {
			defSelector = true;
		}

		target = target.parentNode;
		tagName = target.tagName.toLowerCase();
		if (tagName == "html") {
			return;
		}
	}

	if (defSelector) {
		YAHOO.util.Event.preventDefault(e);
	}

	cell = target;

	if (YAHOO.util.Dom.hasClass(cell, cal.Style.CSS_CELL_SELECTABLE)) {
		index = cell.id.split("cell")[1];
		d = cal.cellDates[index];
		date = new Date(d[0],d[1]-1,d[2]);

		var link;

		if (cal.Options.MULTI_SELECT) {
			link = cell.getElementsByTagName("a")[0];
			if (link) {
				link.blur();
			}

			var cellDate = cal.cellDates[index];
			var cellDateIndex = cal._indexOfSelectedFieldArray(cellDate);

			if (cellDateIndex > -1) {
				cal.deselectCell(index);
			} else {
				cal.selectCell(index);
			}
		} else {
			link = cell.getElementsByTagName("a")[0];
			if (link) {
				link.blur();
			}
			cal.selectCell(index);
		}
	}
};

YAHOO.widget.Calendar.prototype.doCellMouseOver = function(e, cal) {
	var target;
	if (e) {
		target = YAHOO.util.Event.getTarget(e);
	} else {
		target = this;
	}

	while (target.tagName.toLowerCase() != "td") {
		target = target.parentNode;
		if (target.tagName.toLowerCase() == "html") {
			return;
		}
	}

	if (YAHOO.util.Dom.hasClass(target, cal.Style.CSS_CELL_SELECTABLE)) {
		YAHOO.util.Dom.addClass(target, cal.Style.CSS_CELL_HOVER);
	}
};

YAHOO.widget.Calendar.prototype.doCellMouseOut = function(e, cal) {
	var target;
	if (e) {
		target = YAHOO.util.Event.getTarget(e);
	} else {
		target = this;
	}

	while (target.tagName.toLowerCase() != "td") {
		target = target.parentNode;
		if (target.tagName.toLowerCase() == "html") {
			return;
		}
	}

	if (YAHOO.util.Dom.hasClass(target, cal.Style.CSS_CELL_SELECTABLE)) {
		YAHOO.util.Dom.removeClass(target, cal.Style.CSS_CELL_HOVER);
	}
};

YAHOO.widget.Calendar.prototype.setupConfig = function() {
	var defCfg = YAHOO.widget.Calendar._DEFAULT_CONFIG;
	this.cfg.addProperty(defCfg.PAGEDATE.key, { value:new Date(), handler:this.configPageDate } );
	this.cfg.addProperty(defCfg.SELECTED.key, { value:[], handler:this.configSelected } );
	this.cfg.addProperty(defCfg.TITLE.key, { value:defCfg.TITLE.value, handler:this.configTitle } );
	this.cfg.addProperty(defCfg.CLOSE.key, { value:defCfg.CLOSE.value, handler:this.configClose } );
	this.cfg.addProperty(defCfg.IFRAME.key, { value:defCfg.IFRAME.value, handler:this.configIframe, validator:this.cfg.checkBoolean } );
	this.cfg.addProperty(defCfg.MINDATE.key, { value:defCfg.MINDATE.value, handler:this.configMinDate } );
	this.cfg.addProperty(defCfg.MAXDATE.key, { value:defCfg.MAXDATE.value, handler:this.configMaxDate } );
	this.cfg.addProperty(defCfg.MULTI_SELECT.key, { value:defCfg.MULTI_SELECT.value, handler:this.configOptions, validator:this.cfg.checkBoolean } );
	this.cfg.addProperty(defCfg.START_WEEKDAY.key, { value:defCfg.START_WEEKDAY.value, handler:this.configOptions, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.SHOW_WEEKDAYS.key, { value:defCfg.SHOW_WEEKDAYS.value, handler:this.configOptions, validator:this.cfg.checkBoolean } );
	this.cfg.addProperty(defCfg.SHOW_WEEK_HEADER.key, { value:defCfg.SHOW_WEEK_HEADER.value, handler:this.configOptions, validator:this.cfg.checkBoolean } );
	this.cfg.addProperty(defCfg.SHOW_WEEK_FOOTER.key, { value:defCfg.SHOW_WEEK_FOOTER.value, handler:this.configOptions, validator:this.cfg.checkBoolean } );
	this.cfg.addProperty(defCfg.HIDE_BLANK_WEEKS.key, { value:defCfg.HIDE_BLANK_WEEKS.value, handler:this.configOptions, validator:this.cfg.checkBoolean } );
	this.cfg.addProperty(defCfg.NAV_ARROW_LEFT.key, { value:defCfg.NAV_ARROW_LEFT.value, handler:this.configOptions } );
	this.cfg.addProperty(defCfg.NAV_ARROW_RIGHT.key, { value:defCfg.NAV_ARROW_RIGHT.value, handler:this.configOptions } );
	this.cfg.addProperty(defCfg.MONTHS_SHORT.key, { value:defCfg.MONTHS_SHORT.value, handler:this.configLocale } );
	this.cfg.addProperty(defCfg.MONTHS_LONG.key, { value:defCfg.MONTHS_LONG.value, handler:this.configLocale } );
	this.cfg.addProperty(defCfg.WEEKDAYS_1CHAR.key, { value:defCfg.WEEKDAYS_1CHAR.value, handler:this.configLocale } );
	this.cfg.addProperty(defCfg.WEEKDAYS_SHORT.key, { value:defCfg.WEEKDAYS_SHORT.value, handler:this.configLocale } );
	this.cfg.addProperty(defCfg.WEEKDAYS_MEDIUM.key, { value:defCfg.WEEKDAYS_MEDIUM.value, handler:this.configLocale } );
	this.cfg.addProperty(defCfg.WEEKDAYS_LONG.key, { value:defCfg.WEEKDAYS_LONG.value, handler:this.configLocale } );

	var refreshLocale = function() {
		this.cfg.refireEvent(defCfg.LOCALE_MONTHS.key);
		this.cfg.refireEvent(defCfg.LOCALE_WEEKDAYS.key);
	};

	this.cfg.subscribeToConfigEvent(defCfg.START_WEEKDAY.key, refreshLocale, this, true);
	this.cfg.subscribeToConfigEvent(defCfg.MONTHS_SHORT.key, refreshLocale, this, true);
	this.cfg.subscribeToConfigEvent(defCfg.MONTHS_LONG.key, refreshLocale, this, true);
	this.cfg.subscribeToConfigEvent(defCfg.WEEKDAYS_1CHAR.key, refreshLocale, this, true);
	this.cfg.subscribeToConfigEvent(defCfg.WEEKDAYS_SHORT.key, refreshLocale, this, true);
	this.cfg.subscribeToConfigEvent(defCfg.WEEKDAYS_MEDIUM.key, refreshLocale, this, true);
	this.cfg.subscribeToConfigEvent(defCfg.WEEKDAYS_LONG.key, refreshLocale, this, true);
	this.cfg.addProperty(defCfg.LOCALE_MONTHS.key, { value:defCfg.LOCALE_MONTHS.value, handler:this.configLocaleValues } );
	this.cfg.addProperty(defCfg.LOCALE_WEEKDAYS.key, { value:defCfg.LOCALE_WEEKDAYS.value, handler:this.configLocaleValues } );
	this.cfg.addProperty(defCfg.DATE_DELIMITER.key, { value:defCfg.DATE_DELIMITER.value, handler:this.configLocale } );
	this.cfg.addProperty(defCfg.DATE_FIELD_DELIMITER.key, { value:defCfg.DATE_FIELD_DELIMITER.value, handler:this.configLocale } );
	this.cfg.addProperty(defCfg.DATE_RANGE_DELIMITER.key, { value:defCfg.DATE_RANGE_DELIMITER.value, handler:this.configLocale } );
	this.cfg.addProperty(defCfg.MY_MONTH_POSITION.key, { value:defCfg.MY_MONTH_POSITION.value, handler:this.configLocale, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MY_YEAR_POSITION.key, { value:defCfg.MY_YEAR_POSITION.value, handler:this.configLocale, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MD_MONTH_POSITION.key, { value:defCfg.MD_MONTH_POSITION.value, handler:this.configLocale, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MD_DAY_POSITION.key, { value:defCfg.MD_DAY_POSITION.value, handler:this.configLocale, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MDY_MONTH_POSITION.key, { value:defCfg.MDY_MONTH_POSITION.value, handler:this.configLocale, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MDY_DAY_POSITION.key, { value:defCfg.MDY_DAY_POSITION.value, handler:this.configLocale, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MDY_YEAR_POSITION.key, { value:defCfg.MDY_YEAR_POSITION.value, handler:this.configLocale, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MY_LABEL_MONTH_POSITION.key, { value:defCfg.MY_LABEL_MONTH_POSITION.value, handler:this.configLocale, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MY_LABEL_YEAR_POSITION.key, { value:defCfg.MY_LABEL_YEAR_POSITION.value, handler:this.configLocale, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MY_LABEL_MONTH_SUFFIX.key, { value:defCfg.MY_LABEL_MONTH_SUFFIX.value, handler:this.configLocale } );
	this.cfg.addProperty(defCfg.MY_LABEL_YEAR_SUFFIX.key, { value:defCfg.MY_LABEL_YEAR_SUFFIX.value, handler:this.configLocale } );
};

YAHOO.widget.Calendar.prototype.configPageDate = function(type, args, obj) {
	this.cfg.setProperty(YAHOO.widget.Calendar._DEFAULT_CONFIG.PAGEDATE.key, this._parsePageDate(args[0]), true);
};

YAHOO.widget.Calendar.prototype.configMinDate = function(type, args, obj) {
	var val = args[0];
	if (YAHOO.lang.isString(val)) {
		val = this._parseDate(val);
		this.cfg.setProperty(YAHOO.widget.Calendar._DEFAULT_CONFIG.MINDATE.key, new Date(val[0],(val[1]-1),val[2]));
	}
};

YAHOO.widget.Calendar.prototype.configMaxDate = function(type, args, obj) {
	var val = args[0];
	if (YAHOO.lang.isString(val)) {
		val = this._parseDate(val);
		this.cfg.setProperty(YAHOO.widget.Calendar._DEFAULT_CONFIG.MAXDATE.key, new Date(val[0],(val[1]-1),val[2]));
	}
};

YAHOO.widget.Calendar.prototype.configSelected = function(type, args, obj) {
	var selected = args[0];
	var cfgSelected = YAHOO.widget.Calendar._DEFAULT_CONFIG.SELECTED.key;

	if (selected) {
		if (YAHOO.lang.isString(selected)) {
			this.cfg.setProperty(cfgSelected, this._parseDates(selected), true);
		}
	}
	if (! this._selectedDates) {
		this._selectedDates = this.cfg.getProperty(cfgSelected);
	}
};

YAHOO.widget.Calendar.prototype.configOptions = function(type, args, obj) {
	this.Options[type.toUpperCase()] = args[0];
};

YAHOO.widget.Calendar.prototype.configLocale = function(type, args, obj) {
	var defCfg = YAHOO.widget.Calendar._DEFAULT_CONFIG;
	this.Locale[type.toUpperCase()] = args[0];

	this.cfg.refireEvent(defCfg.LOCALE_MONTHS.key);
	this.cfg.refireEvent(defCfg.LOCALE_WEEKDAYS.key);
};

YAHOO.widget.Calendar.prototype.configLocaleValues = function(type, args, obj) {
	var defCfg = YAHOO.widget.Calendar._DEFAULT_CONFIG;

	type = type.toLowerCase();
	var val = args[0];

	switch (type) {
		case defCfg.LOCALE_MONTHS.key:
			switch (val) {
				case YAHOO.widget.Calendar.SHORT:
					this.Locale.LOCALE_MONTHS = this.cfg.getProperty(defCfg.MONTHS_SHORT.key).concat();
					break;
				case YAHOO.widget.Calendar.LONG:
					this.Locale.LOCALE_MONTHS = this.cfg.getProperty(defCfg.MONTHS_LONG.key).concat();
					break;
			}
			break;
		case defCfg.LOCALE_WEEKDAYS.key:
			switch (val) {
				case YAHOO.widget.Calendar.ONE_CHAR:
					this.Locale.LOCALE_WEEKDAYS = this.cfg.getProperty(defCfg.WEEKDAYS_1CHAR.key).concat();
					break;
				case YAHOO.widget.Calendar.SHORT:
					this.Locale.LOCALE_WEEKDAYS = this.cfg.getProperty(defCfg.WEEKDAYS_SHORT.key).concat();
					break;
				case YAHOO.widget.Calendar.MEDIUM:
					this.Locale.LOCALE_WEEKDAYS = this.cfg.getProperty(defCfg.WEEKDAYS_MEDIUM.key).concat();
					break;
				case YAHOO.widget.Calendar.LONG:
					this.Locale.LOCALE_WEEKDAYS = this.cfg.getProperty(defCfg.WEEKDAYS_LONG.key).concat();
					break;
			}

			var START_WEEKDAY = this.cfg.getProperty(defCfg.START_WEEKDAY.key);

			if (START_WEEKDAY > 0) {
				for (var w=0;w<START_WEEKDAY;++w) {
					this.Locale.LOCALE_WEEKDAYS.push(this.Locale.LOCALE_WEEKDAYS.shift());
				}
			}
			break;
	}
};

YAHOO.widget.Calendar.prototype.initStyles = function() {
	var defStyle = YAHOO.widget.Calendar._STYLES;

	this.Style = {
		CSS_ROW_HEADER: defStyle.CSS_ROW_HEADER,
		CSS_ROW_FOOTER: defStyle.CSS_ROW_FOOTER,
		CSS_CELL : defStyle.CSS_CELL,
		CSS_CELL_SELECTOR : defStyle.CSS_CELL_SELECTOR,
		CSS_CELL_SELECTED : defStyle.CSS_CELL_SELECTED,
		CSS_CELL_SELECTABLE : defStyle.CSS_CELL_SELECTABLE,
		CSS_CELL_RESTRICTED : defStyle.CSS_CELL_RESTRICTED,
		CSS_CELL_TODAY : defStyle.CSS_CELL_TODAY,
		CSS_CELL_OOM : defStyle.CSS_CELL_OOM,
		CSS_CELL_OOB : defStyle.CSS_CELL_OOB,
		CSS_HEADER : defStyle.CSS_HEADER,
		CSS_HEADER_TEXT : defStyle.CSS_HEADER_TEXT,
		CSS_BODY : defStyle.CSS_BODY,
		CSS_WEEKDAY_CELL : defStyle.CSS_WEEKDAY_CELL,
		CSS_WEEKDAY_ROW : defStyle.CSS_WEEKDAY_ROW,
		CSS_FOOTER : defStyle.CSS_FOOTER,
		CSS_CALENDAR : defStyle.CSS_CALENDAR,
		CSS_SINGLE : defStyle.CSS_SINGLE,
		CSS_CONTAINER : defStyle.CSS_CONTAINER,
		CSS_NAV_LEFT : defStyle.CSS_NAV_LEFT,
		CSS_NAV_RIGHT : defStyle.CSS_NAV_RIGHT,
		CSS_CLOSE : defStyle.CSS_CLOSE,
		CSS_CELL_TOP : defStyle.CSS_CELL_TOP,
		CSS_CELL_LEFT : defStyle.CSS_CELL_LEFT,
		CSS_CELL_RIGHT : defStyle.CSS_CELL_RIGHT,
		CSS_CELL_BOTTOM : defStyle.CSS_CELL_BOTTOM,
		CSS_CELL_HOVER : defStyle.CSS_CELL_HOVER,
		CSS_CELL_HIGHLIGHT1 : defStyle.CSS_CELL_HIGHLIGHT1,
		CSS_CELL_HIGHLIGHT2 : defStyle.CSS_CELL_HIGHLIGHT2,
		CSS_CELL_HIGHLIGHT3 : defStyle.CSS_CELL_HIGHLIGHT3,
		CSS_CELL_HIGHLIGHT4 : defStyle.CSS_CELL_HIGHLIGHT4
	};
};

YAHOO.widget.Calendar.prototype.buildMonthLabel = function() {
	var pageDate = this.cfg.getProperty(YAHOO.widget.Calendar._DEFAULT_CONFIG.PAGEDATE.key);

	var monthLabel = this.Locale.LOCALE_MONTHS[pageDate.getMonth()] + this.Locale.MY_LABEL_MONTH_SUFFIX;
	var yearLabel = pageDate.getFullYear() + this.Locale.MY_LABEL_YEAR_SUFFIX;

	if (this.Locale.MY_LABEL_MONTH_POSITION == 2 || this.Locale.MY_LABEL_YEAR_POSITION == 1) {
		return yearLabel + monthLabel;
	} else {
		return monthLabel + yearLabel;
	}
};

YAHOO.widget.Calendar.prototype.buildDayLabel = function(workingDate) {
	return workingDate.getDate();
};

YAHOO.widget.Calendar.prototype.renderHeader = function(html) {
	var colSpan = 7;

	var DEPR_NAV_LEFT = "us/tr/callt.gif";
	var DEPR_NAV_RIGHT = "us/tr/calrt.gif";
	var defCfg = YAHOO.widget.Calendar._DEFAULT_CONFIG;

	if (this.cfg.getProperty(defCfg.SHOW_WEEK_HEADER.key)) {
		colSpan += 1;
	}

	if (this.cfg.getProperty(defCfg.SHOW_WEEK_FOOTER.key)) {
		colSpan += 1;
	}

	html[html.length] = "<thead>";
	html[html.length] =		"<tr>";
	html[html.length] =			'<th colspan="' + colSpan + '" class="' + this.Style.CSS_HEADER_TEXT + '">';
	html[html.length] =				'<div class="' + this.Style.CSS_HEADER + '">';

	var renderLeft, renderRight = false;

	if (this.parent) {
		if (this.index === 0) {
			renderLeft = true;
		}
		if (this.index == (this.parent.cfg.getProperty("pages") -1)) {
			renderRight = true;
		}
	} else {
		renderLeft = true;
		renderRight = true;
	}

	var cal = this.parent || this;

	if (renderLeft) {
		var leftArrow = this.cfg.getProperty(defCfg.NAV_ARROW_LEFT.key);

		if (leftArrow === null && YAHOO.widget.Calendar.IMG_ROOT !== null) {
			leftArrow = YAHOO.widget.Calendar.IMG_ROOT + DEPR_NAV_LEFT;
		}
		var leftStyle = (leftArrow === null) ? "" : ' style="background-image:url(' + leftArrow + ')"';
		html[html.length] = '<a class="' + this.Style.CSS_NAV_LEFT + '"' + leftStyle + ' >&#160;</a>';
	}

	html[html.length] = this.buildMonthLabel();

	if (renderRight) {
		var rightArrow = this.cfg.getProperty(defCfg.NAV_ARROW_RIGHT.key);
		if (rightArrow === null && YAHOO.widget.Calendar.IMG_ROOT !== null) {
			rightArrow = YAHOO.widget.Calendar.IMG_ROOT + DEPR_NAV_RIGHT;
		}
		var rightStyle = (rightArrow === null) ? "" : ' style="background-image:url(' + rightArrow + ')"';
		html[html.length] = '<a class="' + this.Style.CSS_NAV_RIGHT + '"' + rightStyle + ' >&#160;</a>';
	}

	html[html.length] =	'</div>\n</th>\n</tr>';

	if (this.cfg.getProperty(defCfg.SHOW_WEEKDAYS.key)) {
		html = this.buildWeekdays(html);
	}

	html[html.length] = '</thead>';

	return html;
};

YAHOO.widget.Calendar.prototype.buildWeekdays = function(html) {
	var defCfg = YAHOO.widget.Calendar._DEFAULT_CONFIG;

	html[html.length] = '<tr class="' + this.Style.CSS_WEEKDAY_ROW + '">';

	if (this.cfg.getProperty(defCfg.SHOW_WEEK_HEADER.key)) {
		html[html.length] = '<th>&#160;</th>';
	}

	for(var i=0;i<this.Locale.LOCALE_WEEKDAYS.length;++i) {
		html[html.length] = '<th class="calweekdaycell">' + this.Locale.LOCALE_WEEKDAYS[i] + '</th>';
	}

	if (this.cfg.getProperty(defCfg.SHOW_WEEK_FOOTER.key)) {
		html[html.length] = '<th>&#160;</th>';
	}

	html[html.length] = '</tr>';

	return html;
};

YAHOO.widget.Calendar.prototype.renderBody = function(workingDate, html) {
	var defCfg = YAHOO.widget.Calendar._DEFAULT_CONFIG;

	var startDay = this.cfg.getProperty(defCfg.START_WEEKDAY.key);

	this.preMonthDays = workingDate.getDay();
	if (startDay > 0) {
		this.preMonthDays -= startDay;
	}
	if (this.preMonthDays < 0) {
		this.preMonthDays += 7;
	}

	this.monthDays = YAHOO.widget.DateMath.findMonthEnd(workingDate).getDate();
	this.postMonthDays = YAHOO.widget.Calendar.DISPLAY_DAYS-this.preMonthDays-this.monthDays;

	workingDate = YAHOO.widget.DateMath.subtract(workingDate, YAHOO.widget.DateMath.DAY, this.preMonthDays);

	var weekNum,weekClass;
	var weekPrefix = "w";
	var cellPrefix = "_cell";
	var workingDayPrefix = "wd";
	var dayPrefix = "d";

	var cellRenderers;
	var renderer;

	var todayYear = this.today.getFullYear();
	var todayMonth = this.today.getMonth();
	var todayDate = this.today.getDate();

	var useDate = this.cfg.getProperty(defCfg.PAGEDATE.key);
	var hideBlankWeeks = this.cfg.getProperty(defCfg.HIDE_BLANK_WEEKS.key);
	var showWeekFooter = this.cfg.getProperty(defCfg.SHOW_WEEK_FOOTER.key);
	var showWeekHeader = this.cfg.getProperty(defCfg.SHOW_WEEK_HEADER.key);
	var mindate = this.cfg.getProperty(defCfg.MINDATE.key);
	var maxdate = this.cfg.getProperty(defCfg.MAXDATE.key);

	if (mindate) {
		mindate = YAHOO.widget.DateMath.clearTime(mindate);
	}
	if (maxdate) {
		maxdate = YAHOO.widget.DateMath.clearTime(maxdate);
	}

	html[html.length] = '<tbody class="m' + (useDate.getMonth()+1) + ' ' + this.Style.CSS_BODY + '">';

	var i = 0;

	var tempDiv = document.createElement("div");
	var cell = document.createElement("td");
	tempDiv.appendChild(cell);

	var jan1 = new Date(useDate.getFullYear(),0,1);

	var cal = this.parent || this;

	for (var r=0;r<6;r++) {
		weekNum = YAHOO.widget.DateMath.getWeekNumber(workingDate, useDate.getFullYear(), startDay);
		weekClass = weekPrefix + weekNum;

		if (r !== 0 && hideBlankWeeks === true && workingDate.getMonth() != useDate.getMonth()) {
			break;
		} else {
			html[html.length] = '<tr class="' + weekClass + '">';

			if (showWeekHeader) { html = this.renderRowHeader(weekNum, html); }

			for (var d=0;d<7;d++){
				cellRenderers = [];
				renderer = null;

				this.clearElement(cell);
				cell.className = this.Style.CSS_CELL;
				cell.id = this.id + cellPrefix + i;

				if (workingDate.getDate()		== todayDate &&
					workingDate.getMonth()		== todayMonth &&
					workingDate.getFullYear()	== todayYear) {
					cellRenderers[cellRenderers.length]=cal.renderCellStyleToday;
				}

				var workingArray = [workingDate.getFullYear(),workingDate.getMonth()+1,workingDate.getDate()];
				this.cellDates[this.cellDates.length] = workingArray;

				if (workingDate.getMonth() != useDate.getMonth()) {
					cellRenderers[cellRenderers.length]=cal.renderCellNotThisMonth;
				} else {
					YAHOO.util.Dom.addClass(cell, workingDayPrefix + workingDate.getDay());
					YAHOO.util.Dom.addClass(cell, dayPrefix + workingDate.getDate());

					for (var s=0;s<this.renderStack.length;++s) {
						var rArray = this.renderStack[s];
						var type = rArray[0];

						var month;
						var day;
						var year;

						switch (type) {
							case YAHOO.widget.Calendar.DATE:
								month = rArray[1][1];
								day = rArray[1][2];
								year = rArray[1][0];

								if (workingDate.getMonth()+1 == month && workingDate.getDate() == day && workingDate.getFullYear() == year) {
									renderer = rArray[2];
									this.renderStack.splice(s,1);
								}
								break;
							case YAHOO.widget.Calendar.MONTH_DAY:
								month = rArray[1][0];
								day = rArray[1][1];

								if (workingDate.getMonth()+1 == month && workingDate.getDate() == day) {
									renderer = rArray[2];
									this.renderStack.splice(s,1);
								}
								break;
							case YAHOO.widget.Calendar.RANGE:
								var date1 = rArray[1][0];
								var date2 = rArray[1][1];

								var d1month = date1[1];
								var d1day = date1[2];
								var d1year = date1[0];

								var d1 = new Date(d1year, d1month-1, d1day);

								var d2month = date2[1];
								var d2day = date2[2];
								var d2year = date2[0];

								var d2 = new Date(d2year, d2month-1, d2day);

								if (workingDate.getTime() >= d1.getTime() && workingDate.getTime() <= d2.getTime()) {
									renderer = rArray[2];

									if (workingDate.getTime()==d2.getTime()) {
										this.renderStack.splice(s,1);
									}
								}
								break;
							case YAHOO.widget.Calendar.WEEKDAY:

								var weekday = rArray[1][0];
								if (workingDate.getDay()+1 == weekday) {
									renderer = rArray[2];
								}
								break;
							case YAHOO.widget.Calendar.MONTH:

								month = rArray[1][0];
								if (workingDate.getMonth()+1 == month) {
									renderer = rArray[2];
								}
								break;
						}

						if (renderer) {
							cellRenderers[cellRenderers.length]=renderer;
						}
					}
				}

				if (this._indexOfSelectedFieldArray(workingArray) > -1) {
					cellRenderers[cellRenderers.length]=cal.renderCellStyleSelected;
				}

				if ((mindate && (workingDate.getTime() < mindate.getTime())) ||
					(maxdate && (workingDate.getTime() > maxdate.getTime()))
				) {
					cellRenderers[cellRenderers.length]=cal.renderOutOfBoundsDate;
				} else {
					cellRenderers[cellRenderers.length]=cal.styleCellDefault;
					cellRenderers[cellRenderers.length]=cal.renderCellDefault;
				}

				for (var x=0; x < cellRenderers.length; ++x) {
					if (cellRenderers[x].call(cal, workingDate, cell) == YAHOO.widget.Calendar.STOP_RENDER) {
						break;
					}
				}

				workingDate.setTime(workingDate.getTime() + YAHOO.widget.DateMath.ONE_DAY_MS);

				if (i >= 0 && i <= 6) {
					YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_TOP);
				}
				if ((i % 7) === 0) {
					YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_LEFT);
				}
				if (((i+1) % 7) === 0) {
					YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_RIGHT);
				}

				var postDays = this.postMonthDays;
				if (hideBlankWeeks && postDays >= 7) {
					var blankWeeks = Math.floor(postDays/7);
					for (var p=0;p<blankWeeks;++p) {
						postDays -= 7;
					}
				}

				if (i >= ((this.preMonthDays+postDays+this.monthDays)-7)) {
					YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_BOTTOM);
				}

				html[html.length] = tempDiv.innerHTML;
				i++;
			}

			if (showWeekFooter) { html = this.renderRowFooter(weekNum, html); }

			html[html.length] = '</tr>';
		}
	}

	html[html.length] = '</tbody>';

	return html;
};

YAHOO.widget.Calendar.prototype.renderFooter = function(html) { return html; };

YAHOO.widget.Calendar.prototype.render = function() {
	this.beforeRenderEvent.fire();

	var defCfg = YAHOO.widget.Calendar._DEFAULT_CONFIG;

	var workingDate = YAHOO.widget.DateMath.findMonthStart(this.cfg.getProperty(defCfg.PAGEDATE.key));

	this.resetRenderers();
	this.cellDates.length = 0;

	YAHOO.util.Event.purgeElement(this.oDomContainer, true);

	var html = [];

	html[html.length] = '<table cellSpacing="0" class="' + this.Style.CSS_CALENDAR + ' y' + workingDate.getFullYear() + '" id="' + this.id + '">';
	html = this.renderHeader(html);
	html = this.renderBody(workingDate, html);
	html = this.renderFooter(html);
	html[html.length] = '</table>';

	this.oDomContainer.innerHTML = html.join("\n");

	this.applyListeners();
	this.cells = this.oDomContainer.getElementsByTagName("td");

	this.cfg.refireEvent(defCfg.TITLE.key);
	this.cfg.refireEvent(defCfg.CLOSE.key);
	this.cfg.refireEvent(defCfg.IFRAME.key);

	this.renderEvent.fire();
};

YAHOO.widget.Calendar.prototype.applyListeners = function() {
	var root = this.oDomContainer;
	var cal = this.parent || this;

	var anchor = "a";
	var mousedown = "mousedown";

	var linkLeft = YAHOO.util.Dom.getElementsByClassName(this.Style.CSS_NAV_LEFT, anchor, root);
	var linkRight = YAHOO.util.Dom.getElementsByClassName(this.Style.CSS_NAV_RIGHT, anchor, root);

	if (linkLeft && linkLeft.length > 0) {
		this.linkLeft = linkLeft[0];
		YAHOO.util.Event.addListener(this.linkLeft, mousedown, cal.previousMonth, cal, true);
	}

	if (linkRight && linkRight.length > 0) {
		this.linkRight = linkRight[0];
		YAHOO.util.Event.addListener(this.linkRight, mousedown, cal.nextMonth, cal, true);
	}

	if (this.domEventMap) {
		var el,elements;
		for (var cls in this.domEventMap) {
			if (YAHOO.lang.hasOwnProperty(this.domEventMap, cls)) {
				var items = this.domEventMap[cls];

				if (! (items instanceof Array)) {
					items = [items];
				}

				for (var i=0;i<items.length;i++)	{
					var item = items[i];
					elements = YAHOO.util.Dom.getElementsByClassName(cls, item.tag, this.oDomContainer);

					for (var c=0;c<elements.length;c++) {
						el = elements[c];
							YAHOO.util.Event.addListener(el, item.event, item.handler, item.scope, item.correct );
					}
				}
			}
		}
	}

	YAHOO.util.Event.addListener(this.oDomContainer, "click", this.doSelectCell, this);
	YAHOO.util.Event.addListener(this.oDomContainer, "mouseover", this.doCellMouseOver, this);
	YAHOO.util.Event.addListener(this.oDomContainer, "mouseout", this.doCellMouseOut, this);
};

YAHOO.widget.Calendar.prototype.getDateByCellId = function(id) {
	var date = this.getDateFieldsByCellId(id);
	return new Date(date[0],date[1]-1,date[2]);
};

YAHOO.widget.Calendar.prototype.getDateFieldsByCellId = function(id) {
	id = id.toLowerCase().split("_cell")[1];
	id = parseInt(id, 10);
	return this.cellDates[id];
};

YAHOO.widget.Calendar.prototype.renderOutOfBoundsDate = function(workingDate, cell) {
	YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_OOB);
	cell.innerHTML = workingDate.getDate();
	return YAHOO.widget.Calendar.STOP_RENDER;
};

YAHOO.widget.Calendar.prototype.renderRowHeader = function(weekNum, html) {
	html[html.length] = '<th class="calrowhead">' + weekNum + '</th>';
	return html;
};

YAHOO.widget.Calendar.prototype.renderRowFooter = function(weekNum, html) {
	html[html.length] = '<th class="calrowfoot">' + weekNum + '</th>';
	return html;
};

YAHOO.widget.Calendar.prototype.renderCellDefault = function(workingDate, cell) {
	cell.innerHTML = '<a href="#" class="' + this.Style.CSS_CELL_SELECTOR + '">' + this.buildDayLabel(workingDate) + "</a>";
};

YAHOO.widget.Calendar.prototype.styleCellDefault = function(workingDate, cell) {
	YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_SELECTABLE);
};

YAHOO.widget.Calendar.prototype.renderCellStyleHighlight1 = function(workingDate, cell) {
	YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_HIGHLIGHT1);
};

YAHOO.widget.Calendar.prototype.renderCellStyleHighlight2 = function(workingDate, cell) {
	YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_HIGHLIGHT2);
};

YAHOO.widget.Calendar.prototype.renderCellStyleHighlight3 = function(workingDate, cell) {
	YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_HIGHLIGHT3);
};

YAHOO.widget.Calendar.prototype.renderCellStyleHighlight4 = function(workingDate, cell) {
	YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_HIGHLIGHT4);
};

YAHOO.widget.Calendar.prototype.renderCellStyleToday = function(workingDate, cell) {
	YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_TODAY);
};

YAHOO.widget.Calendar.prototype.renderCellStyleSelected = function(workingDate, cell) {
	YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_SELECTED);
};

YAHOO.widget.Calendar.prototype.renderCellNotThisMonth = function(workingDate, cell) {
	YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_OOM);
	cell.innerHTML=workingDate.getDate();
	return YAHOO.widget.Calendar.STOP_RENDER;
};

YAHOO.widget.Calendar.prototype.renderBodyCellRestricted = function(workingDate, cell) {
	YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL);
	YAHOO.util.Dom.addClass(cell, this.Style.CSS_CELL_RESTRICTED);
	cell.innerHTML=workingDate.getDate();
	return YAHOO.widget.Calendar.STOP_RENDER;
};

YAHOO.widget.Calendar.prototype.addMonths = function(count) {
	var cfgPageDate = YAHOO.widget.Calendar._DEFAULT_CONFIG.PAGEDATE.key;
	this.cfg.setProperty(cfgPageDate, YAHOO.widget.DateMath.add(this.cfg.getProperty(cfgPageDate), YAHOO.widget.DateMath.MONTH, count));
	this.resetRenderers();
	this.changePageEvent.fire();
};

YAHOO.widget.Calendar.prototype.subtractMonths = function(count) {
	var cfgPageDate = YAHOO.widget.Calendar._DEFAULT_CONFIG.PAGEDATE.key;
	this.cfg.setProperty(cfgPageDate, YAHOO.widget.DateMath.subtract(this.cfg.getProperty(cfgPageDate), YAHOO.widget.DateMath.MONTH, count));
	this.resetRenderers();
	this.changePageEvent.fire();
};

YAHOO.widget.Calendar.prototype.addYears = function(count) {
	var cfgPageDate = YAHOO.widget.Calendar._DEFAULT_CONFIG.PAGEDATE.key;
	this.cfg.setProperty(cfgPageDate, YAHOO.widget.DateMath.add(this.cfg.getProperty(cfgPageDate), YAHOO.widget.DateMath.YEAR, count));
	this.resetRenderers();
	this.changePageEvent.fire();
};

YAHOO.widget.Calendar.prototype.subtractYears = function(count) {
	var cfgPageDate = YAHOO.widget.Calendar._DEFAULT_CONFIG.PAGEDATE.key;
	this.cfg.setProperty(cfgPageDate, YAHOO.widget.DateMath.subtract(this.cfg.getProperty(cfgPageDate), YAHOO.widget.DateMath.YEAR, count));
	this.resetRenderers();
	this.changePageEvent.fire();
};

YAHOO.widget.Calendar.prototype.nextMonth = function() {
	this.addMonths(1);
};

YAHOO.widget.Calendar.prototype.previousMonth = function() {
	this.subtractMonths(1);
};

YAHOO.widget.Calendar.prototype.nextYear = function() {
	this.addYears(1);
};

YAHOO.widget.Calendar.prototype.previousYear = function() {
	this.subtractYears(1);
};

YAHOO.widget.Calendar.prototype.reset = function() {
	var defCfg = YAHOO.widget.Calendar._DEFAULT_CONFIG;
	this.cfg.resetProperty(defCfg.SELECTED.key);
	this.cfg.resetProperty(defCfg.PAGEDATE.key);
	this.resetEvent.fire();
};

YAHOO.widget.Calendar.prototype.clear = function() {
	var defCfg = YAHOO.widget.Calendar._DEFAULT_CONFIG;
	this.cfg.setProperty(defCfg.SELECTED.key, []);
	this.cfg.setProperty(defCfg.PAGEDATE.key, new Date(this.today.getTime()));
	this.clearEvent.fire();
};

YAHOO.widget.Calendar.prototype.select = function(date) {
	var aToBeSelected = this._toFieldArray(date);

	var validDates = [];
	var selected = [];
	var cfgSelected = YAHOO.widget.Calendar._DEFAULT_CONFIG.SELECTED.key;

	for (var a=0; a < aToBeSelected.length; ++a) {
		var toSelect = aToBeSelected[a];

		if (!this.isDateOOB(this._toDate(toSelect))) {
			if (validDates.length === 0) {
				this.beforeSelectEvent.fire();
				selected = this.cfg.getProperty(cfgSelected);
			}

			validDates.push(toSelect);

			if (this._indexOfSelectedFieldArray(toSelect) == -1) {
				selected[selected.length] = toSelect;
			}
		}
	}

	if (validDates.length > 0) {
		if (this.parent) {
			this.parent.cfg.setProperty(cfgSelected, selected);
		} else {
			this.cfg.setProperty(cfgSelected, selected);
		}
		this.selectEvent.fire(validDates);
	}

	return this.getSelectedDates();
};

YAHOO.widget.Calendar.prototype.selectCell = function(cellIndex) {
	var cell = this.cells[cellIndex];
	var cellDate = this.cellDates[cellIndex];
	var dCellDate = this._toDate(cellDate);

	var selectable = YAHOO.util.Dom.hasClass(cell, this.Style.CSS_CELL_SELECTABLE);

	if (selectable) {
		this.beforeSelectEvent.fire();

		var cfgSelected = YAHOO.widget.Calendar._DEFAULT_CONFIG.SELECTED.key;
		var selected = this.cfg.getProperty(cfgSelected);

		var selectDate = cellDate.concat();

		if (this._indexOfSelectedFieldArray(selectDate) == -1) {
			selected[selected.length] = selectDate;
		}
		if (this.parent) {
			this.parent.cfg.setProperty(cfgSelected, selected);
		} else {
			this.cfg.setProperty(cfgSelected, selected);
		}
		this.renderCellStyleSelected(dCellDate,cell);
		this.selectEvent.fire([selectDate]);

		this.doCellMouseOut.call(cell, null, this);
	}

	return this.getSelectedDates();
};

YAHOO.widget.Calendar.prototype.deselect = function(date) {
	var aToBeDeselected = this._toFieldArray(date);

	var validDates = [];
	var selected = [];
	var cfgSelected = YAHOO.widget.Calendar._DEFAULT_CONFIG.SELECTED.key;

	for (var a=0; a < aToBeDeselected.length; ++a) {
		var toDeselect = aToBeDeselected[a];

		if (!this.isDateOOB(this._toDate(toDeselect))) {
			if (validDates.length === 0) {
				this.beforeDeselectEvent.fire();
				selected = this.cfg.getProperty(cfgSelected);
			}

			validDates.push(toDeselect);

			var index = this._indexOfSelectedFieldArray(toDeselect);
			if (index != -1) {
				selected.splice(index,1);
			}
		}
	}

	if (validDates.length > 0) {
		if (this.parent) {
			this.parent.cfg.setProperty(cfgSelected, selected);
		} else {
			this.cfg.setProperty(cfgSelected, selected);
		}
		this.deselectEvent.fire(validDates);
	}

	return this.getSelectedDates();
};

YAHOO.widget.Calendar.prototype.deselectCell = function(cellIndex) {
	var cell = this.cells[cellIndex];
	var cellDate = this.cellDates[cellIndex];
	var cellDateIndex = this._indexOfSelectedFieldArray(cellDate);

	var selectable = YAHOO.util.Dom.hasClass(cell, this.Style.CSS_CELL_SELECTABLE);

	if (selectable) {
		this.beforeDeselectEvent.fire();

		var defCfg = YAHOO.widget.Calendar._DEFAULT_CONFIG;
		var selected = this.cfg.getProperty(defCfg.SELECTED.key);

		var dCellDate = this._toDate(cellDate);
		var selectDate = cellDate.concat();

		if (cellDateIndex > -1) {
			if (this.cfg.getProperty(defCfg.PAGEDATE.key).getMonth() == dCellDate.getMonth() &&
				this.cfg.getProperty(defCfg.PAGEDATE.key).getFullYear() == dCellDate.getFullYear()) {
				YAHOO.util.Dom.removeClass(cell, this.Style.CSS_CELL_SELECTED);
			}
			selected.splice(cellDateIndex, 1);
		}

		if (this.parent) {
			this.parent.cfg.setProperty(defCfg.SELECTED.key, selected);
		} else {
			this.cfg.setProperty(defCfg.SELECTED.key, selected);
		}

		this.deselectEvent.fire(selectDate);
	}

	return this.getSelectedDates();
};

YAHOO.widget.Calendar.prototype.deselectAll = function() {
	this.beforeDeselectEvent.fire();

	var cfgSelected = YAHOO.widget.Calendar._DEFAULT_CONFIG.SELECTED.key;

	var selected = this.cfg.getProperty(cfgSelected);
	var count = selected.length;
	var sel = selected.concat();

	if (this.parent) {
		this.parent.cfg.setProperty(cfgSelected, []);
	} else {
		this.cfg.setProperty(cfgSelected, []);
	}

	if (count > 0) {
		this.deselectEvent.fire(sel);
	}

	return this.getSelectedDates();
};

YAHOO.widget.Calendar.prototype._toFieldArray = function(date) {
	var returnDate = [];

	if (date instanceof Date) {
		returnDate = [[date.getFullYear(), date.getMonth()+1, date.getDate()]];
	} else if (YAHOO.lang.isString(date)) {
		returnDate = this._parseDates(date);
	} else if (YAHOO.lang.isArray(date)) {
		for (var i=0;i<date.length;++i) {
			var d = date[i];
			returnDate[returnDate.length] = [d.getFullYear(),d.getMonth()+1,d.getDate()];
		}
	}

	return returnDate;
};

YAHOO.widget.Calendar.prototype._toDate = function(dateFieldArray) {
	if (dateFieldArray instanceof Date) {
		return dateFieldArray;
	} else {
		return new Date(dateFieldArray[0],dateFieldArray[1]-1,dateFieldArray[2]);
	}
};

YAHOO.widget.Calendar.prototype._fieldArraysAreEqual = function(array1, array2) {
	var match = false;

	if (array1[0]==array2[0]&&array1[1]==array2[1]&&array1[2]==array2[2]) {
		match=true;
	}

	return match;
};

YAHOO.widget.Calendar.prototype._indexOfSelectedFieldArray = function(find) {
	var selected = -1;
	var seldates = this.cfg.getProperty(YAHOO.widget.Calendar._DEFAULT_CONFIG.SELECTED.key);

	for (var s=0;s<seldates.length;++s) {
		var sArray = seldates[s];
		if (find[0]==sArray[0]&&find[1]==sArray[1]&&find[2]==sArray[2]) {
			selected = s;
			break;
		}
	}

	return selected;
};

YAHOO.widget.Calendar.prototype.isDateOOM = function(date) {
	return (date.getMonth() != this.cfg.getProperty(YAHOO.widget.Calendar._DEFAULT_CONFIG.PAGEDATE.key).getMonth());
};

YAHOO.widget.Calendar.prototype.isDateOOB = function(date) {
	var defCfg = YAHOO.widget.Calendar._DEFAULT_CONFIG;

	var minDate = this.cfg.getProperty(defCfg.MINDATE.key);
	var maxDate = this.cfg.getProperty(defCfg.MAXDATE.key);
	var dm = YAHOO.widget.DateMath;

	if (minDate) {
		minDate = dm.clearTime(minDate);
	}
	if (maxDate) {
		maxDate = dm.clearTime(maxDate);
	}

	var clearedDate = new Date(date.getTime());
	clearedDate = dm.clearTime(clearedDate);

	return ((minDate && clearedDate.getTime() < minDate.getTime()) || (maxDate && clearedDate.getTime() > maxDate.getTime()));
};

YAHOO.widget.Calendar.prototype._parsePageDate = function(date) {
	var parsedDate;

	var defCfg = YAHOO.widget.Calendar._DEFAULT_CONFIG;

	if (date) {
		if (date instanceof Date) {
			parsedDate = YAHOO.widget.DateMath.findMonthStart(date);
		} else {
			var month, year, aMonthYear;
			aMonthYear = date.split(this.cfg.getProperty(defCfg.DATE_FIELD_DELIMITER.key));
			month = parseInt(aMonthYear[this.cfg.getProperty(defCfg.MY_MONTH_POSITION.key)-1], 10)-1;
			year = parseInt(aMonthYear[this.cfg.getProperty(defCfg.MY_YEAR_POSITION.key)-1], 10);

			parsedDate = new Date(year, month, 1);
		}
	} else {
		parsedDate = new Date(this.today.getFullYear(), this.today.getMonth(), 1);
	}
	return parsedDate;
};

YAHOO.widget.Calendar.prototype.onBeforeSelect = function() {
	if (this.cfg.getProperty(YAHOO.widget.Calendar._DEFAULT_CONFIG.MULTI_SELECT.key) === false) {
		if (this.parent) {
			this.parent.callChildFunction("clearAllBodyCellStyles", this.Style.CSS_CELL_SELECTED);
			this.parent.deselectAll();
		} else {
			this.clearAllBodyCellStyles(this.Style.CSS_CELL_SELECTED);
			this.deselectAll();
		}
	}
};

YAHOO.widget.Calendar.prototype.onSelect = function(selected) { };
YAHOO.widget.Calendar.prototype.onBeforeDeselect = function() { };
YAHOO.widget.Calendar.prototype.onDeselect = function(deselected) { };
YAHOO.widget.Calendar.prototype.onChangePage = function() { this.render(); };
YAHOO.widget.Calendar.prototype.onRender = function() { };
YAHOO.widget.Calendar.prototype.onReset = function() { this.render(); };
YAHOO.widget.Calendar.prototype.onClear = function() { this.render(); };
YAHOO.widget.Calendar.prototype.validate = function() { return true; };
YAHOO.widget.Calendar.prototype._parseDate = function(sDate) {
	var aDate = sDate.split(this.Locale.DATE_FIELD_DELIMITER);
	var rArray;

	if (aDate.length == 2) {
		rArray = [aDate[this.Locale.MD_MONTH_POSITION-1],aDate[this.Locale.MD_DAY_POSITION-1]];
		rArray.type = YAHOO.widget.Calendar.MONTH_DAY;
	} else {
		rArray = [aDate[this.Locale.MDY_YEAR_POSITION-1],aDate[this.Locale.MDY_MONTH_POSITION-1],aDate[this.Locale.MDY_DAY_POSITION-1]];
		rArray.type = YAHOO.widget.Calendar.DATE;
	}

	for (var i=0;i<rArray.length;i++) {
		rArray[i] = parseInt(rArray[i], 10);
	}

	return rArray;
};

YAHOO.widget.Calendar.prototype._parseDates = function(sDates) {
	var aReturn = [];

	var aDates = sDates.split(this.Locale.DATE_DELIMITER);

	for (var d=0;d<aDates.length;++d) {
		var sDate = aDates[d];

		if (sDate.indexOf(this.Locale.DATE_RANGE_DELIMITER) != -1) {
			var aRange = sDate.split(this.Locale.DATE_RANGE_DELIMITER);

			var dateStart = this._parseDate(aRange[0]);
			var dateEnd = this._parseDate(aRange[1]);

			var fullRange = this._parseRange(dateStart, dateEnd);
			aReturn = aReturn.concat(fullRange);
		} else {
			var aDate = this._parseDate(sDate);
			aReturn.push(aDate);
		}
	}
	return aReturn;
};

YAHOO.widget.Calendar.prototype._parseRange = function(startDate, endDate) {
	var dStart = new Date(startDate[0],startDate[1]-1,startDate[2]);
	var dCurrent = YAHOO.widget.DateMath.add(new Date(startDate[0],startDate[1]-1,startDate[2]),YAHOO.widget.DateMath.DAY,1);
	var dEnd = new Date(endDate[0], endDate[1]-1, endDate[2]);

	var results = [];
	results.push(startDate);
	while (dCurrent.getTime() <= dEnd.getTime()) {
		results.push([dCurrent.getFullYear(),dCurrent.getMonth()+1,dCurrent.getDate()]);
		dCurrent = YAHOO.widget.DateMath.add(dCurrent,YAHOO.widget.DateMath.DAY,1);
	}
	return results;
};

YAHOO.widget.Calendar.prototype.resetRenderers = function() {
	this.renderStack = this._renderStack.concat();
};

YAHOO.widget.Calendar.prototype.clearElement = function(cell) {
	cell.innerHTML = "&#160;";
	cell.className="";
};

YAHOO.widget.Calendar.prototype.addRenderer = function(sDates, fnRender) {
	var aDates = this._parseDates(sDates);
	for (var i=0;i<aDates.length;++i) {
		var aDate = aDates[i];

		if (aDate.length == 2) {
			if (aDate[0] instanceof Array) {
				this._addRenderer(YAHOO.widget.Calendar.RANGE,aDate,fnRender);
			} else {
				this._addRenderer(YAHOO.widget.Calendar.MONTH_DAY,aDate,fnRender);
			}
		} else if (aDate.length == 3) {
			this._addRenderer(YAHOO.widget.Calendar.DATE,aDate,fnRender);
		}
	}
};

YAHOO.widget.Calendar.prototype._addRenderer = function(type, aDates, fnRender) {
	var add = [type,aDates,fnRender];
	this.renderStack.unshift(add);
	this._renderStack = this.renderStack.concat();
};

YAHOO.widget.Calendar.prototype.addMonthRenderer = function(month, fnRender) {
	this._addRenderer(YAHOO.widget.Calendar.MONTH,[month],fnRender);
};

YAHOO.widget.Calendar.prototype.addWeekdayRenderer = function(weekday, fnRender) {
	this._addRenderer(YAHOO.widget.Calendar.WEEKDAY,[weekday],fnRender);
};

YAHOO.widget.Calendar.prototype.clearAllBodyCellStyles = function(style) {
	for (var c=0;c<this.cells.length;++c) {
		YAHOO.util.Dom.removeClass(this.cells[c],style);
	}
};

YAHOO.widget.Calendar.prototype.setMonth = function(month) {
	var cfgPageDate = YAHOO.widget.Calendar._DEFAULT_CONFIG.PAGEDATE.key;
	var current = this.cfg.getProperty(cfgPageDate);
	current.setMonth(parseInt(month, 10));
	this.cfg.setProperty(cfgPageDate, current);
};

YAHOO.widget.Calendar.prototype.setYear = function(year) {
	var cfgPageDate = YAHOO.widget.Calendar._DEFAULT_CONFIG.PAGEDATE.key;
	var current = this.cfg.getProperty(cfgPageDate);
	current.setFullYear(parseInt(year, 10));
	this.cfg.setProperty(cfgPageDate, current);
};

YAHOO.widget.Calendar.prototype.getSelectedDates = function() {
	var returnDates = [];
	var selected = this.cfg.getProperty(YAHOO.widget.Calendar._DEFAULT_CONFIG.SELECTED.key);

	for (var d=0;d<selected.length;++d) {
		var dateArray = selected[d];

		var date = new Date(dateArray[0],dateArray[1]-1,dateArray[2]);
		returnDates.push(date);
	}

	returnDates.sort( function(a,b) { return a-b; } );
	return returnDates;
};

YAHOO.widget.Calendar.prototype.hide = function() {
	this.oDomContainer.style.display = "none";
};

YAHOO.widget.Calendar.prototype.show = function() {
	this.oDomContainer.style.display = "block";
};

YAHOO.widget.Calendar.prototype.browser = function() {
			var ua = navigator.userAgent.toLowerCase();
						if (ua.indexOf('opera')!=-1) {
						return 'opera';
						} else if (ua.indexOf('msie 7')!=-1) {
						return 'ie7';
						} else if (ua.indexOf('msie') !=-1) {
						return 'ie';
						} else if (ua.indexOf('safari')!=-1) {
						return 'safari';
						} else if (ua.indexOf('gecko') != -1) {
						return 'gecko';
						} else {
						return false;
						}
			}();
YAHOO.widget.Calendar.prototype.toString = function() {
	return "Calendar " + this.id;
};

YAHOO.widget.Calendar_Core = YAHOO.widget.Calendar;

YAHOO.widget.Cal_Core = YAHOO.widget.Calendar;

YAHOO.widget.CalendarGroup = function(id, containerId, config) {
	if (arguments.length > 0) {
		this.init(id, containerId, config);
	}
};

YAHOO.widget.CalendarGroup.prototype.init = function(id, containerId, config) {
	this.initEvents();
	this.initStyles();

	this.pages = [];

	this.id = id;

	this.containerId = containerId;

	this.oDomContainer = document.getElementById(containerId);

	YAHOO.util.Dom.addClass(this.oDomContainer, YAHOO.widget.CalendarGroup.CSS_CONTAINER);
	YAHOO.util.Dom.addClass(this.oDomContainer, YAHOO.widget.CalendarGroup.CSS_MULTI_UP);

	this.cfg = new YAHOO.util.Config(this);

	this.Options = {};

	this.Locale = {};

	this.setupConfig();

	if (config) {
		this.cfg.applyConfig(config, true);
	}

	this.cfg.fireQueue();

	if (YAHOO.env.ua.opera){
		this.renderEvent.subscribe(this._fixWidth, this, true);
	}
};

YAHOO.widget.CalendarGroup.prototype.setupConfig = function() {
	var defCfg = YAHOO.widget.CalendarGroup._DEFAULT_CONFIG;

	this.cfg.addProperty(defCfg.PAGES.key, { value:defCfg.PAGES.value, validator:this.cfg.checkNumber, handler:this.configPages } );
	this.cfg.addProperty(defCfg.PAGEDATE.key, { value:new Date(), handler:this.configPageDate } );
	this.cfg.addProperty(defCfg.SELECTED.key, { value:[], handler:this.configSelected } );
	this.cfg.addProperty(defCfg.TITLE.key, { value:defCfg.TITLE.value, handler:this.configTitle } );
	this.cfg.addProperty(defCfg.CLOSE.key, { value:defCfg.CLOSE.value, handler:this.configClose } );
	this.cfg.addProperty(defCfg.IFRAME.key, { value:defCfg.IFRAME.value, handler:this.configIframe, validator:this.cfg.checkBoolean } );
	this.cfg.addProperty(defCfg.MINDATE.key, { value:defCfg.MINDATE.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.MAXDATE.key, { value:defCfg.MAXDATE.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.MULTI_SELECT.key, { value:defCfg.MULTI_SELECT.value, handler:this.delegateConfig, validator:this.cfg.checkBoolean } );
	this.cfg.addProperty(defCfg.START_WEEKDAY.key, { value:defCfg.START_WEEKDAY.value, handler:this.delegateConfig, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.SHOW_WEEKDAYS.key, { value:defCfg.SHOW_WEEKDAYS.value, handler:this.delegateConfig, validator:this.cfg.checkBoolean } );
	this.cfg.addProperty(defCfg.SHOW_WEEK_HEADER.key, { value:defCfg.SHOW_WEEK_HEADER.value, handler:this.delegateConfig, validator:this.cfg.checkBoolean } );
	this.cfg.addProperty(defCfg.SHOW_WEEK_FOOTER.key, { value:defCfg.SHOW_WEEK_FOOTER.value, handler:this.delegateConfig, validator:this.cfg.checkBoolean } );
	this.cfg.addProperty(defCfg.HIDE_BLANK_WEEKS.key, { value:defCfg.HIDE_BLANK_WEEKS.value, handler:this.delegateConfig, validator:this.cfg.checkBoolean } );
	this.cfg.addProperty(defCfg.NAV_ARROW_LEFT.key, { value:defCfg.NAV_ARROW_LEFT.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.NAV_ARROW_RIGHT.key, { value:defCfg.NAV_ARROW_RIGHT.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.MONTHS_SHORT.key, { value:defCfg.MONTHS_SHORT.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.MONTHS_LONG.key, { value:defCfg.MONTHS_LONG.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.WEEKDAYS_1CHAR.key, { value:defCfg.WEEKDAYS_1CHAR.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.WEEKDAYS_SHORT.key, { value:defCfg.WEEKDAYS_SHORT.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.WEEKDAYS_MEDIUM.key, { value:defCfg.WEEKDAYS_MEDIUM.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.WEEKDAYS_LONG.key, { value:defCfg.WEEKDAYS_LONG.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.LOCALE_MONTHS.key, { value:defCfg.LOCALE_MONTHS.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.LOCALE_WEEKDAYS.key, { value:defCfg.LOCALE_WEEKDAYS.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.DATE_DELIMITER.key, { value:defCfg.DATE_DELIMITER.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.DATE_FIELD_DELIMITER.key, { value:defCfg.DATE_FIELD_DELIMITER.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.DATE_RANGE_DELIMITER.key, { value:defCfg.DATE_RANGE_DELIMITER.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.MY_MONTH_POSITION.key, { value:defCfg.MY_MONTH_POSITION.value, handler:this.delegateConfig, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MY_YEAR_POSITION.key, { value:defCfg.MY_YEAR_POSITION.value, handler:this.delegateConfig, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MD_MONTH_POSITION.key, { value:defCfg.MD_MONTH_POSITION.value, handler:this.delegateConfig, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MD_DAY_POSITION.key, { value:defCfg.MD_DAY_POSITION.value, handler:this.delegateConfig, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MDY_MONTH_POSITION.key, { value:defCfg.MDY_MONTH_POSITION.value, handler:this.delegateConfig, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MDY_DAY_POSITION.key, { value:defCfg.MDY_DAY_POSITION.value, handler:this.delegateConfig, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MDY_YEAR_POSITION.key, { value:defCfg.MDY_YEAR_POSITION.value, handler:this.delegateConfig, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MY_LABEL_MONTH_POSITION.key, { value:defCfg.MY_LABEL_MONTH_POSITION.value, handler:this.delegateConfig, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MY_LABEL_YEAR_POSITION.key, { value:defCfg.MY_LABEL_YEAR_POSITION.value, handler:this.delegateConfig, validator:this.cfg.checkNumber } );
	this.cfg.addProperty(defCfg.MY_LABEL_MONTH_SUFFIX.key, { value:defCfg.MY_LABEL_MONTH_SUFFIX.value, handler:this.delegateConfig } );
	this.cfg.addProperty(defCfg.MY_LABEL_YEAR_SUFFIX.key, { value:defCfg.MY_LABEL_YEAR_SUFFIX.value, handler:this.delegateConfig } );
};

YAHOO.widget.CalendarGroup.prototype.initEvents = function() {
	var me = this;
	var strEvent = "Event";

	var sub = function(fn, obj, bOverride) {
		for (var p=0;p<me.pages.length;++p) {
			var cal = me.pages[p];
			cal[this.type + strEvent].subscribe(fn, obj, bOverride);
		}
	};

	var unsub = function(fn, obj) {
		for (var p=0;p<me.pages.length;++p) {
			var cal = me.pages[p];
			cal[this.type + strEvent].unsubscribe(fn, obj);
		}
	};

	var defEvents = YAHOO.widget.Calendar._EVENT_TYPES;

	this.beforeSelectEvent = new YAHOO.util.CustomEvent(defEvents.BEFORE_SELECT);
	this.beforeSelectEvent.subscribe = sub; this.beforeSelectEvent.unsubscribe = unsub;

	this.selectEvent = new YAHOO.util.CustomEvent(defEvents.SELECT);
	this.selectEvent.subscribe = sub; this.selectEvent.unsubscribe = unsub;

	this.beforeDeselectEvent = new YAHOO.util.CustomEvent(defEvents.BEFORE_DESELECT);
	this.beforeDeselectEvent.subscribe = sub; this.beforeDeselectEvent.unsubscribe = unsub;

	this.deselectEvent = new YAHOO.util.CustomEvent(defEvents.DESELECT);
	this.deselectEvent.subscribe = sub; this.deselectEvent.unsubscribe = unsub;

	this.changePageEvent = new YAHOO.util.CustomEvent(defEvents.CHANGE_PAGE);
	this.changePageEvent.subscribe = sub; this.changePageEvent.unsubscribe = unsub;

	this.beforeRenderEvent = new YAHOO.util.CustomEvent(defEvents.BEFORE_RENDER);
	this.beforeRenderEvent.subscribe = sub; this.beforeRenderEvent.unsubscribe = unsub;

	this.renderEvent = new YAHOO.util.CustomEvent(defEvents.RENDER);
	this.renderEvent.subscribe = sub; this.renderEvent.unsubscribe = unsub;

	this.resetEvent = new YAHOO.util.CustomEvent(defEvents.RESET);
	this.resetEvent.subscribe = sub; this.resetEvent.unsubscribe = unsub;

	this.clearEvent = new YAHOO.util.CustomEvent(defEvents.CLEAR);
	this.clearEvent.subscribe = sub; this.clearEvent.unsubscribe = unsub;

};

YAHOO.widget.CalendarGroup.prototype.configPages = function(type, args, obj) {
	var pageCount = args[0];

	var cfgPageDate = YAHOO.widget.CalendarGroup._DEFAULT_CONFIG.PAGEDATE.key;

	var sep = "_";
	var groupCalClass = "groupcal";

	var firstClass = "first-of-type";
	var lastClass = "last-of-type";

	for (var p=0;p<pageCount;++p) {
		var calId = this.id + sep + p;
		var calContainerId = this.containerId + sep + p;

		var childConfig = this.cfg.getConfig();
		childConfig.close = false;
		childConfig.title = false;

		var cal = this.constructChild(calId, calContainerId, childConfig);
		var caldate = cal.cfg.getProperty(cfgPageDate);
		this._setMonthOnDate(caldate, caldate.getMonth() + p);
		cal.cfg.setProperty(cfgPageDate, caldate);

		YAHOO.util.Dom.removeClass(cal.oDomContainer, this.Style.CSS_SINGLE);
		YAHOO.util.Dom.addClass(cal.oDomContainer, groupCalClass);

		if (p===0) {
			YAHOO.util.Dom.addClass(cal.oDomContainer, firstClass);
		}

		if (p==(pageCount-1)) {
			YAHOO.util.Dom.addClass(cal.oDomContainer, lastClass);
		}

		cal.parent = this;
		cal.index = p;

		this.pages[this.pages.length] = cal;
	}
};

YAHOO.widget.CalendarGroup.prototype.configPageDate = function(type, args, obj) {
	var val = args[0];
	var firstPageDate;

	var cfgPageDate = YAHOO.widget.CalendarGroup._DEFAULT_CONFIG.PAGEDATE.key;

	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		if (p === 0) {
			firstPageDate = cal._parsePageDate(val);
			cal.cfg.setProperty(cfgPageDate, firstPageDate);
		} else {
			var pageDate = new Date(firstPageDate);
			this._setMonthOnDate(pageDate, pageDate.getMonth() + p);
			cal.cfg.setProperty(cfgPageDate, pageDate);
		}
	}
};

YAHOO.widget.CalendarGroup.prototype.configSelected = function(type, args, obj) {
	var cfgSelected = YAHOO.widget.CalendarGroup._DEFAULT_CONFIG.SELECTED.key;
	this.delegateConfig(type, args, obj);
	var selected = (this.pages.length > 0) ? this.pages[0].cfg.getProperty(cfgSelected) : [];
	this.cfg.setProperty(cfgSelected, selected, true);
};

YAHOO.widget.CalendarGroup.prototype.delegateConfig = function(type, args, obj) {
	var val = args[0];
	var cal;

	for (var p=0;p<this.pages.length;p++) {
		cal = this.pages[p];
		cal.cfg.setProperty(type, val);
	}
};

YAHOO.widget.CalendarGroup.prototype.setChildFunction = function(fnName, fn) {
	var pageCount = this.cfg.getProperty(YAHOO.widget.CalendarGroup._DEFAULT_CONFIG.PAGES.key);

	for (var p=0;p<pageCount;++p) {
		this.pages[p][fnName] = fn;
	}
};

YAHOO.widget.CalendarGroup.prototype.callChildFunction = function(fnName, args) {
	var pageCount = this.cfg.getProperty(YAHOO.widget.CalendarGroup._DEFAULT_CONFIG.PAGES.key);

	for (var p=0;p<pageCount;++p) {
		var page = this.pages[p];
		if (page[fnName]) {
			var fn = page[fnName];
			fn.call(page, args);
		}
	}
};

YAHOO.widget.CalendarGroup.prototype.constructChild = function(id,containerId,config) {
	var container = document.getElementById(containerId);
	if (! container) {
		container = document.createElement("div");
		container.id = containerId;
		this.oDomContainer.appendChild(container);
	}
	return new YAHOO.widget.Calendar(id,containerId,config);
};

YAHOO.widget.CalendarGroup.prototype.setMonth = function(month) {
	month = parseInt(month, 10);
	var currYear;

	var cfgPageDate = YAHOO.widget.CalendarGroup._DEFAULT_CONFIG.PAGEDATE.key;

	for (var p=0; p<this.pages.length; ++p) {
		var cal = this.pages[p];
		var pageDate = cal.cfg.getProperty(cfgPageDate);
		if (p === 0) {
			currYear = pageDate.getFullYear();
		} else {
			pageDate.setYear(currYear);
		}
		this._setMonthOnDate(pageDate, month+p);
		cal.cfg.setProperty(cfgPageDate, pageDate);
	}
};

YAHOO.widget.CalendarGroup.prototype.setYear = function(year) {
	var cfgPageDate = YAHOO.widget.CalendarGroup._DEFAULT_CONFIG.PAGEDATE.key;

	year = parseInt(year, 10);
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		var pageDate = cal.cfg.getProperty(cfgPageDate);

		if ((pageDate.getMonth()+1) == 1 && p>0) {
			year+=1;
		}
		cal.setYear(year);
	}
};
YAHOO.widget.CalendarGroup.prototype.render = function() {
	this.renderHeader();
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.render();
	}
	this.renderFooter();
};

YAHOO.widget.CalendarGroup.prototype.select = function(date) {
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.select(date);
	}
	return this.getSelectedDates();
};

YAHOO.widget.CalendarGroup.prototype.selectCell = function(cellIndex) {
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.selectCell(cellIndex);
	}
	return this.getSelectedDates();
};

YAHOO.widget.CalendarGroup.prototype.deselect = function(date) {
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.deselect(date);
	}
	return this.getSelectedDates();
};

YAHOO.widget.CalendarGroup.prototype.deselectAll = function() {
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.deselectAll();
	}
	return this.getSelectedDates();
};

YAHOO.widget.CalendarGroup.prototype.deselectCell = function(cellIndex) {
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.deselectCell(cellIndex);
	}
	return this.getSelectedDates();
};

YAHOO.widget.CalendarGroup.prototype.reset = function() {
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.reset();
	}
};

YAHOO.widget.CalendarGroup.prototype.clear = function() {
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.clear();
	}
};

YAHOO.widget.CalendarGroup.prototype.nextMonth = function() {
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.nextMonth();
	}
};

YAHOO.widget.CalendarGroup.prototype.previousMonth = function() {
	for (var p=this.pages.length-1;p>=0;--p) {
		var cal = this.pages[p];
		cal.previousMonth();
	}
};

YAHOO.widget.CalendarGroup.prototype.nextYear = function() {
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.nextYear();
	}
};

YAHOO.widget.CalendarGroup.prototype.previousYear = function() {
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.previousYear();
	}
};

YAHOO.widget.CalendarGroup.prototype.getSelectedDates = function() {
	var returnDates = [];
	var selected = this.cfg.getProperty(YAHOO.widget.CalendarGroup._DEFAULT_CONFIG.SELECTED.key);
	for (var d=0;d<selected.length;++d) {
		var dateArray = selected[d];

		var date = new Date(dateArray[0],dateArray[1]-1,dateArray[2]);
		returnDates.push(date);
	}

	returnDates.sort( function(a,b) { return a-b; } );
	return returnDates;
};

YAHOO.widget.CalendarGroup.prototype.addRenderer = function(sDates, fnRender) {
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.addRenderer(sDates, fnRender);
	}
};

YAHOO.widget.CalendarGroup.prototype.addMonthRenderer = function(month, fnRender) {
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.addMonthRenderer(month, fnRender);
	}
};

YAHOO.widget.CalendarGroup.prototype.addWeekdayRenderer = function(weekday, fnRender) {
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		cal.addWeekdayRenderer(weekday, fnRender);
	}
};

YAHOO.widget.CalendarGroup.prototype.renderHeader = function() {};

YAHOO.widget.CalendarGroup.prototype.renderFooter = function() {};

YAHOO.widget.CalendarGroup.prototype.addMonths = function(count) {
	this.callChildFunction("addMonths", count);
};

YAHOO.widget.CalendarGroup.prototype.subtractMonths = function(count) {
	this.callChildFunction("subtractMonths", count);
};

YAHOO.widget.CalendarGroup.prototype.addYears = function(count) {
	this.callChildFunction("addYears", count);
};

YAHOO.widget.CalendarGroup.prototype.subtractYears = function(count) {
	this.callChildFunction("subtractYears", count);
};

YAHOO.widget.CalendarGroup.prototype.show = function() {
	this.oDomContainer.style.display = "block";
	if (YAHOO.env.ua.opera) {
		this._fixWidth();
	}
};

YAHOO.widget.CalendarGroup.prototype._setMonthOnDate = function(date, iMonth) {
	if (YAHOO.env.ua.webkit && YAHOO.env.ua.webkit < 420 && (iMonth < 0 || iMonth > 11)) {
		var DM = YAHOO.widget.DateMath;
		var newDate = DM.add(date, DM.MONTH, iMonth-date.getMonth());
		date.setTime(newDate.getTime());
	} else {
		date.setMonth(iMonth);
	}
};

YAHOO.widget.CalendarGroup.prototype._fixWidth = function() {
	var startW = this.oDomContainer.offsetWidth;
	var w = 0;
	for (var p=0;p<this.pages.length;++p) {
		var cal = this.pages[p];
		w += cal.oDomContainer.offsetWidth;
	}
	if (w > 0) {
		this.oDomContainer.style.width = w + "px";
	}
};

YAHOO.widget.CalendarGroup.CSS_CONTAINER = "yui-calcontainer";

YAHOO.widget.CalendarGroup.CSS_MULTI_UP = "multi";

YAHOO.widget.CalendarGroup.CSS_2UPTITLE = "title";

YAHOO.widget.CalendarGroup.CSS_2UPCLOSE = "close-icon";

YAHOO.lang.augmentProto(YAHOO.widget.CalendarGroup, YAHOO.widget.Calendar, "buildDayLabel",
																	"buildMonthLabel",
																	"renderOutOfBoundsDate",
																	"renderRowHeader",
																	"renderRowFooter",
																	"renderCellDefault",
																	"styleCellDefault",
																	"renderCellStyleHighlight1",
																	"renderCellStyleHighlight2",
																	"renderCellStyleHighlight3",
																	"renderCellStyleHighlight4",
																	"renderCellStyleToday",
																	"renderCellStyleSelected",
																	"renderCellNotThisMonth",
																	"renderBodyCellRestricted",
																	"initStyles",
																	"configTitle",
																	"configClose",
																	"configIframe",
																	"hide",
																	"browser");

YAHOO.widget.CalendarGroup._DEFAULT_CONFIG = YAHOO.widget.Calendar._DEFAULT_CONFIG;
YAHOO.widget.CalendarGroup._DEFAULT_CONFIG.PAGES = {key:"pages", value:2};

YAHOO.widget.CalendarGroup.prototype.toString = function() {
	return "CalendarGroup " + this.id;
};

YAHOO.widget.CalGrp = YAHOO.widget.CalendarGroup;

YAHOO.widget.Calendar2up = function(id, containerId, config) {
	this.init(id, containerId, config);
};

YAHOO.extend(YAHOO.widget.Calendar2up, YAHOO.widget.CalendarGroup);

YAHOO.widget.Cal2up = YAHOO.widget.Calendar2up;

YAHOO.register("calendar", YAHOO.widget.Calendar, {version: "2.3.0", build: "442"});