//
// Calendar Manager
//




function CXCalendarManager() {

	// Default calendar container values
	this.calendarContainerID = 'calendarContainer';
	this.calendarContainerClass = 'CXCalendarContainer';
	this.calendarContainerElement = 'div';
	this.calendarContainer = null;
    var Dom = YAHOO.util.Dom;
	// arrays to hold handles to our calendars, range pickers and empty leg segments
	this.calendars = [];
	this.pickers = [];
	this.legs = [];

	// holder for the current YUI calendar and CX calendar obj
	this.YUICalendar = null;
	this.CXCalendarHandle = null;

	// holder for a calendar to close
	this.calendarToClose = null;
	
	// calendar dimensions
	this.calWidth = 190;
	this.calHeight = 199;

	// updating flag to force only one update at a time
	this.updating = false;
	
	// format strings
	this.emptyFormatStringMDY = "mm/dd/yyyy";
	this.emptyFormatStringDMY = "dd/mm/yyyy";
	this.emptyFormatStringYMD = "yyyy/mm/dd";
	CXCalendarManager.OnCreateContainer = new Array();
};
// static property
CXCalendarManager.prototype.OnCreateContainer = null;
// Create shared calendar container
CXCalendarManager.prototype.createContainer = function() {
	// create container for calendar
	var container = document.createElement(this.calendarContainerElement);
	container.setAttribute('id',this.calendarContainerID);
	container.setAttribute('class',this.calendarContainerClass);
	
	//container.style.display = 'none';
	document.body.appendChild(container);

	this.calendarContainer = container;
	// when the dom has settled down initialize our calendar
	YAHOO.util.Event.onDOMReady(this.init,this,true);
}
CXCalendarManager.prototype.doPreviousMonthNav = function(evt, cal)
{
    suspendblur = true;
}
CXCalendarManager.prototype.doNextMonthNav = function(evt, cal)
{
    suspendblur = true;
}
CXCalendarManager.prototype.applyListners = function()
{

        // add handling to the click event of the arrow buttons so that 
        // we can suspendblur to keep the calendar open when if it was 
        // opened by the textbox's focus event.
        var root = this.YUICalendar.oDomContainer,
			anchor = "a",
			click = "click",
		    linkLeft = YAHOO.util.Dom.getElementsByClassName(this.YUICalendar.Style.CSS_NAV_LEFT, anchor, root),		    
			linkRight = YAHOO.util.Dom.getElementsByClassName(this.YUICalendar.Style.CSS_NAV_RIGHT, anchor, root);
		if (linkLeft && linkLeft.length > 0) {
			this.linkLeft = linkLeft[0];
			YAHOO.util.Event.addListener(this.linkLeft, click, this.doPreviousMonthNav, this.YUICalendar, false);
		}

		if (linkRight && linkRight.length > 0) {
			this.linkRight = linkRight[0];
			YAHOO.util.Event.addListener(linkRight, click, this.doNextMonthNav, this, false);
		}
}
// Calendar manager initialization
CXCalendarManager.prototype.init = function(mgr) {
    //calnavleft
	// initialize calendar on dom availability of container
	YAHOO.util.Event.onContentReady(this.calendarContainerID,
		function() { 
			this.YUICalendar = new YAHOO.widget.Calendar( this.calendarContainerID,
				this.calendarContainerID, { close:true } );
		    this.YUICalendar.render();
			this.YUICalendar.hide();
            for(var i = 0; i < CXCalendarManager.OnCreateContainer.length; ++i)
                CXCalendarManager.OnCreateContainer[i].OnCreated();
        
		
		},
		this,
		true
	);
};
// shift the year if appropriate
CXCalendarManager.prototype.shiftYear = function(year, month, day, dateAssumption, minDate, maxDate) {
	var now = new Date();

	var nYear = now.getFullYear();
	var nMonth = now.getMonth() + 1;
	var nDay = now.getDate();

	if (YAHOO.CXCalendarManager.CXCalendarHandle.dateAssumption == 1 &&
		(nMonth > month || (nMonth == month && nDay > day)))
	{
		year++
	}
	else if (YAHOO.CXCalendarManager.CXCalendarHandle.dateAssumption == -1 &&
		(nMonth < month || (nMonth == month && nDay < day)))
	{
		year--;
	}

	var testDate = new Date(month + "/" + day + "/" + year);

	if((testDate < minDate) && (dateAssumption == 0)) {
		year++;
	} else if((testDate > maxDate) && (dateAssumption == 0)) {
		year--;
	}

	return year;
}

// does the given date string have a year?
CXCalendarManager.prototype.hasYear = function (datestring) {
	var mdy = /(\d{1,2})[-.\/ ](\d{1,2})[-.\/ ](\d{4})/;
	var ymd = /(\d{4})[-.\/ ](\d{1,2})[-.\/ ](\d{1,2})/;

	return (mdy.test(datestring) || ymd.test(datestring));
}

// handle changes to the calendar (populate date box)
CXCalendarManager.prototype.handleSelect = function(type, args, obj) {
    if (YAHOO.CXCalendarManager.updating == false) {
        YAHOO.CXCalendarManager.updating = true;

        var dates = args[0];
        var date = dates[0];
        var year = date[0], month = date[1], day = date[2];

        // get a handle for the textbox
        var cal = YAHOO.CXCalendarManager.CXCalendarHandle;
        var selDateBox = cx.byID(cal.dateBoxID);

        var dateString = "";
        setBlack(selDateBox, YAHOO.CXCalendarManager.initialTextFieldColor, YAHOO.CXCalendarManager.initialTextFieldClass);

        if (YAHOO.CXCalendarManager.CXCalendarHandle.dateFormatString == "DayMonthYear") {
            dateString = day + "/" + month + "/" + year;
        } else if (YAHOO.CXCalendarManager.CXCalendarHandle.dateFormatString == "MonthDayYear") {
            dateString = month + "/" + day + "/" + year;
        } else if (YAHOO.CXCalendarManager.CXCalendarHandle.dateFormatString == "YearMonthDay") {
            dateString = year + "/" + month + "/" + day;
        }
        selDateBox.value = dateString;
        // force the child to set a date depending on parent
        if (true === cal.hasChild()) {
            var d = this.parseDate(dateString, YAHOO.CXCalendarManager.CXCalendarHandle.dateFormatString, YAHOO.CXCalendarManager.CXCalendarHandle.dateAssumption)
            this.handleChildSelect(cal, cal.childCalendar, d);
        }
        YAHOO.CXCalendarManager.updateRanges(selDateBox.id);
        if (selDateBox.onchange) {
            selDateBox.onchange(null);
        }
        //        else if (undefined !== selDateBox.onchange) {
        //            selDateBox.onchange();
        //        }

        this.YUICalendar.hide();

        YAHOO.CXCalendarManager.updating = false;
    }
};
// checks to see if the parent calendar selection will force a child to "follow suit".
CXCalendarManager.prototype.handleChildSelect = function(cxParentCal, cxChildCal, dateb) {
    var tb = cx.byID(cxChildCal.dateBoxID); 
    var datea = null;
    if(tb.value.indexOf('/') > 0)
    {
        datea = new Date();    
        try
        {   
            datea = this.parseDate(tb.value, cxChildCal.dateFormatString, cxChildCal.dateAssumption); //.setFullYear(year,month - 1,day);
        }
        catch(e)
        {
            alert(e);
            // if we do not have a valid date we will set it to what the parent date was
            if(false == this.isValidDate(val, cxChildCal.dateFormatString, cxChildCal.dateAssumption))
            {
               datea = dateb; 
            }
        }
    }
    if(null == datea)
        return;
   // set the month if the parent month is greater than the child
   if(((datea.getMonth() < dateb.getMonth()) && (datea.getFullYear() == dateb.getFullYear())) || ((datea.getMonth() > dateb.getMonth()) && (datea.getFullYear() < dateb.getFullYear())))
   {
        datea.setMonth(dateb.getMonth());
   }
   if(((datea.getDate() < dateb.getDate()) && (datea.getMonth() == dateb.getMonth())) || ((datea.getDate() < dateb.getDate()) && (datea.getMonth() < dateb.getMonth()&& (datea.getFullYear() < dateb.getFullYear()))))
   {
       datea.setDate(dateb.getDate() + 1);
   }
        
   if(datea.getFullYear() < dateb.getFullYear())
        datea.setFullYear(dateb.getFullYear());    
    tb.value = this.toDateString(datea, cxChildCal.dateFormatString);
    if(true === cxChildCal.hasChild())
    {
        this.handleChildSelect(cxChildCal, cxChildCal.childCalendar, datea);
    }
}
// returns a formatted string from a date object
CXCalendarManager.prototype.toDateString = function(date, dateFormat) {
    var dateString = "";
    switch(dateFormat)
    {
        case "DayMonthYear":
            dateString = date.getDate() + "/" + date.getMonth() + 1 + "/" + date.getFullYear();
            break;
        case "MonthDayYear":
            dateString = date.getMonth() + 1 + "/" + date.getDate() + "/" + date.getFullYear();
            break;
        case "YearMonthDay":
            dateString = date.getFullYear() + "/" + date.getMonth() + 1 + "/" + date.getDate();
            break;
    }     
    return dateString;
}


// parse a date out of a string with a given format
CXCalendarManager.prototype.parseDate = function(stringDate, dateFormat, dateAssumption) {

	var testDate = null;

	if(YAHOO.CXCalendarManager.hasYear(stringDate)== true){
		var dmy = /(\d{1,2})[-.\/ ](\d{1,2})[-.\/ ](\d{4})/;
		var mdy = /(\d{1,2})[-.\/ ](\d{1,2})[-.\/ ](\d{4})/;
		var ymd = /(\d{4})[-.\/ ](\d{1,2})[-.\/ ](\d{1,2})/;
	} else {
		var dmy = /(\d{1,2})[-.\/ ](\d{1,2})/;
		var mdy = /(\d{1,2})[-.\/ ](\d{1,2})/;
		var ymd = /(\d{1,2})[-.\/ ](\d{1,2})/;
	}

	if(YAHOO.CXCalendarManager.hasYear(stringDate) == false){

		var now = new Date();
		var year = now.getFullYear();
		var month;
		var day;

		if(dateFormat == "DayMonthYear") {
			valid = dmy.test(stringDate);
			month = parseInt(RegExp.$2);
			day = parseInt(RegExp.$1);

		} else if (dateFormat == "MonthDayYear") {
			valid = mdy.test(stringDate);
			month = parseInt(RegExp.$1);
			day = parseInt(RegExp.$2);

		} else if (dateFormat == "YearMonthDay") {
			valid = ymd.test(stringDate);
			month = parseInt(RegExp.$1);
			day = parseInt(RegExp.$2);
		}

		year = YAHOO.CXCalendarManager.shiftYear(year, month, day, YAHOO.CXCalendarManager.CXCalendarHandle.dateAssumption,
			YAHOO.CXCalendarManager.CXCalendarHandle.minDate, YAHOO.CXCalendarManager.CXCalendarHandle.maxDate);

		if(dateFormat == "DayMonthYear") {
			valid = dmy.test(stringDate);
			testDate = new Date(RegExp.$2 + "/" + RegExp.$1 + "/" + year);

		} else if (dateFormat == "MonthDayYear") {
			valid = mdy.test(stringDate);
			testDate = new Date(RegExp.$1 + "/" + RegExp.$2 + "/" + year);

		} else if (dateFormat == "YearMonthDay") {
			valid = ymd.test(stringDate);
			testDate = new Date(RegExp.$1 + "/" + RegExp.$2 + "/" + year);
		}

	} else {
		if(dateFormat == "DayMonthYear") {
			valid = dmy.test(stringDate);
			testDate = new Date(RegExp.$2 + "/" + RegExp.$1 + "/" + RegExp.$3);

		} else if (dateFormat == "MonthDayYear") {
			valid = mdy.test(stringDate);
			testDate = new Date(RegExp.$1 + "/" + RegExp.$2 + "/" + RegExp.$3);

		} else if (dateFormat == "YearMonthDay") {
			valid = ymd.test(stringDate);
			testDate = new Date(RegExp.$2 + "/" + RegExp.$3 + "/" + RegExp.$1);
		}
	}

	return testDate;
}

// test a string to see if it contains a valid date given a specific format
CXCalendarManager.prototype.isValidDate = function(stringDate, dateFormat, dateAssumption) {

	var valid = false;
	var testDate = null;

	var tday;
	var tmonth;
	var tyear;

	if(YAHOO.CXCalendarManager.hasYear(stringDate)  == true){
		var dmy = /(\d{1,2})[-.\/ ](\d{1,2})[-.\/ ](\d{4})/;
		var mdy = /(\d{1,2})[-.\/ ](\d{1,2})[-.\/ ](\d{4})/;
		var ymd = /(\d{4})[-.\/ ](\d{1,2})[-.\/ ](\d{1,2})/;
	} else {
		var dmy = /(\d{1,2})[-.\/ ](\d{1,2})/;
		var mdy = /(\d{1,2})[-.\/ ](\d{1,2})/;
		var ymd = /(\d{1,2})[-.\/ ](\d{1,2})/;
	}

	if(YAHOO.CXCalendarManager.hasYear(stringDate) == false){
		var now = new Date();
		tyear = now.getFullYear();

		if(dateFormat == "DayMonthYear") {
			valid = dmy.test(stringDate);
			tmonth = parseInt(RegExp.$2);
			tday = parseInt(RegExp.$1);

		} else if (dateFormat == "MonthDayYear") {
			valid = mdy.test(stringDate);
			tmonth = parseInt(RegExp.$1);
			tday = parseInt(RegExp.$2);

		} else if (dateFormat == "YearMonthDay") {
			valid = ymd.test(stringDate);
			tmonth = parseInt(RegExp.$1);
			tday = parseInt(RegExp.$2);
		}

		tyear = YAHOO.CXCalendarManager.shiftYear(tyear, tmonth, tday, YAHOO.CXCalendarManager.CXCalendarHandle.dateAssumption,
			YAHOO.CXCalendarManager.CXCalendarHandle.minDate, YAHOO.CXCalendarManager.CXCalendarHandle.maxDate);


		if(dateFormat == "DayMonthYear") {
			testDate = new Date(RegExp.$2 + "/" + RegExp.$1 + "/" + tyear);

		} else if (dateFormat == "MonthDayYear") {
			testDate = new Date(RegExp.$1 + "/" + RegExp.$2 + "/" + tyear);

		} else if (dateFormat == "YearMonthDay") {
			testDate = new Date(RegExp.$1 + "/" + RegExp.$2 + "/" + tyear);
		}


	} else {
		if(dateFormat == "DayMonthYear") {
			valid = dmy.test(stringDate);
			testDate = new Date(RegExp.$2 + "/" + RegExp.$1 + "/" + RegExp.$3);

			tday = parseInt(RegExp.$1);
			tmonth = parseInt(RegExp.$2);
			tyear = parseInt(RegExp.$3);

		} else if (dateFormat == "MonthDayYear") {
			valid = mdy.test(stringDate);
			testDate = new Date(RegExp.$1 + "/" + RegExp.$2 + "/" +RegExp.$3);

			tday = parseInt(RegExp.$2);
			tmonth = parseInt(RegExp.$1);
			tyear = parseInt(RegExp.$3);

		} else if (dateFormat == "YearMonthDay") {
			valid = ymd.test(stringDate);
			testDate = new Date(RegExp.$2 + "/" + RegExp.$3 + "/" + RegExp.$1);

			tday = parseInt(RegExp.$3);
			tmonth = parseInt(RegExp.$2);
			tyear = parseInt(RegExp.$1);
		}
	}

	if(valid == true) {
		var day = testDate.getDate();
		var month = testDate.getMonth() + 1;
		var year = testDate.getFullYear();

		valid = ((tday == day) && (tmonth == month) && (tyear == year));

	}

	return valid;
}

// handle changes to date select fields (populate calendar)
CXCalendarManager.prototype.updateCalendar = function(initial) {

	if(YAHOO.CXCalendarManager.updating == false && this.CXCalendarHandle) {
		YAHOO.CXCalendarManager.updating = true;

		// get a handle for the textbox
		var selDateBox = cx.byID(this.CXCalendarHandle.dateBoxID);

		var date = selDateBox.value;
		var realdate;
		var foundDate = false;
		var formatString = this.CXCalendarHandle.dateFormatString;
		var minDate = this.CXCalendarHandle.minDate;
		var maxDate = this.CXCalendarHandle.maxDate;

		foundDate = this.isValidDate(date,formatString,this.CXCalendarHandle.dateAssumption);

		if(foundDate == true) {

			realdate = this.parseDate(date,formatString,this.CXCalendarHandle.dateAssumption);

			var year = realdate.getFullYear();
			var month = realdate.getMonth() + 1;
			//var day = realdate.getDate();

			// We don't want to change what the user has entered, so I've removed this logic
			// that changes the date to the maximum or minimum date.  The user's input should 
			// be preserved and an error should be thrown if it's incorrect. -RAC 11.05.2007		
//			if(realdate<minDate){
//				date = this.CXCalendarHandle.minDate;
//				month = date.getMonth() + 1;
//				year = date.getFullYear();
//				this.CXCalendarHandle.setControls(date);
//			}

//			if(realdate>maxDate){
//				date = this.CXCalendarHandle.maxDate;
//				month = date.getMonth() + 1;
//				year = date.getFullYear();
//				this.CXCalendarHandle.setControls(date);
//			}

			// select the date and set paging
			this.YUICalendar.select(realdate);
			this.YUICalendar.cfg.setProperty("pagedate", month + "/" + year);
			this.YUICalendar.render();

		} else if (initial == true) {
			var now = new Date();
			if (now > maxDate) {
				this.YUICalendar.cfg.setProperty("pagedate", (maxDate.getMonth() + 1) + "/" + maxDate.getFullYear());
			} else if (now < minDate) {
				this.YUICalendar.cfg.setProperty("pagedate", (minDate.getMonth() + 1) + "/" + minDate.getFullYear());
			} else {
				this.YUICalendar.clear();
			}
		}

		YAHOO.CXCalendarManager.updating = false;
	}

};
CXCalendarManager.prototype.returnTextBox = null;
CXCalendarManager.prototype.whenTextBox = null;
CXCalendarManager.prototype.synchronizeDates = function(event)
{
    //alert('sync called');
    var target = YAHOO.util.Event.getTarget(event);
    if(null == target)
    {
    
    //alert(c);
    //alert(this.synchronizeDates.arguments);
    var type = this.arguments[0];
    var dates = this.arguments[1];
    this.calendar = this.arguments[2];
    // called from selectEvent.. 
    // 3 params:
    // [0] = type
    // [1] = args - args[0] = dates{array}; (ie args[0][0]=year args[0][1]=month args[0][2]=day.)
    // [2] = obj - should be the calendar object.
        //alert('called from selectEvent');
        //alert(this.calendar);
        return;
    }
    // the idea here is to make sure that the return date and the start dates 
    // month and year match. if they differ then lets synchronize them.
    if(null === CXCalendarManager.returnTextBox)
        return
    var date = new Date(CXCalendarManager.whenTextBox.value);
    var returnDate = new Date(CXCalendarManager.returnTextBox.value);
    if((date.getMonth() === returnDate.getMonth()) && (date.getFullYear() === returnDate.getFullYear()))
        return;
     if(date.getMonth() != returnDate.getMonth())
     {
        returnDate.setMonth(date.getMonth());
     }
     if(date.getFullYear() != returnDate.getFullYear())
     {
        returnDate.setFullYear(date.getFullYear());
     }
     
     YAHOO.CXCalendarManager.findCalendar(CXCalendarManager.returnTextBox.id).setControls(returnDate)
}
// add a calendar handle
CXCalendarManager.prototype.addCalendar = function(calendarButtonID, dateBoxID,startDate, minDate, maxDate,
	allowNull, dateFormatString, dateAssumption, isReturnPicker, childCalendarDateBoxID) {
	// create CXCalendar handler object
	var cal = new CXCalendar(
		calendarButtonID,
		this.calendars.length,
		dateBoxID,
		startDate,
		minDate,
		maxDate,
		allowNull,
		dateFormatString,
		dateAssumption,
		isReturnPicker,
		childCalendarDateBoxID
	);
	// append to our collection
	this.calendars.push(cal);
	/// commented this out for now.. some restructure needs to happen here.
//    if(hasChildCalendar === true)
//    {
//        //CXCalendarManager.returnTextBox = cx.byID(dateBoxID);
//    }
//    else
//    {
//        try
//        {
//	        //var bool = YAHOO.util.Event.addListener(dateBoxID, 'onchange', this.synchronizeDates, this, this);
//	    }
//	    catch(e)
//	    {	    
//	    }
	    
	YAHOO.CXCalendarManager.setEmptyFieldFormatStringWithElement(cx.byID(dateBoxID));
	
	// add a listener to the button
	YAHOO.util.Event.addListener(calendarButtonID, 'click', this.showCalendar, this, this);
	YAHOO.util.Event.addListener(dateBoxID, 'blur', this.setEmptyFieldFormatString, this, this);
	YAHOO.util.Event.addListener(dateBoxID, 'focus', this.showCalendar, this, this);	
	YAHOO.util.Event.addListener(dateBoxID, 'blur', this.hideCalendarBlur, this, this);
	YAHOO.util.Event.addListener(dateBoxID, 'keydown', this.hideCalendarKeyDown, this, this);
};

var suspendblur = false;

CXCalendarManager.prototype.hide = function(calendar) {
	if(YAHOO.CXCalendarManager.CXCalendarHandle) {
		YAHOO.CXCalendarManager.setEmptyFieldFormatStringWithElement(cx.byID(YAHOO.CXCalendarManager.CXCalendarHandle.dateBoxID));
	}
	calendar.hide();
}

CXCalendarManager.prototype.setEmptyFieldFormatStringWithElement = function (dateBox) {
	// get the date box element	
	if(dateBox) {
		
		var formatString = YAHOO.CXCalendarManager.findCalendar(dateBox.id).dateFormatString;
	
		// if we have an empty date field on a blur event, display the format string until the field gets focus again
		if(dateBox.value == ""){
			if(formatString == "DayMonthYear"){
				dateBox.value=YAHOO.CXCalendarManager.emptyFormatStringDMY;
			} else if (formatString == "MonthDayYear"){
				dateBox.value=YAHOO.CXCalendarManager.emptyFormatStringMDY;
			} else if (formatString == "YearMonthDay") {
				dateBox.value=YAHOO.CXCalendarManager.emptyFormatStringYMD;
			}
		}
		if(dateBox.value == YAHOO.CXCalendarManager.emptyFormatStringDMY ||
			dateBox.value == YAHOO.CXCalendarManager.emptyFormatStringMDY ||
			dateBox.value == YAHOO.CXCalendarManager.emptyFormatStringYMD) {
			setGray(dateBox);
		}
	}

}
CXCalendarManager.prototype.setFieldColor = function (dateBox) {
		if(dateBox.value == YAHOO.CXCalendarManager.emptyFormatStringDMY ||
			dateBox.value == YAHOO.CXCalendarManager.emptyFormatStringMDY ||
			dateBox.value == YAHOO.CXCalendarManager.emptyFormatStringYMD) {
			setGray(dateBox);
		} else {
			setBlack(dateBox,YAHOO.CXCalendarManager.initialTextFieldColor,YAHOO.CXCalendarManager.initialTextFieldClass);
		}	
}
function getInheritedColor(element){
    while(element)
    {
        var ret;
        if (element.currentStyle)
        {
		    ret = element.currentStyle["color"];
		    if(ret.length>0)
		    return ret;
	    }
	    else if (window.getComputedStyle)
	    {
		    ret = document.defaultView.getComputedStyle(element,null).getPropertyValue("color");
		    if(ret.length>0)
		    return ret;
	    }    
    }
}
function getInheritedClass(element){
    while(element)
    {
    if( element.className && element.className.length > 0 )
    {
        return element.className;
    }
        if(element.parentNode)
            element = element.parentNode;        
        else
            element = element.parentElement;       
    }
}
CXCalendarManager.prototype.initialTextStyle = false;
CXCalendarManager.prototype.initialTextFieldColor = null;
CXCalendarManager.prototype.initialTextFieldClass = null;
function initDefaultTextStyle(dateBox){        
    YAHOO.CXCalendarManager.initialTextStyle = true;
    var color = dateBox.style.color
    if( (null === YAHOO.CXCalendarManager.initialTextFieldColor) && (!color || color.length <=0) )
    {
        color = getInheritedColor(dateBox);
        YAHOO.CXCalendarManager.initialTextFieldColor = color;  
    }
    if( (null === YAHOO.CXCalendarManager.initialTextFieldClass) && (!color || color.length <=0) )
    {
        color = getInheritedClass(dateBox);   
        YAHOO.CXCalendarManager.initialTextFieldClass = color;   
     }   
     else if (false ===   YAHOO.CXCalendarManager.initialTextFieldColor)
        YAHOO.CXCalendarManager.initialTextFieldColor = "#000000";
}
function setGray (dateBox) {  
	if(dateBox)
		dateBox.style.color = "#cccccc";
}

function setBlack (dateBox,color,className) {

    if(null === className && null === color)
    {
		dateBox.style.color = color;
    }
    else if(null != color && color.length >= 0) 
	{
	    dateBox.style.color = color;
	}
	else if(null != className && className.length >= 0)
	{
	    dateBox.style.color = "";
	    dateBox.className = className;
	}
	else
	{
	    dateBox.style.color = "#000000";
	}
}

CXCalendarManager.prototype.setEmptyFieldFormatString = function (event) {

	// parse some event params
	var eventTarget = YAHOO.util.Event.getTarget(event);
	var eventTargetID = eventTarget.id;

	var dateBox = cx.byID(eventTargetID);
	
	YAHOO.CXCalendarManager.setEmptyFieldFormatStringWithElement(dateBox);

}

/* 
hide a calendar -- there are three methods you can call to hide a calendar:
	hideCalendar:  this is a basic method to just hide a calendar.
	hideCalendarKeyDown:	this is used to hide a calendar on a keyDown event.  This method temporarily suspends 
						the blur event so that if you click the calendar after typing in the field, the 
						calendar isn't immediately hidden by the blur event.
	hideCalendarBlur:  this method hides the calendar if the blur event isn't suspended.  If it is suspended,
						all it does is remove the suspension and wait for the next blur event to trigger.
*/

CXCalendarManager.prototype.hideCalendarKeyDown = function(event) {
	if(this.CXCalendarHandle) {
		var dateBox = cx.byID(this.CXCalendarHandle.dateBoxID);
		setBlack(dateBox,YAHOO.CXCalendarManager.initialTextFieldColor,YAHOO.CXCalendarManager.initialTextFieldClass);
	}
	this.hideCalendar(event);
	suspendblur = true;
}
CXCalendarManager.prototype.hideCalendarBlur = function(event) {
	if(!suspendblur){
		this.hideCalendar(event);
	}
	suspendblur = false;
}
CXCalendarManager.prototype.hideCalendar = function(event) {
	var eventTarget = YAHOO.util.Event.getTarget(event);
	this.calendarToClose = eventTarget.id;
	setTimeout("YAHOO.CXCalendarManager.reallyHideCalendar()", 200);
	
}

CXCalendarManager.prototype.reallyHideCalendar = function() {
    if(suspendblur) {suspendblur = false; return};// if during the time out something tells the calendar to stay open then return.
	// if we already have a calender handle
	if(this.CXCalendarHandle != null) {

		if((this.CXCalendarHandle.dateBoxID == this.calendarToClose) && (this.YUICalendar.visible() == true)){

			this.YUICalendar.selectEvent.unsubscribeAll();

			this.calendarToClose = null;

			// hide the calendar
			this.YUICalendar.hide();

			// null our handle
			this.CXCalendarHandle = null;
		}
	}
}

// get the X position of an element
CXCalendarManager.prototype.findPosX = function(obj)
{
	var curleft = 0;
	if(obj.offsetParent) {
		while(1) {
			curleft += obj.offsetLeft;
			if(!obj.offsetParent) {
				break;
			}
			obj = obj.offsetParent;
		}
	} else if(obj.x) {
		curleft += obj.x;
	}
	return curleft;
}

// get the Y position of an element
CXCalendarManager.prototype.findPosY = function(obj)
{
	var curtop = 0;
	if(obj.offsetParent) {
		while(1) {
			curtop += obj.offsetTop;
			if(!obj.offsetParent) {
				break;
			}
			obj = obj.offsetParent;
		}
	} else if(obj.y) {
		curtop += obj.y;
	}

	return curtop;
}

// show a calendar
CXCalendarManager.prototype.showCalendar = function(event) {
	// parse some event params
	var eventTarget = YAHOO.util.Event.getTarget(event);
	var eventButtonID = eventTarget.parentNode.id;
	var eventTargetID = eventTarget.id;
	var isClick = (event.type == 'click');
	var isFocus = (event.type == 'focus');
	var pageX = 0;
	var pageY = 0;

	// if the event was a click on the calendar button we can just get
	// the coordinates of where the event came from
	if(isClick) {
		pageX = YAHOO.util.Event.getPageX(event);
		pageY = YAHOO.util.Event.getPageY(event);

	// otherwise, we caught a focus event, which originates at 0,0
	// so we actually have to find the coordinates of the textbox
	} else {
		pageX = CXCalendarManager.prototype.findPosX(YAHOO.util.Event.getTarget(event)) + 100;
		pageY = CXCalendarManager.prototype.findPosY(YAHOO.util.Event.getTarget(event)) + 15;

	}

	var previousButtonID = null;
	var previousVisible = this.YUICalendar.visible();

	// if we already have a calender handle
	if(this.CXCalendarHandle != null) {

		if(this.YUICalendar.visible() == true){

			// hide the calendar
			this.YUICalendar.hide();
		}

		// unsubscribe from all events
		this.YUICalendar.selectEvent.unsubscribeAll();

		previousButtonID = this.CXCalendarHandle.calendarButtonID;

		// null our handle
		this.CXCalendarHandle = null;
	}

	// if the click came from the button associated with the calendar we just had open,
	// don't waste cpu cycles opening what we just closed -- calendar buttons act like toggles
	if(eventButtonID == previousButtonID && previousVisible == true) {

		return;

	// if the click is on a different button, show it
	} else {

		// find the new calendar we want
		for (i = 0; i < this.calendars.length; i++) {
			if(this.calendars[i].calendarButtonID != null && this.calendars[i].dateBoxID != null) {
				if (this.calendars[i].calendarButtonID == eventButtonID || this.calendars[i].dateBoxID == eventTargetID) {
					this.CXCalendarHandle = this.calendars[i];
					break;
				}
			}
		}
		
		// if we found a calendar handle
		if(this.CXCalendarHandle){
		
			// get the date box element
			var dateBox = cx.byID(this.CXCalendarHandle.dateBoxID);
		
			// if it was populated with a format string (i.e. not holding a date)
			// clear the format string
			if(dateBox.value == YAHOO.CXCalendarManager.emptyFormatStringMDY ||
				dateBox.value == YAHOO.CXCalendarManager.emptyFormatStringDMY ||
				dateBox.value == YAHOO.CXCalendarManager.emptyFormatStringYMD){
				dateBox.value = "";
			}
		}

		// if we don't have a starting date, clear the calendar
		if(this.CXCalendarHandle.startDate == null){
			this.YUICalendar.clear();
		}

		// set the minimum allowable date if applicable
		if(this.CXCalendarHandle.minDate != null) {
			this.YUICalendar.cfg.setProperty("mindate",this.CXCalendarHandle.minDate);
		}

		// set the maximum allowable date if applicable
		if(this.CXCalendarHandle.maxDate != null) {
			this.YUICalendar.cfg.setProperty("maxdate",this.CXCalendarHandle.maxDate);
		}

		// update the calendar to match whatever is in the select fields
		this.updateCalendar(true);

		// subscribe the dropdowns to a select event
		this.YUICalendar.selectEvent.subscribe(this.handleSelect, this, true);

		// ensure calendar is fully displayed on screen		
		var screenBot = (parseInt(document.documentElement.scrollTop ? document.documentElement.scrollTop : document.body.scrollTop) + parseInt(YAHOO.util.Dom.getViewportHeight()));
		
		var posx = (pageX - 6);
		var posy = pageY;
		
		if((posy + this.calHeight) > screenBot){
			posy = screenBot - this.calHeight;
		}
			
		// render and show calendar
		this.YUICalendar.render();
		this.YUICalendar.show();
        this.applyListners();

		// position calendar where the click came from
		// (offset the position a few pixels so a click in the
		// exact same spot closes the calendar)
		this.calendarContainer.style.left = posx + "px";
		this.calendarContainer.style.top = posy + "px";
	}
};


// CXCalendar calendar handler
function CXCalendar(calendarButtonID, calIndex, dateBoxID, startDate, minDate, maxDate,
	allowNull, dateFormatString, dateAssumption, isReturnPicker, childDateBoxID) {
	this.isReturnPicker = isReturnPicker;
	this.childCalendarDateBoxID = childDateBoxID;
	//this is our hook into the CalendarManager
	var CalendarCreatedObject = new Object();
	CalendarCreatedObject.calendar = this;
	CalendarCreatedObject.manager = YAHOO.CXCalendarManager;
	CalendarCreatedObject.OnCreated = function()
	{  
	        var c = YAHOO.CXCalendarManager.YUICalendar;
	        //alert(c);
	        if(null == c)
	            //alert('yuicalendar = null');
	        if(null != c && !c.IsRegisteredForClick)
	        {
	            c.IsRegisteredForClick = true;
	            //this.calendar
	            //alert(YAHOO.CXCalendarManager.synchronizeDates);
	            var textbox = cx.byID(this.calendar.dateBoxID);
	            c.selectEvent.subscribe(this.calendar.selectTextBox, c, textbox);
	        }
	        
	    
	}
	    CXCalendarManager.OnCreateContainer.push(CalendarCreatedObject);
	
	this.calendarButtonID = calendarButtonID;
	this.calIndex = calIndex;
	this.dateBoxID = dateBoxID;

	if(startDate == null)
		this.startDate = new Date();
	else
		this.startDate = new Date(startDate);

	this.minDate = new Date(minDate);
	this.maxDate = new Date(maxDate);

	this.allowNull = allowNull;
	this.dateFormatString = dateFormatString;

	if(dateAssumption == 'Future')
		this.dateAssumption = 1;
	else if (dateAssumption == 'Past')
		this.dateAssumption = -1;
	else
		this.dateAssumption = 0;
	
	var dateBox = cx.byID(dateBoxID);
	if(dateBox) {      
	    dateBox.calendar = this;
        if(false === YAHOO.CXCalendarManager.initialTextStyle)
            initDefaultTextStyle(dateBox);
		    // if we have an empty date field, display the format string until the field gets focus again
	    if(dateBox.value == ""){
		    if(this.dateFormatString == "DayMonthYear"){
			    dateBox.value=YAHOO.CXCalendarManager.emptyFormatStringDMY;
		    } else if (this.dateFormatString == "MonthDayYear"){
			    dateBox.value=YAHOO.CXCalendarManager.emptyFormatStringMDY;
		    } else if (this.dateFormatString == "YearMonthDay") {
			    dateBox.value=YAHOO.CXCalendarManager.emptyFormatStringYMD;
		    }
		    setGray(dateBox);
		}
	}
};
CXCalendar.prototype.hasChild = function()
{
    if(null != this.childCalendarDateBoxID && null == this.childCalendar)
        for(var i = 0; i < YAHOO.CXCalendarManager.calendars.length; ++i)
	    {
            if(YAHOO.CXCalendarManager.calendars[i].dateBoxID == this.childCalendarDateBoxID)
            {
                this.childCalendar = YAHOO.CXCalendarManager.calendars[i];
            }
	    }
    if(null != this.childCalendar)
        return true
    return false;
}
CXCalendar.prototype.childCalendarDateBoxID = null;
CXCalendar.prototype.childCalendar = null;


CXCalendar.prototype.selectTextBox = function(type, dateobj, object)
{
    var dates = dateobj[0];
    var date = dates[0];
    var month = date[2];
    var day = date[1];
    var year = date[0];
    //alert(this.calendar.dateBoxID);
    //object.parentNode.innerHTML += month;
}
// set the html controls to a given date
CXCalendar.prototype.setControls = function(date) {

    // get handle for the field
    var selDate = cx.byID(this.dateBoxID);

    var dateString = "";

    if (date != null) {
        var year = date.getFullYear();
        var month = date.getMonth() + 1;
        var day = date.getDate();

        if (this.dateFormatString == "DayMonthYear") {
            dateString = date.getDate() + "/" + (date.getMonth() + 1) + "/" + date.getFullYear();
        } else if (this.dateFormatString == "MonthDayYear") {
            dateString = (date.getMonth() + 1) + "/" + date.getDate() + "/" + date.getFullYear();
        } else if (this.dateFormatString == "YearMonthDay") {
            dateString = date.getFullYear() + "/" + (date.getMonth() + 1) + "/" + date.getDate();
        }
    }
    selDate.value = dateString;
};


function CXCalendarEmptyLegRange(checkBoxID, startDateBoxID, endDateBoxID){
	this.checkBox = cx.byID(checkBoxID);
	this.startDateBoxID = startDateBoxID;
	this.endDateBoxID = endDateBoxID;
};

CXCalendarManager.prototype.addEmptyLegRange = function(checkBoxID, startDateBoxID, endDateBoxID) {
	var leg = new CXCalendarEmptyLegRange(checkBoxID, startDateBoxID, endDateBoxID);

	this.legs.push(leg);

	YAHOO.util.Event.addListener(checkBoxID, 'change', this.setEmptyLegDates, this, this);
	YAHOO.util.Event.addListener([startDateBoxID, endDateBoxID], 'blur', this.setEmptyLegDates, this, this);
};

CXCalendarManager.prototype.setEmptyLegDates = function (event) {
	var eventTarget = YAHOO.util.Event.getTarget(event);
	var eventTargetID = eventTarget.id;

	var leg = null;

	for (i = 0; i < YAHOO.CXCalendarManager.legs.length; i++) {
		if(YAHOO.CXCalendarManager.legs[i].checkBox != null) {
			if (YAHOO.CXCalendarManager.legs[i].checkBox.id == eventTargetID ||
				YAHOO.CXCalendarManager.legs[i].startDateBoxID == eventTargetID ||
				YAHOO.CXCalendarManager.legs[i].endDateBoxID == eventTargetID) {
				leg = YAHOO.CXCalendarManager.legs[i];
				break;
			}
		}
	}

	if(event.type == "change"){
		if(leg.checkBox.checked && eventTargetID == leg.checkBox.id){
			YAHOO.CXCalendarManager.findCalendar(leg.startDateBoxID).setControls(null);
			YAHOO.CXCalendarManager.findCalendar(leg.endDateBoxID).setControls(null);
		}
	} else if (event.type == "blur" && eventTarget.value.length > 0) {
		if(leg.checkBox.checked && (eventTargetID == leg.startDateBoxID || eventTargetID == leg.endDateBoxID))
		{
			leg.checkBox.checked = false;
			var now = new Date();

			YAHOO.CXCalendarManager.findCalendar(leg.startDateBoxID).setControls(
				new Date( now.valueOf() + 1*24*60*60*1000 )
			);

			YAHOO.CXCalendarManager.findCalendar(leg.endDateBoxID).setControls(
				new Date( now.valueOf() + 4*24*60*60*1000 )
			);
		}
	}
};

CXCalendarManager.prototype.findCalendar = function(dateBoxID){
	for (i = 0; i < YAHOO.CXCalendarManager.calendars.length; i++) {
		if(YAHOO.CXCalendarManager.calendars[i].dateBoxID != null) {
			if (YAHOO.CXCalendarManager.calendars[i].dateBoxID == dateBoxID) {
				return YAHOO.CXCalendarManager.calendars[i];
			}
		}
	}
};

function CXCalendarRangePicker(rangeSelectID, startPicker, endPicker){
	this.rangeSelectID = rangeSelectID;
	this.startPicker = startPicker;
	this.endPicker = endPicker;
};

CXCalendarManager.prototype.addPicker = function(rangeSelectID, startDateBoxID, endDateBoxID) {
	var picker = new CXCalendarRangePicker(
		rangeSelectID,
		startDateBoxID,
		endDateBoxID
	);

	this.pickers.push(picker);

	YAHOO.util.Event.addListener(rangeSelectID, 'change', this.setPickersToRange, this, this);
	YAHOO.util.Event.addListener([startDateBoxID,endDateBoxID], 'change', this.updatePickerRanges, this, this);
};

CXCalendarManager.prototype.updatePickerRanges = function(event) {
	var eventTargetID = YAHOO.util.Event.getTarget(event).id;
	YAHOO.CXCalendarManager.updateRanges(eventTargetID);
};

CXCalendarManager.prototype.updateRanges = function(datebox) {
	if(YAHOO.CXCalendarManager.pickers == null || YAHOO.CXCalendarManager.pickers.length == 0)
		return;

	var picker = null;

	for(i=0;i<YAHOO.CXCalendarManager.pickers.length;i++){
		if(datebox == YAHOO.CXCalendarManager.pickers[i].startPicker || datebox == YAHOO.CXCalendarManager.pickers[i].endPicker){
			picker = YAHOO.CXCalendarManager.pickers[i];
			break;
		}
	}

	if(picker){
		var startdate = cx.byID(picker.startPicker);
		var enddate = cx.byID(picker.endPicker);
		var range = cx.byID(picker.rangeSelectID);
		var datestring = startdate.value + ";" + enddate.value;

		// On the Broker Inventory page, range is null.  To resolve an issue where 
		// only the first date selection on the page would work, I added the if(range) 
		// logic.  Is this something that should be deleted?  -RAC 11.05.2007
		if(range)
		{
			for (idx = 0; idx < range.options.length; idx++)
			{
				if (range.options[idx].value == datestring)
				{
					range.selectedIndex = idx;
					return;
				}
			}
			range.selectedIndex = 0;
		}
	}

};

CXCalendarManager.prototype.setPickersToRange = function(event) {
	// parse some event params
	var eventTarget = YAHOO.util.Event.getTarget(event);
	var eventTargetID = eventTarget.id;

	var startPicker;
	var endPicker;

	var startDate;
	var endDate;

	var dropdown = cx.byID(eventTargetID);

	if(dropdown && dropdown.value){
		startDate = dropdown.value.split(";")[0];
		endDate = dropdown.value.split(";")[1];

		var picker;

		for(i=0;i<this.pickers.length;i++){
			if(eventTargetID == this.pickers[i].rangeSelectID){
				picker = this.pickers[i];
				break;
			}
		}

		if(picker){
			startPicker = cx.byID(picker.startPicker);
			endPicker = cx.byID(picker.endPicker);

			if(startPicker && endPicker) {
				startPicker.value = startDate;
				endPicker.value = endDate;
				this.setFieldColor(startPicker);
				this.setFieldColor(endPicker);
			}
		}
	}
};


/** extending YAHOO to give us some helper functions
* Hides the Calendar's outer container from view.
* @method hide
*/
YAHOO.widget.Calendar.prototype.visible = function() {
	if(this.oDomContainer.style.display == "none")
		return false;
	return true;
};


// instantiate our calendar manager somehwere nice and shared like the YAHOO namespace
YAHOO.CXCalendarManager = new CXCalendarManager();
//Changed to window load event; this was onDomReady, but IE returns true too early when in an IFrame
YAHOO.util.Event.addListener(window, 'load', YAHOO.CXCalendarManager.createContainer,YAHOO.CXCalendarManager,true);