/************************************************************************************************/
/* Common Functions                                                                             */
/************************************************************************************************/

/// <summary>
/// Call Method on a Class
/// </summary>
/// <param name="elementId">element id</param>
/// <param name="func">function name</param>
/// <param name="param">parameter</param>
/// <returns>dom element</returns>
function Msfg$callFunction(elementId ,func, param)
{
    var c = Sys.Application.getComponents();
    for (var i=0; i<c.length; i++) {
        if (c[i].get_id() == elementId)
        {
            eval("c[" + i + "]." + func).call(c[i],param);
        }
    }
}

/// <summary>
/// Create Element
/// </summary>
/// <param name="element">element name</param>
/// <returns>dom element</returns>
function Msfg$createElement(element)
{
 // thanks to Simon Willison...
  if (typeof document.createElementNS != 'undefined') {
    return document.createElementNS('http://www.w3.org/1999/xhtml', element);
  }
  if (typeof document.createElement != 'undefined') {
    return document.createElement(element);
  }
  return false;
}

/// <summary>
/// Round number
/// </summary>
/// <param name="number">Number to round</param>
/// <param name="toNearest">Round to the nearest</param>
/// <returns>Rounded number</returns>
function Msfg$round(number, toNearest, maximumDecimalCount) 
{
    var num = Math.round(number / toNearest) * toNearest;
    
    return num.toFixed(maximumDecimalCount);
}

/// <summary>
/// Removes a class name from a space
/// seperated list of class names.
/// </summary>
/// <param name="classNames">List of class names</param>
/// <param name="className">Class name to remove</param>
/// <returns>Processed string</returns>
function Msfg$removeClassName(classNames, className) 
{
    var classNameArray = classNames.split(" ");
  
    for(var i = 0; i < classNameArray.length; i++)
    {
       var currentClassName = classNameArray[i];
      
       if (currentClassName.length > 0)
       {
           if(currentClassName == className)
           {
              // Remove the CSS class.  
             classNameArray.splice(i, 1);
           }
       }
  }
  
  return classNameArray.join(" ");
}

/// <summary>
/// Clear the text year from a textbox on click.
/// </summary>
/// <param name="sender">Control to manipulate</param>
/// <param name="text">The prompt text</param>
/// <param name="params">Parameter values - maximum length of the field, and the function (blur/focus) calling the method.</param>
function Msfg$toggleTemporaryInputText(sender, text, params) {
	var value = sender.value;
	var leftTrimmedValue = value.replace(/^\s+/,""); 
	var type = params.type;
	if (text.length > params.maxLength)
		text = text.substring(0, params.maxLength);
	
	if (type == "blur" && (leftTrimmedValue == "" || leftTrimmedValue == text)) {
		// Losing focus and the field is empty or the user has typed in the prompt text (?!).
		sender.className += " msfg-placeholder";
		sender.value = text;
	} else if (type == "focus" && leftTrimmedValue == text) {
		// Gaining focus and the field has the the prompt text.
		sender.className = Msfg$removeClassName(sender.className, "msfg-placeholder");
		sender.value = "";
	} else {
		if (leftTrimmedValue != text) {
			sender.className = Msfg$removeClassName(sender.className, "msfg-placeholder");
		}
	}
}

/// <summary>
/// The click imitate element behaviour 
/// by first calling the onclick() method (OnClientClick attribute of the Button)
/// </summary>
/// <param name="sender">Control to manipulate</param>
function Msfg$SumbitFormEnter(event,target){
    if (event.keyCode == 13 && !(event.srcElement && (event.srcElement.tagName.toLowerCase() == "textarea"))) {

        var defaultButton = document.getElementById(target);
        
        if (defaultButton && typeof(defaultButton.click) != "undefined") {
            defaultButton.click();
            event.cancelBubble = true;
            event.returnValue = false;
        }
    }
    return true;
}

/// <summary>
/// Adjust the value to be in range..
/// </summary>
/// <param name="sender">Control to manipulate</param>
/// <param name="toNearest">Round to the nearest</param>
function Msfg$numericFieldAdjust(sender, minimum, maximum)
{
    var value = sender.value;
    if(value < minimum)
    {
        sender.value = minimum;
    }
    else if(value > maximum)
    {   
        sender.value = maximum;
    }
}

/// <summary>
/// Round numeric feilds value.
/// </summary>
/// <param name="sender">Control to manipulate</param>
/// <param name="toNearest">Round to the nearest</param>
function Msfg$numericFieldRoundNumber(sender, toNearest, minimum, maximumDecimalCount)
{
    var value = sender.value;
    sender.value = Msfg$round(value, toNearest, maximumDecimalCount);
    //If the value is Nan, set it to the minimum value.
    if(isNaN(sender.value))
    {
        sender.value = minimum;
    }
}


/// <summary>
/// Remove non numeric characters from a numeric field.
/// </summary>
/// <param name="sender">Control to manipulate</param>
function Msfg$numericFieldCleanString(sender)
{
    var value = sender.value;
    
    var rx = new RegExp(/[^0-9.]/g);
    
    value = value.replace(rx, "");
    
    sender.value = value;
}

/// <summary>
/// Clean invalid characters from a string.
/// </summary>
/// <param name="sender">Control to manipulate</param>
function Msfg$cleanString(sender)
{
    var value = sender.value;
    
    var rx = new RegExp(/[\<\>]/g);
    
    value = value.replace(rx, "");
    
    sender.value = value;
}

/// <summary>
/// Update a hidden feild.
/// </summary>
/// <param name="id">id of the hidden field</param>
/// <param name="value"value to be set on the hidden field.</param>
function Msfg$updateHiddenField(id, value)
{
    var field = $get(id);
    field.value = value;
}

/************************************************************************************************/
/* Common Address Lookup Validation Functions                                                             */
/************************************************************************************************/

/// <summary>
/// Validates a addresslookup to make sure a value
/// has been selected.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customRequiredAddressLookupValidatorEvaluateIsValid(sender, args)
{ 
    var field = $get(sender.hiddenFieldId);
    
    args.IsValid = eval(field.value);
}

/************************************************************************************************/
/* Common Date Validation Functions                                                             */
/************************************************************************************************/

/// <summary>
/// Validates a date to make sure that it is 
/// a valid date.
/// </summary>
/// <param name="day">the day</param>
/// <param name="month">the month</param>
/// <param name="year">the year</param>
/// <returns>true; if valid date else false</returns>
function Msfg$validatorCheckDate(day, month, year)
{
    var isValid = true;
    
    var value = new Date();
    
    year = Msfg$getCentury(year);
    
    value.setFullYear(year,month,day); 

    if(year != value.getFullYear())
    {
        isValid = false;
    }

    if(month != value.getMonth())
    {
        isValid = false;
    }

    if(day != value.getDate())
    {
        isValid = false;
    }
    
    return isValid;
}

/// <summary>
/// Validates a date to make sure that all 
/// parts have been entered.
/// </summary>
/// <param name="day">the day</param>
/// <param name="month">the month</param>
/// <param name="year">the year</param>
/// <returns>true; if valid date else false</returns>
function Msfg$validatorRequiredCheck(day, month, year, initialYearValue)
{
    var isValid = true;
    
    if (day.length > 0)
    {
        if (month.length > 0)
        {
            if (!(year.length > 0  && year != initialYearValue ))
            {
                isValid = false;
            }
        }
        else
        {
            isValid = false;
        }
    }
    else
    {
        isValid = false;
    }
    
    return isValid;
}

/// <summary>
/// Checks for an entry.
/// </summary>
/// <param name="day">the day</param>
/// <param name="month">the month</param>
/// <param name="year">the year</param>
/// <returns>true; if valid date else false</returns>
function Msfg$validatorEntryCheck(day, month, year, initialYearValue)
{
    var entry = false;
    
    if (day.length > 0)
    {
        entry = true;
    }
    
    if (month.length > 0)
    {
        entry = true;
    }
    
    if (year.length > 0  && year != initialYearValue )
    {
        entry = true;
    }
    
    return entry;
}

/// <summary>
/// Checks to see if a date is not below
/// the minimum limit.
/// </summary>
/// <param name="day">the day</param>
/// <param name="month">the month</param>
/// <param name="year">the year</param>
/// <param name="daylimit">the day limit</param>
/// <param name="monthlimit">the month limit</param>
/// <param name="yearlimit">the year limit</param>
/// <returns>true; if valid date else false</returns>
function Msfg$validatorMinimumDateCheck(day, month, year, daylimit, monthlimit, yearlimit)
{
    var isValid = true;

    var value = new Date()
    value.setFullYear(year,month,day);
    
    var minimum = new Date()
    minimum.setFullYear(yearlimit,(monthlimit - 1),daylimit);
   
    if(value < minimum)
    {
        isValid = false;
    }
    
    return isValid;
}

/// <summary>
/// Checks to see if a date is not above
/// the maximum limit.
/// </summary>
/// <param name="day">the day</param>
/// <param name="month">the month</param>
/// <param name="year">the year</param>
/// <param name="daylimit">the day limit</param>
/// <param name="monthlimit">the month limit</param>
/// <param name="yearlimit">the year limit</param>
/// <returns>true; if valid date else false</returns>
function Msfg$validatorMaximumDateCheck(day, month, year, daylimit, monthlimit, yearlimit)
{
    var isValid = true;

    var value = new Date()
    value.setFullYear(year,month,day);
    
    var maximum = new Date()
    maximum.setFullYear(yearlimit,(monthlimit - 1),daylimit);
    
    if(value > maximum)
    {
        isValid = false;
    }
    
    return isValid;
}

/// <summary>
/// Get a date from string.
/// </summary>
/// <param name="value">string date value</param>
function Msfg$validatorGetDateFromString(value)
{
    var rx = new RegExp(/\s*(\d{1,2})\/(\d{1,2})\/(\d{2,4})\s*/); 
    
    var matches = rx.exec(value);
    
    if (matches != null && value == matches[0])
    {     
        var date = new Date()
        
         date.setFullYear(Msfg$getCentury(matches[3]), (matches[2] - 1), matches[1]); 
        
        return date;
    }
    else
    {
        return null;
    }
}

/// <summary>
/// Get a date from string. [SURF]
/// </summary>
/// <param name="value">string date value</param>
function Msfg$getCentury(year)
{
    if(year.length == 2)
    {
        var date = new Date();
        var currentCentury = Math.round(date.getFullYear() / 100).toString(); 
        year =  currentCentury + year;
	}
	return year;
}

/************************************************************************************************/
/* Month Year General & Validation Functions                                                    */
/************************************************************************************************/

/// <summary>
/// Validates a month year box to make sure a value
/// has been selected.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customRequiredMonthYearValidatorEvaluateIsValid(sender, args)
{
    var month = document.getElementById(sender.month).value;
    var year = document.getElementById(sender.year).value;
    
    args.IsValid = Msfg$validatorEntryCheck("", month, year, "Year");
}

/// <summary>
/// Validates a month year box to make sure the date is valid.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customMonthYearValidatorEvaluateIsValid(sender, args)
{
    var strMonth = document.getElementById(sender.month).value;
    var month = document.getElementById(sender.month).value - 1;
    var year = document.getElementById(sender.year).value;
    
    if(Msfg$validatorEntryCheck("", strMonth, year, "Year"))
    {
        args.IsValid = Msfg$validatorCheckDate(1, month, year);
    }
}

/// <summary>
/// Validates a month year string to make sure its greater
/// than or equal to the minimum.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customMinumumMonthYearValidatorEvaluateIsValid(sender, args) 
{
    var strMonth = document.getElementById(sender.month).value;
    var month = document.getElementById(sender.month).value - 1;
    var year = document.getElementById(sender.year).value;
    
    if(Msfg$validatorEntryCheck("", strMonth, year, "Year") && Msfg$validatorCheckDate(1, month, year))
    {
        args.IsValid = Msfg$validatorMinimumDateCheck(1, month, year, 1, sender.limitmonth, sender.limityear);
    }
}

/// <summary>
/// Validates a month year string to make sure its less
/// than or equal to the maximum.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customMaximumMonthYearValidatorEvaluateIsValid(sender, args) 
{
    var strMonth = document.getElementById(sender.month).value;
    var month = document.getElementById(sender.month).value - 1;
    var year = document.getElementById(sender.year).value;
    
    if(Msfg$validatorEntryCheck("", strMonth, year, "Year") && Msfg$validatorCheckDate(1, month, year))
    {
        args.IsValid = Msfg$validatorMaximumDateCheck(1, month, year, 1, sender.limitmonth, sender.limityear);
    }
}

/************************************************************************************************/
/* DateBox General & Validation Functions                                                       */
/************************************************************************************************/

/// <summary>
/// Validates a date box to make sure a value
/// has been selected.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customRequiredDateValidatorEvaluateIsValid(sender, args)
{
    var day = document.getElementById(sender.day).value;
    var month = document.getElementById(sender.month).value;
    var year = document.getElementById(sender.year).value;
    
    args.IsValid = Msfg$validatorEntryCheck(day, month, year, "Year");
}

/// <summary>
/// Validates a date box to make sure the date is valid.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customDateValidatorEvaluateIsValid(sender, args)
{
    var strMonth = document.getElementById(sender.month).value;   
    var day = document.getElementById(sender.day).value;
    var month = document.getElementById(sender.month).value - 1;
    var year = document.getElementById(sender.year).value;
    
    if(Msfg$validatorEntryCheck(day, strMonth, year, "Year"))
    {
        args.IsValid = Msfg$validatorCheckDate(day, month, year);
    }
}

/// <summary>
/// Validates a date string to make sure its greater
/// than or equal to the minimum.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customMinumumDateValidatorEvaluateIsValid(sender, args) 
{
    var strMonth = document.getElementById(sender.month).value;   
    var day = document.getElementById(sender.day).value;
    var month = document.getElementById(sender.month).value - 1;
    var year = document.getElementById(sender.year).value;
  
    if(Msfg$validatorEntryCheck(day, strMonth, year, "Year") && Msfg$validatorCheckDate(day, month, year))
    {   
        args.IsValid = Msfg$validatorMinimumDateCheck(day, month, year, sender.limitday, sender.limitmonth, sender.limityear);
    }
}

/// <summary>
/// Validates a date string to make sure its less
/// than or equal to the maximum.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customMaximumDateValidatorEvaluateIsValid(sender, args) 
{
    var strMonth = document.getElementById(sender.month).value;   
    var day = document.getElementById(sender.day).value;
    var month = document.getElementById(sender.month).value - 1;
    var year = document.getElementById(sender.year).value;
    
    if(Msfg$validatorEntryCheck(day, strMonth, year, "Year") && Msfg$validatorCheckDate(day, month, year))
    {
        args.IsValid = Msfg$validatorMaximumDateCheck(day, month, year, sender.limitday, sender.limitmonth, sender.limityear);
    }
}

/************************************************************************************************/
/* CalenderBox General & Validation Functions                                                   */
/************************************************************************************************/

/// <summary>
/// Validates a date string to make sure the date is valid.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customDateStringValidatorEvaluateIsValid(sender, args)
{
    args.IsValid = true;
    if(typeof(document.getElementById(sender.controltovalidate).defaultText) != "undefined" && document.getElementById(sender.controltovalidate).defaultText == args.Value) return;
    
    var rx = new RegExp(/\s*(\d{1,2})\/(\d{1,2})\/(\d{2,4})\s*/); //[SURF
    
    var matches = rx.exec(args.Value);
    
    if (matches != null && args.Value == matches[0])
    {
        args.IsValid = Msfg$validatorCheckDate(matches[1], (matches[2] - 1), matches[3]);    
    }
    else
    {
        args.IsValid = false;
    }
}

/// <summary>
/// Validates a date string to make sure its greater
/// than or equal to the minimum.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customMinumumDateStringValidatorEvaluateIsValid(sender, args) 
{
    args.IsValid = true;
    if(typeof(document.getElementById(sender.controltovalidate).defaultText) != "undefined" && document.getElementById(sender.controltovalidate).defaultText == args.Value) return;
    
    var limit = new Date();
    
    limit.setFullYear(sender.limityear,(sender.limitmonth - 1),sender.limitday);

    var value = Msfg$validatorGetDateFromString(args.Value);
    
    if(limit != null)
    {
        if(value < limit)
        {
            args.IsValid = false;
        }
    }
    else
    {
        args.IsValid = false;
    }
}

/// <summary>
/// Validates a date string to make sure its less
/// than or equal to the maximum.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customMaximumDateStringValidatorEvaluateIsValid(sender, args) 
{
    args.IsValid = true;
    if(typeof(document.getElementById(sender.controltovalidate).defaultText) != "undefined" && document.getElementById(sender.controltovalidate).defaultText == args.Value) return;
    
    var limit = new Date();
    
    limit.setFullYear(sender.limityear,(sender.limitmonth - 1),sender.limitday);

    var value = Msfg$validatorGetDateFromString(args.Value);

    if(limit != null)
    {
        if(value > limit)
        {
            args.IsValid = false;
        }
    }
    else
    {
        args.IsValid = false;
    }
}

/// <summary>
/// Validates that a CalendarBox is within the date ranges allowed by a second box.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param name="args">Event arguments</param>
function Msfg$customRestrictedDateValidatorEvaluateIsValid(sender, args)
{
    args.IsValid = true;
    if(typeof(document.getElementById(sender.controltovalidate).defaultText) != "undefined" && document.getElementById(sender.controltovalidate).defaultText == args.Value) return;
    
    var dateToRestrictBy = Msfg$validatorGetDateFromString(document.getElementById(sender.restrictionControl).value);
	  var dateToCheck = Msfg$validatorGetDateFromString(document.getElementById(sender.controltovalidate).value);
    if(dateToRestrictBy != null && dateToCheck != null)
    { 
        var minDifference = parseInt(sender.restrictionControlDifference);
    
        dateToCheck.setDate(dateToCheck.getDate()-minDifference);
        if(dateToCheck >= dateToRestrictBy)
        {
            args.IsValid = true;
        }
        else
        {
            args.IsValid = false;
        }
    }
}

function msfg$CalendarCallback(callback)
{
   if(callback){
       return true;
    }
    else{
       return false;
    }
}

/// <summary>
/// Call the calendar callback control if required Or
/// Restricts the days of one calendar box, based on the value of another.
/// </summary>
/// <param name="thisControl">The master calendar box</param>
/// <param name="controlToRestrict">The restricted calendar box</param>
/// <param name="minDays">The minimum days between the two boxes</param>
/// <param name="controlToExecute">The control to be executed for calendar callback</param>
/// <param name="callback">The calendar control call back functionality check</param>
function msfg$updateCalendarBox(thisControl, controlToRestrict, minDays, controlToExecute, callback)
{ 
      
    if(callback){
        Msfg$callFunction(controlToExecute,'Update', thisControl);
    }
    else{
    
        // Check the associated datePicker object is available (be safe)
        if(!(thisControl.id in datePickerController.datePickers)) {
                return;
        }

        // Add the minDays value to the restrictive date
        var dateTime = Msfg$validatorGetDateFromString(thisControl.value);
        
        if(dateTime == null) {
            return;
        }
        dateTime.setDate(dateTime.getDate()+minDays);
        // Create a formatted date to pass to the CalendarBox functions
        var days = String(dateTime.getDate());
        if(days.length == 1)
            days = "0" + days;
            
        var months = String(dateTime.getMonth()+1);

        if(months.length == 1)
            months = "0" + months; 
        var years = dateTime.getFullYear();
        var formattedDate = days + "/" + months + "/" + years;

        // Check the value of the input is a date of the correct format
        var dt = datePickerController.dateFormat(formattedDate, datePickerController.datePickers[thisControl.id].format.charAt(0) == "m");
        // If the input's value cannot be parsed as a valid date then return
        if(dt == 0) return;

        // Grab the value set within the endDate input and parse it using the dateFormat method
        // N.B: The second parameter to the dateFormat function, if TRUE, tells the function to favour the m-d-y date format
        var edv = datePickerController.dateFormat(document.getElementById(controlToRestrict).value, datePickerController.datePickers[controlToRestrict].format.charAt(0) == "m");

        // Grab the end date datePicker Objects
        var ed = datePickerController.datePickers[controlToRestrict];
        
        ed.setRangeLow( dt );
       
        // If theres a value already present within the end date input and it's smaller than the start date
        // then set the end date to the formatted date.      
        if(edv < dt) {
          if(typeof(ed.showOnInputFocus) == "undefined") {
            document.getElementById(controlToRestrict).value = formattedDate;
          } else {
            if(ed.showOnInputFocus == false) {
                document.getElementById(controlToRestrict).value = formattedDate;
            } else {
                ed.date = dateTime;
            } 
          }
        }
    }
}


/// <summary>
/// Initialises valid dates for all Calendar controls on this pages
/// Exclude the days and dates & min/max values.
/// </summary>
function msfg$initCalendarBoxes()
{   
     
     if(datePickerArray == ""){
           setTimeout("msfg$initCalendarBoxes()", 200);
          return;
     }

    for(var i=0; i<datePickerArray.length; i++ ) {
        var dp = datePickerController.datePickers[datePickerArray[i]];
        var ctrl = document.getElementById(datePickerArray[i]);

        if(typeof ctrl.excludedDays != "undefined" && typeof ctrl.excludedDates != "undefined"){
            dp.setDisabledDays(eval(ctrl.excludedDays));
            dp.setDisabledDates(eval(ctrl.excludedDates));
        }
        if(typeof ctrl.initMinDate != "undefined" && typeof ctrl.initMaxDate != "undefined"){
            dp.setRangeLow(eval(ctrl.initMinDate));   
            dp.setRangeHigh(eval(ctrl.initMaxDate));
        }
    }
   
}

/// <summary>
/// validate the excluded days and dates
/// </summary>
/// <param name="excludedDays">Excluded days</param>
/// <param name="excludedDates">Excluded dates</param>
function Msfg$customExcludedDateValidation(sender, args)
{
    args.IsValid = true;
    if(typeof(document.getElementById(sender.controltovalidate).defaultText) != "undefined" && document.getElementById(sender.controltovalidate).defaultText == args.Value) return;
    
   ctrl = document.getElementById(sender.controltovalidate);
   excludedDates = eval(ctrl.excludedDates);
   excludedDays = eval(ctrl.excludedDays);
    
   if(excludedDays != null){
       var date =  new Date(args.Value);
       for(var i = 0; i < excludedDays.length; i++){
         if(excludedDays[date.getDay()] == 1){
           args.IsValid = false;
         }
       }
   }

   if(excludedDates != null){
       var excludedDate = date.getFullYear() + date.getMonth() + date.getDate()
       for(var i = 0; i < excludedDates.length; i++){
         if(excludedDates[i]== excludedDate){
           args.IsValid = false;
         }
       }
   }
}

/************************************************************************************************/
/* Validation Highligher Function                                                               */
/************************************************************************************************/

/// <summary>
/// Highlights fields containers when they
/// the do not validate.
/// </summary>
/// <param name="validationGroup">Validation Group</param>
function Msfg$validationHighlighterOnSubmit(validationGroup)
{   
    // Check to make sure highliters have been registered
    if (typeof Page_ValidationHighlighters == "undefined") {
        return;
    }
    
    var highlighter;
    var control = Array();
    
    for (var i = 0; i < Page_ValidationHighlighters.length; i++) 
    {
        highlighter = Page_ValidationHighlighters[i];
        
        if (IsValidationGroupMatch(highlighter, validationGroup)) 
        {
            for (var v = 0; v < Page_Validators.length; v++) 
            {
                validator = Page_Validators[v];

                if (IsValidationGroupMatch(validator, validationGroup))
                {
                    Msfg$validationHighlighterRemoveErrorMessage(validator);
                }
            }
        }
    }
    
    for (var i = 0; i < Page_ValidationHighlighters.length; i++) 
    {
        highlighter = Page_ValidationHighlighters[i];
        
        if (!Page_IsValid && IsValidationGroupMatch(highlighter, validationGroup)) 
        {
            for (var v = 0; v < Page_Validators.length; v++) 
            {
                validator = Page_Validators[v];
                  
                if (!validator.isvalid && typeof(validator.errormessage) == "string" && IsValidationGroupMatch(validator, validationGroup)) 
                {
                    Msfg$validationHighlighterShowErrorMessage(validator);
                    if(validator.validationappearancetype == null || validator.validationappearancetype.toLowerCase() != "highlight")
                    {
                        break;
                    }
                }
            }
        }
    }
}

/// <summary>
/// Show a validation message from a highlightable container.
/// </summary>
/// <param name="validator">the validator</param>
function Msfg$validationHighlighterShowErrorMessage(validator)
{
	var errorMessageContainerId = validator.container + "_ErrorMessageContainer";
	
	if(document.getElementById(errorMessageContainerId) == null)
	{
		var validatorAppearance = (validator.validationappearancetype || "bubbleright");	// Default to bubbleright if the validator doesn't have the attribute.
	    if(validatorAppearance.toLowerCase() == "highlight")
        {
            // Container;
	        var container = document.getElementById(validator.container);
	    
	        // Create Error Message Container 
	        var errorMessageContainer = Msfg$createElement('div');
	        errorMessageContainer.id = errorMessageContainerId;
    	
	        // Create Error Message
	        var p = Msfg$createElement('p');
	        var text = document.createTextNode(validator.errormessage);
	    
            // Set Css Class on Parent Container.
            container.className = Msfg$removeClassName(container.className, "msfg-validationerror");
            container.className += " msfg-validationerror";
            
            // Create Control Hierachy
            p.appendChild(text);
            errorMessageContainer.appendChild(p);
            
            // Add Error Message Container Css Classes
            errorMessageContainer.className = "msfg-validationerror-text";
            container.appendChild(errorMessageContainer);
        }
        else
        {
			var targetControl = null;
			// Do we have an override for positioning the highlight control?
			if (validator.highlightagainst)
			{
				targetControl = validator.highlightagainst;
			}
			
			// Fallback/default positioning - against the control being validated.
			if (targetControl == null)
			{
				targetControl = validator.controltovalidate == null ? validator.year : validator.controltovalidate;
			}
			
            //var controlToValidate = validator.controltovalidate == null? validator.year : validator.controltovalidate;
	        //Add Error Message Container Css Classes
	        
	        //close any bubble thats been opened if any
	        floatValidation.close();
	        
	        if(validatorAppearance.toLowerCase() == "bubbleright")
	        {
	            //errorMessageContainer.className = 'msfg-floatvalidation msfg-floatvalidation-side';
	            floatValidation.display('side', targetControl, validator.errormessage);
	        }
	        else
	        {
	            //errorMessageContainer.className = 'msfg-floatvalidation';
	            floatValidation.display('below', targetControl, validator.errormessage);
	        }
        }
	}
}

/// <summary>
/// Remove a validation message from a highlightable container.
/// </summary>
/// <param name="validator">the validator</param>
function Msfg$validationHighlighterRemoveErrorMessage(validator)
{
    var errorMessageContainerId = validator.container + "_ErrorMessageContainer";
    var container = document.getElementById(validator.container);
    if (container) {
		container.className = Msfg$removeClassName(container.className, "msfg-validationerror");
	    
		if (!(document.getElementById(errorMessageContainerId) == null))
		{
			container.removeChild(document.getElementById(errorMessageContainerId))
		}
	}
}

/// <summary>
/// Gets the true position of the control.
/// </summary>
/// <param name="element">the element</param>
function truePosition(element) {
	var valueT = 0, valueL = 0;
	do {
		valueT += element.offsetTop  || 0;
		valueL += element.offsetLeft || 0;
		element = element.offsetParent;
		if (element) {
			p = Element.getStyle(element, 'position');
			if (p == 'relative' || p == 'absolute') break;
		}
	} while (element);
	return [valueL, valueT];
};

/// <summary>
/// True Position helper function.
/// </summary>
/// <param name="element">the element</param>
function realOffset(element) {
        var t = 0, l = 0;
        do {
                t += element.scrollTop  || 0;
                l += element.scrollLeft || 0;
                element = element.parentNode;
        } while (element);
        return [l, t];
};

/// <summary>Returns true if the specified element has been relatively positioned.</summary>
function isRelativeElement(element) {
	var position = element.style.position || "";
	if (position == "") {
		if (element.currentStyle && element.currentStyle.position) {
			position = element.currentStyle.position;
		} else if (typeof window.getComputedStyle == "function") {
			position = window.getComputedStyle(element, null).position;
		} else if (typeof document.defaultView != "undefined" && typeof document.defaultView.getComputedStyle == "function") {
			var interim = document.defaultView.getComputedStyle(element, null);
			if (typeof interim.position != "undefined")
				position = interim.position;
			else
				position = interim.getPropertyValue("position");
		}
	}
	
	return ((position || "").toLowerCase() == "relative");
}

/// <summary>
/// True Position helper function.
/// </summary>
/// <param name="element">the element</param>
function cumulativeOffset(element) {
        var t = 0, l = 0;
        
        do {
			if (isRelativeElement(element)) {
				// Relative positioned element without actual positioning - the browsers tend to incorrectly define this element as an offset parent.
			} else {
				t += element.offsetTop  || 0;
				l += element.offsetLeft || 0;
			}
			element = element.offsetParent;
        } while (element);
        return [l, t];
};

/// <summary>
/// Crestes the floating bubble and postions it
/// </summary>
var floatValidation = {

	floater : Object, // The actual floating div...
	ieframe : Object, // The iframe to hide selects in ie... 

	close : function()
	{   
	    if((this.floater != null) && (this.floater.parentNode != null))
	    {
		    this.floater.parentNode.removeChild(this.floater);
		    
		    if(document.getElementById("ieframe"))
		    {
    			this.ieframe.style.display='none';
		    }		
		}
	},

	renderIEframe : function()
	{
		var floaterPos = truePosition(this.floater);
		 if(!document.getElementById("ieframe"))
		 {
		         var loc = "javascript:'<html></html>'";
		         this.ieframe = document.createElement('iframe');
		         this.ieframe.src = loc;
		         this.ieframe.setAttribute('className','ieframe');
		         this.ieframe.scrolling="no";
		         this.ieframe.frameBorder="0";
		         this.ieframe.style.position="absolute";
		         this.ieframe.name = this.ieframe.id = "ieframe";
		         document.body.appendChild(this.ieframe);		
		 }
		 else
		 {
		         this.ieframe = document.getElementById("ieframe");
		 };

		// Iframe pos based on type...
		if(this.type=='side')
		{
			this.ieframe.style.left=(floaterPos[0] + 10) + 'px';
			this.ieframe.style.top=(floaterPos[1] + 12) + 'px';
			this.ieframe.style.height=(this.floater.offsetHeight - 22) + 'px';
			this.ieframe.style.width=(this.floater.offsetWidth + 7) + 'px';
		}
		else
		{
			this.ieframe.style.left=(floaterPos[0]) + 'px';
			this.ieframe.style.top=(floaterPos[1] + 9) + 'px';
			this.ieframe.style.height=(this.floater.offsetHeight - 19) + 'px';
			this.ieframe.style.width=(this.floater.offsetWidth + 7) + 'px';			
		}
		this.ieframe.style.filter='progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0)';
		this.ieframe.style.display='block';	
	},

	display : function(type,field,message)
	{
		this.type = type;
		var formField = document.getElementById(field);
		this.floater = document.createElement('div');
		this.floater.id='floatvalidationtest';
		var p = document.createElement('p');
		 
		var t = document.createTextNode(message);
		 
		var a = document.createElement('a');
		a.href="javascript:void(1);";
		a.onclick = function() {floatValidation.close()};
		a.appendChild(t);
		p.appendChild(a);
		this.floater.appendChild(p);
		this.floater.className=(type=='side' ? 'msfg-floatvalidation msfg-floatvalidation-side' : 'msfg-floatvalidation');
		 
		// new positioning
		var pos = truePosition(formField);
		if(this.type=='side')
		{
			this.floater.style.left=(pos[0] + formField.offsetWidth) + 'px';
			this.floater.style.top=(pos[1] - 15) + 'px';
		}
		else
		{
			this.floater.style.left=(pos[0] +5) + 'px';
			var topPos=pos[1] + formField.offsetHeight;				
			this.floater.style.top=topPos + 'px';
		}
	
		formField.parentNode.appendChild(this.floater);	
	}

}

// *** End positioning functions ***

/************************************************************************************************/
/* Help Functions                                                                               */
/************************************************************************************************/

/// <summary>
/// Toggle the view state of the help control.
/// </summary>
/// <param name="helpPanelId">help panel id</param>
/// <param anme="imageButtonId">help image button id</param>
function Msfg$toggleHelp(helpPanelId, imageButtonId)
{
	imageButton = document.getElementById(imageButtonId);
	helpPanel = document.getElementById(helpPanelId);
	
	if(helpPanel.className=='msfg-helplayer-active')
	{
		Msfg$closeHelp(helpPanel, imageButton);					
	}
	else
	{					
		Msfg$activateHelp(helpPanel, imageButton);
	}
}

/// <summary>
/// Toggle the view state of the help control.
/// </summary>
/// <param name="helpPanel">help panel</param>
/// <param anme="imageButton">help image button</param>
function Msfg$activateHelp(helpPanel, imageButton)
{
	imageButton.src = imageButton.src.replace(/.png/,'_pressed.png');
	helpPanel.className='msfg-helplayer-active';								
	helpPanel.style.display='block';
}

/// <summary>
/// Toggle the view state of the help control.
/// </summary>
/// <param name="helpPanel">help panel</param>
/// <param anme="imageButton">help image button</param>
function Msfg$closeHelp(helpPanel, imageButton)
{
	imageButton.src = imageButton.src.replace(/_pressed/,'');
	helpPanel.className='msfg-helplayer';								
	helpPanel.style.display='none';
}

/************************************************************************************************/
/* Check Box List Validation Functions                                                          */
/************************************************************************************************/

/// <summary>
/// Gets the number of checkboxes that are checked.
/// </summary>
/// <param name="idSeperator">Id Seperator</param>
/// <param anme="itemCount">Number of Check Boxes</param>
/// <param anme="controlId">Id of the control to validate</param>
function Msfg$getCountOfCheckedCheckBoxes(idSeperator, itemCount, parentcontrolid)
{
    var checkBoxCheckedCount = 0;
    
    for(var i = 0; i < itemCount; i++)
    {
        var checkBox = document.getElementById(parentcontrolid + idSeperator + i);

        if(checkBox.checked)
        {
            checkBoxCheckedCount++;
        }
    }
    
    return checkBoxCheckedCount;
}

/// <summary>
/// Validates teh maximum number of checkboxes
/// that can be chekced in a check box list.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customMaximumCheckBoxCheckedValidatorEvaluateIsValid(sender, args) 
{
    var checkBoxCheckedCount = Msfg$getCountOfCheckedCheckBoxes(sender.idseperator, sender.itemcount, sender.parentcontrolid);
    var limit = sender.limit;
        
    if(checkBoxCheckedCount > limit)
    {
        args.IsValid = false;
    }
}

/// <summary>
/// Validates teh minimum number of checkboxes
/// that can be chekced in a check box list.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customMinimumCheckBoxCheckedValidatorEvaluateIsValid(sender, args) 
{
    var checkBoxCheckedCount = Msfg$getCountOfCheckedCheckBoxes(sender.idseperator, sender.itemcount, sender.parentcontrolid);
    var limit = sender.limit;
        
    if(checkBoxCheckedCount < limit)
    {
        args.IsValid = false;
    }
}


/// <summary>
/// Validates when a checkbox is required
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customCheckBoxRequiredValidatorEvaluateIsValid(sender, args)
{
    var checkbox = document.getElementById(args.Value);
    args.IsValid = checkbox.checked;
}

/************************************************************************************************/
/* Regex Validator Functions                                                                    */
/************************************************************************************************/

/// <summary>
/// Validates a Regex validator
/// </summary>
/// <param name="val">Validator</param>
/// <return>true; if is valid else false</return>
function Msfg$RegularExpressionValidatorEvaluateIsValid(val) 
{
    if (ValidatorGetValue(val.controltovalidate) != val.initialvalue)
    {
        return RegularExpressionValidatorEvaluateIsValid(val);
    }
    else
    {
        return true;
    }
}

// Performs a linear search on the list of components maintained
// by the MS Ajax framework. The componentId corrosponds to the
// html page element. If found it returns a reference to the object
// instance, otherwise null.
function Msfg$GetMsAjaxComponent(componentId)
{
    var components = Sys.Application.getComponents();
    var foundIndex = -1;
    for (var i=0; i<components.length; i++) {
    if (components[i].get_id() == componentId) {
            foundIndex = i;
            break;
        }
    }
    return (foundIndex > -1 ? components[foundIndex] : null);
}

// Function: suppressEnterKey(event)
// Usage:	 Suppresses the submit action when pressing Enter in the textbox
// Params:	 event - the window event
function suppressEnterKey(event)
{
    var enterKeyCode = 13;

    if (window.event)   //IE and Safari Browser
    {   
        event = window.event;

        if(navigator.vendor != null)
        {
            var BrowserIsSafari = false;
            if ((navigator.vendor.toLowerCase().indexOf("apple") > -1)  && (event.keyCode == 3))
            {
                BrowserIsSafari = true;
                event.keyCode = enterKeyCode;
            }
        }
        
        if ((event.keyCode == enterKeyCode) || (BrowserIsSafari))
        {
            event.returnValue = false; 
	        event.cancel = true;
        } 
    }
    else 
    {   
        if (event.which == enterKeyCode) 
        {
	        event.preventDefault(); 
        } 
    } 
}

/************************************************************************************************/
/* Lookup Validation                                                                            */
/************************************************************************************************/

/// <summary>
/// Validates for no results.
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customFailedLookupValidatorEvaluateIsValid(sender, args) 
{
    var noresults = document.getElementById(sender.noresults).value;   
    args.IsValid = (noresults == "false") ? true  : false
}

/// <summary>
/// Validates for required
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customRequiredLookupValidatorEvaluateIsValid(sender, args) 
{
    // Check that the hidden field is visible or hidden
    var required = document.getElementById(sender.required); 
    args.IsValid = (required.value == "true");   
}

/// <summary>
/// Validates for required
/// </summary>
/// <param name="sender">Control to validate</param>
/// <param anme="args">Event arguments</param>
function Msfg$customRequiredSelectionLookupValidatorEvaluateIsValid(sender, args) 
{
    var HiddenSelectionElement = document.getElementById(sender.hiddenLookup);
    if(HiddenSelectionElement.value == "false") 
    { 
        args.IsValid = true;
        return;
    }
        
    sender.container = "vlVehicleLookup_ctl01_divSelectContainer";
    var element = document.getElementById(sender.selectionRequired);
    if(element != null)
    {
        args.IsValid = (element.value != "") ? true  : false
    }
}

/************************************************************************************************/
/* New Window PostBack Script Utils                                                             */
/************************************************************************************************/

/// <summary>
/// Geterate the url for the blank new window page.
/// </summary>
/// <param name="eventTarget">element that triggered event.</param>
/// <param name="navigateUrl">url to navigate to.</param>
function Msfg$CreateNewWindowUrl(){
    var pageUrl = location.href;
    var windowUrl = "/framework/pages/blank.htm";
    var subSite = "";

    if (pageUrl.indexOf("/moneysupermarket/") != -1) 
    {				
      subSite = "/moneysupermarket";
    }
    else if (pageUrl.indexOf("/travelsupermarket/") != -1) 
    {
      subSite = "/travelsupermarket";
    }
    else if (pageUrl.indexOf("/tests/") != -1) 
    {
      subSite = "/tests";
    }   
    return subSite + windowUrl;
}

/************************************************************************************************/
/* New Window PostBack Script                                                                   */
/************************************************************************************************/

/// <summary>
/// Goto a url in new window
/// </summary>
/// <param name="eventTarget">element that triggered event.</param>
/// <param name="navigateUrl">url to navigate to.</param>
function Msfg$GotoNewWindow(eventTarget, navigateUrl) {
    var windowName = eventTarget.replace(/\$/g,"_") + "_Popup";
    var w = window.open(navigateUrl,windowName, "");
}

/// <summary>
/// Performs the requested PostBack in a new window.
/// </summary>
/// <param name="eventTarget">element that triggered event.</param>
/// <param anme="eventArgument">event arguments.</param>
/// <param anme="block">block submit.</param>
function Msfg$DoNewWindowSubmit(eventTarget, block) {
    var windowName = eventTarget.replace(/\$/g,"_") + "_Popup";
    var w = window.open(Msfg$CreateNewWindowUrl(),windowName, "");
    var frm = Msfg$getElementsForm($(eventTarget.replace(/\$/g,"_")));
    frm.target=windowName;
    __doPostBack(eventTarget, '');
    frm.target="_self";
    if(block)
    {
        return false;
    }
}

/// <summary>
/// Performs the requested PostBack in a new window.
/// </summary>
/// <param name="eventTarget">element that triggered event.</param>
/// <param anme="eventArgument">event arguments.</param>
/// <param anme="block">block submit.</param>
function Msfg$DoNewWindowPostBack(eventTarget, eventArgument, block) {
    var windowName = eventTarget.replace(/\$/g,"_") + "_Popup";
    var w = window.open(Msfg$CreateNewWindowUrl(),windowName, "");
    var frm = Msfg$getElementsForm($(eventTarget.replace(/\$/g,"_")));
    frm.target=windowName;
    __doPostBack(eventTarget, eventArgument);
    frm.target="_self";
    if(block)
    {
        return false;
    }
}

/// <summary>
/// Performs the requested PostBack with options in a new window.
/// </summary>
/// <param name="eventTarget">element that triggered event.</param>
/// <param anme="eventArgument">event arguments.</param>
/// <param anme="validation">true if validation enabled; else false.</param>
/// <param anme="validationGroup">validation group name</param>
/// <param anme="actionUrl">action url</param>
/// <param anme="trackFocus">track focus of event</param>
/// <param anme="clientSubmit">client submit</param>
/// <param anme="block">block submit.</param>
function Msfg$DoNewWindowPostBackWithOptions(eventTarget, eventArgument, validation, validationGroup, actionUrl, trackFocus, clientSubmit, block) {
    var windowName = eventTarget.replace(/\$/g,"_") + "_Popup";
    var w = window.open(Msfg$CreateNewWindowUrl(),windowName, "");
    var frm = Msfg$getElementsForm($(eventTarget.replace(/\$/g,"_")));
    frm.target=windowName;
    WebForm_DoPostBackWithOptions(new WebForm_PostBackOptions(eventTarget, eventArgument, validation, validationGroup, actionUrl, trackFocus, clientSubmit));
    frm.target="_self";
    if(block)
    {
        return false;
    }
}

/************************************************************************************************/
/* New Window And Sem Tracking Utils Method                                                     */
/************************************************************************************************/

/// <summary>
/// Create image and wait for load.
/// </summary>
/// <param name="timeout">timeout in milliseconds.</param>
/// <param name="semUrl">sem tracking url.</param>
function Msfg$createImage(semUrl) {
    if(semUrl != null && semUrl != "") {
        var img = new Image();
        img.src = semUrl;
    }
}

/// <summary>
/// get the form that the element is in. 
/// </summary>
/// <param name="e">element.</param>
function Msfg$getElementsForm(e) {
    if(e == null) {
        return null;
    }
    if(e.parentNode == null) {
        return null;
    }
    else if(e.parentNode.tagName == "FORM"){
        return e.parentNode;
    }
    else if (e.parentNode.tagName == "BODY") {
        return null;
    }
    else {
        return Msfg$getElementsForm(e.parentNode);
    }
}

/************************************************************************************************/
/* New Window PostBack Script With Sem Tracking                                                 */
/************************************************************************************************/

/// <summary>
/// Goto a url and perform sem tracking
/// </summary>
/// <param name="eventTarget">element that triggered event.</param>
/// <param name="navigateUrl">url to navigate to.</param>
/// <param anme="semUrl">semTrackingUrl.</param>
function Msfg$GotoNewWindowWithSemTracking(eventTarget, navigateUrl,semUrl,timeout) {
    Msfg$GotoNewWindow(eventTarget, navigateUrl)
    Msfg$createImage(semUrl);
}

/// <summary>
/// Performs the requested PostBack in a new window.
/// and sem tracking.
/// </summary>
/// <param name="eventTarget">element that triggered event.</param>
/// <param anme="eventArgument">event arguments.</param>
/// <param anme="block">block submit.</param>
/// <param anme="semUrl">semTrackingUrl.</param>
function Msfg$DoNewWindowSubmitWithSemTracking(eventTarget, block, semUrl,timeout) {
    Msfg$DoNewWindowSubmit(eventTarget, block);
    Msfg$createImage(semUrl);    
    if(block)
    {
        return false;
    }
}

/// <summary>
/// Performs the requested PostBack in a new window.
/// and sem tracking.
/// </summary>
/// <param name="eventTarget">element that triggered event.</param>
/// <param anme="eventArgument">event arguments.</param>
/// <param anme="block">block submit.</param>
/// <param anme="semUrl">semTrackingUrl.</param>
function Msfg$DoNewWindowPostBackWithSemTracking(eventTarget, eventArgument, block, semUrl,timeout) {
    Msfg$DoNewWindowPostBack(eventTarget, eventArgument, block);
    Msfg$createImage(semUrl);
    if(block)
    {
        return false;
    }
}

/// <summary>
/// Performs the requested PostBack with options in a new window.
/// and sem tracking.
/// </summary>
/// <param name="eventTarget">element that triggered event.</param>
/// <param anme="eventArgument">event arguments.</param>
/// <param anme="validation">true if validation enabled; else false.</param>
/// <param anme="validationGroup">validation group name</param>
/// <param anme="actionUrl">action url</param>
/// <param anme="trackFocus">track focus of event</param>
/// <param anme="clientSubmit">client submit</param>
/// <param anme="block">block submit.</param>
/// <param anme="semUrl">semTrackingUrl.</param>
function Msfg$DoNewWindowPostBackWithOptionsAndSemTracking(eventTarget, eventArgument, validation, validationGroup, actionUrl, trackFocus, clientSubmit, block, semUrl,timeout) {
    Msfg$DoNewWindowPostBackWithOptions(eventTarget, eventArgument, validation, validationGroup, actionUrl, trackFocus, clientSubmit, block);
    Msfg$createImage(semUrl);
    if(block)
    {
        return false;
    }
}

/************************************************************************************************/
/* Goto/Do PostBack Script With Sem Tracking                                                    */
/************************************************************************************************/

/// <summary>
/// Goto a url and perform sem tracking
/// </summary>
/// <param name="eventTarget">element that triggered event.</param>
/// <param name="navigateUrl">url to navigate to.</param>
/// <param anme="semUrl">sem tracking url.</param>
function Msfg$GotoWithSemTracking(eventTarget, navigateUrl, semUrl,timeout) {
    Msfg$createImage(semUrl);
    setTimeout(function() {window.location = navigateUrl;}, timeout);
}

/// <summary>
/// Performs the requested PostBack in a new window.
/// </summary>
/// <param name="eventTarget">element that triggered event.</param>
/// <param anme="eventArgument">event arguments.</param>
/// <param anme="block">block submit.</param>
function Msfg$DoSubmitWithSemTracking(eventTarget, block, semUrl,timeout) {
    var frm = Msfg$getElementsForm($(eventTarget.replace(/\$/g,"_")));
    Msfg$createImage(semUrl);
    setTimeout(function() {__doPostBack(eventTarget, '');}, timeout);
    if(block)
    {
        return false;
    }
}

/// <summary>
/// Performs the requested PostBack in a new window.
/// </summary>
/// <param name="eventTarget">element that triggered event.</param>
/// <param anme="eventArgument">event arguments.</param>
/// <param anme="block">block submit.</param>
function Msfg$DoPostBackWithSemTracking(eventTarget, eventArgument, block, semUrl, timeout) {
    Msfg$createImage(semUrl);
    setTimeout(function() {__doPostBack(eventTarget, '');}, timeout);
    if(block)
    {
        return false;
    }   
}

/// <summary>
/// Performs the requested PostBack with options in a new window.
/// </summary>
/// <param name="eventTarget">element that triggered event.</param>
/// <param anme="eventArgument">event arguments.</param>
/// <param anme="validation">true if validation enabled; else false.</param>
/// <param anme="validationGroup">validation group name</param>
/// <param anme="actionUrl">action url</param>
/// <param anme="trackFocus">track focus of event</param>
/// <param anme="clientSubmit">client submit</param>
/// <param anme="block">block submit.</param>
function Msfg$DoPostBackWithOptionsAndSemTracking(eventTarget, eventArgument, validation, validationGroup, actionUrl, trackFocus, clientSubmit, block, semUrl, timeout) {
    Msfg$createImage(semUrl);
    setTimeout(function() {WebForm_DoPostBackWithOptions(new WebForm_PostBackOptions(eventTarget, eventArgument, validation, validationGroup, actionUrl, trackFocus, clientSubmit));}, timeout);
    if(block)
    {
        return false;
    }
}

/************************************************************************************************/
/* SEO Optimised Controls                                                                       */
/************************************************************************************************/

/// <summary>
/// Transform and unordered list to select.
/// </summary>
/// <param name="eventTarget">UnorderedListElement Id</param>
/// <param anme="eventArgument">Index of select option to be selected</param>
function Msfg$TransFormULToSelect(ULElementId, selectedIndex) {

    var UlElement = $(ULElementId);

    if(UlElement != null && UlElement.hasChildNodes()) {

	    var UlParentElement = UlElement.parentNode;				
	    var select = CreateSelectFromUL(UlElement, selectedIndex);				
	    UlParentElement.replaceChild(select, UlElement);
    } 
}

/// <summary>
/// Creates and returns a select element from the provided unordered list
/// </summary>
/// <param name="eventTarget">UnorderedList Element </param>
/// <param anme="eventArgument">Index of select option to be selected</param>		
function CreateSelectFromUL(ULElement, selectedIndex) {

    var select;			
    Element.extend(ULElement);
    lis = ULElement.getElementsByTagName('li');
    		
    if(lis != null && lis.length >  0) {
	    //create <select>
	    select =  Msfg$createElement("select");
	    select.setAttribute("id", ULElement.id);
    		
	    //Transfer Class Name from UL to Select
	    classnames = $w(ULElement.className);
	    for(i = 0; i < classnames.length ; i++) {
		    select.setAttribute("class", classnames[i]);
	    }					
    	
	    //get and cycle through <a>'s and lis
	    aElements = ULElement.getElementsByTagName('a');
	    liElements = ULElement.getElementsByTagName('li');
    		
	    for( aIndex = 0; aIndex < aElements.length; aIndex ++) {
		    //get <a> and <li>
		    aTag = aElements[aIndex];	
		    liTag = liElements[aIndex];
    	
		    if(aTag != null) {
    		
			    //create select <option>
			    selected = (selectedIndex == aIndex);
			    text = aTag.childNodes[0].nodeValue;
			    value = aTag.href;
			    select.options[aIndex] = new Option(text, value, selected);
    				
			    //Transfer Class Name from <li> to <options>
			    if(liTag != null) {					
    				
				    classnames = $w(liTag.className);
				    for(i = 0; i < classnames.length ; i++)	{
					    select.options[aIndex].setAttribute("class", classnames[i]);
				    }
			    }
		    }
	    }
    }
    return select;
}

function Msfg$ChangeButton(source, changeUrl)
{
    sourceArray = source.id.split('_');
    var sourceElement = document.getElementById(sourceArray[0] + '_btnLookup');
    sourceElement.src = changeUrl;
}