function OrderedListBoxInsert(ctlSelect, strText, strValue, blnSelectIt)
{
    var loweredValue = strValue.toLowerCase() ;
    var loweredText  = strText.toLowerCase() ;

    for (var ii=ctlSelect.options.length ; ii ; ii--)
        if (ctlSelect.options[ii-1].value.toLowerCase() == loweredValue)
            return ; // It is already there.
        

    for (var ii=ctlSelect.options.length ; ii ; ii--)
    {
        if (loweredText > ctlSelect.options[ii-1].text.toLowerCase())
        {
            ctlSelect.options[ii] = new Option(strText, strValue, false, blnSelectIt) ;
            return ;
        }
        ctlSelect.options[ii] = new Option(ctlSelect.options[ii-1].text, ctlSelect.options[ii-1].value, false, ctlSelect.options[ii-1].selected) ;
    }
    
    if (!ii) // special case processing if we are inserting at the beginning of the list.
        ctlSelect.options[0] = new Option(strText, strValue, false, blnSelectIt) ;
}

function MoveListBoxValues(sourceName, destName)
{
    var ctlSource = document.getElementById(sourceName) ; 
    var ctlDest   = document.getElementById(destName) ;
    
    for (var ii=ctlSource.options.length-1 ; ii>=0 ; ii--)
        if (ctlSource.options[ii].selected)
        {
            OrderedListBoxInsert(ctlDest, ctlSource.options[ii].text, ctlSource.options[ii].value, true) ;                                        
            ctlSource.options[ii] = null ;  
        }
        
    return false ;        
}

/******************* Generic Form and Control Manipulation ***************/

function SFGetControlSet(ctlSet)
{
    return document.getElementsByName(ctlSet) ; 
}

function SFGetControl(ctlName)
{
    return document.getElementById(ctlName) ; 
}


function SFGetLabelValue( ctlName )
{
    ctl = document.getElementById(ctlName) ; 

    return ctl.innerHTML;
}

function SFGetRadioValue(ctlSet)
{
    var radios = SFGetControlSet(ctlSet) ;
    if (radios == null)    
        return null ;  

    if (radios.length == null || radios.length == 0)
       return (radios.checked?radios.value:null) ; 

    for (var ii=0 ; ii<radios.length ; ++ii)
        if (radios[ii].type != 'radio')
            return null ;  
        else if (radios[ii].checked)
            return radios[ii].value ; 

    return null ;
}

function SFGetRadioDefaultValue(ctlSet)
{
    var radios = SFGetControlSet(ctlSet) ;
    if (radios == null)
        return null ;  

    for (var ii=0 ; ii<radios.length ; ++ii)
        if (radios[ii].type != 'radio')
            return null ;  
        else if (radios[ii].defaultChecked)
            return radios[ii].value ; 
            
    return null ;
}

function SFGetSelectListLength(ctlName)
{
    return SFGetControl(ctlName).options.length ;
}

function SFGetSelectValue(ctlSet)
{
    var options = document.getElementById(ctlSet) ;
    if (options == null)
        return null ;  

    for (var ii=0 ; ii<options.length ; ++ii)
        if (options[ii].selected)
            return options[ii].value ; 

    return null ;
}

function SFGetSelectText(ctlSet)
{
    var options = document.getElementById(ctlSet) ;
    if (options == null)
        return null ;  

    for (var ii=0 ; ii<options.length ; ++ii)
        if (options[ii].selected)
            return options[ii].text ; 

    return '' ;
}

function SFGetSelectDefaultValue(ctlSet)
{
    var options = document.getElementById(ctlSet) ;
    if (options == null)
        return null ;                     

    for (var ii=0 ; ii<options.length ; ++ii)
        if (options[ii].defaultSelected)
            return options[ii].value ; 

    return null ;
}

function SFGetSelectDefaultText(ctlSet)
{
    var options = document.getElementById(ctlSet) ;
    if (options == null)
        return null ;                     

    for (var ii=0 ; ii<options.length ; ++ii)
        if (options[ii].defaultSelected)
            return options[ii].text ; 

    return '' ;
}

function SFGetEditValue(ctlName) 
{
    var ctl = SFGetControl(ctlName) ; 
    if (ctl)
        return ctl.value ; 
        
    return null ;        
}

function SFGetCheckboxState(ctlName)
{
    var ctl = SFGetControl(ctlName) ; 
    return (ctl)?ctl.checked:false ; 
}

function SFRemoveAllWhitespace(strValue)
{
    return strValue.replace(/[\s|\240]/gi, "") ; 
}

function SFEditFieldValue(ctlName)
{
    var ctl = SFGetControl(ctlName) ; 
    
    return ctl?SFRemoveAllWhitespace(ctl.value):false ;
}

function SFEditFieldHasValue(ctlName)
{
    return (SFEditFieldValue(ctlName) != "") ;
}

function SFEditFieldIsDate(ctlName)
{   
    var ctl = SFGetControl(ctlName) ;
    if (!ctl) 
        return true ;
        
    return ValueIsDate(ctl.value) ;
}            
  
function ValueIsDate(dateString)
{  
	var dateRE = /^ *([01]?\d)[\-|\/\.]([0123]?\d)[\-|\/\.]([12][8901]\d{2}) *$/ ;
	if (dateRE.test(dateString))
	{
		var match = dateString.match(dateRE) ; 
		if (match.length == 4)
		{
		    var testDate = new Date(match[3], Number(match[1])-1, match[2]) ;   

            if (testDate.getFullYear() == match[3] && 
                testDate.getMonth()    == Number(match[1])-1 &&
                testDate.getDate()     == match[2])
                return true ; 
		}
	}
    return false ;             
}

function SFTrim(strValue)
{
    return strValue?strValue.replace(/^\s*|\s*$/gi, ""):"" ; 
}

function SFEditFieldMatchesRegEx(ctlName, regEx)
{
    var ctl = SFGetControl(ctlName) ; 
    if (!ctl)
        return false ; 
    return (ctl.value.match(regEx) != null); 
}


/********************** Hide and Show Support ****************************/
function internal_ActionByType(type, action)
{
    var ctls = document.getElementsByTagName(type) ;
    
    var returnValue = true ; 
    for (var ii=0 ; ii<ctls.length ; ++ii)
        if (ctls[ii].name.indexOf("cmsForms_") == 0 || ctls[ii].name.indexOf("cmsFormS_") == 0)
            switch (action)
            {
                case "disable":
                    SFDisableControl(ctls[ii].name) ; 
                    break ;
                case "reset":
                    SFResetToDefault(ctls[ii].name) ;
                    break ; 
                case "enable":
                    SFEnableControl(ctls[ii].name) ; 
                    break ;
                case "validate":
                    returnValue &= SFValidateControl(ctls[ii].name) ; 
                    break ;   
                case "clearCheck":
                    if (ctls[ii].type == "checkbox")
                        ctls[ii].checked = false ;                   
            }
            
    return returnValue ;            
}
function SFClearCheckBoxes()
{
    internal_ActionByType("input", "clearCheck") ; 
}

function SFDisableAll()
{
    internal_ActionByType("input", "disable") ; 
    internal_ActionByType("textarea", "disable") ; 
    internal_ActionByType("select", "disable") ; 
}

function SFResetAll()
{
    SFHideMessageArea() ;
    internal_ActionByType("input", "reset") ; 
    internal_ActionByType("textarea", "reset") ; 
    internal_ActionByType("select", "reset") ; 
}

function SFEnableAll()
{
    internal_ActionByType("input", "enable") ; 
}

function SFValidateAll(ctl)
{
    var allPassed = true ; 
    
    if (window.FormSpecificValidation)
        allPassed &= FormSpecificValidation() ;
    
    allPassed &= internal_ActionByType("select", "validate") ;
    allPassed &= internal_ActionByType("input", "validate") ;
    allPassed &= internal_ActionByType("textarea", "validate") ;

    if (allPassed)
        ctl.form.submit() ;
}

function SFValidateControl(ctlName)
{
    var messageName = "alert_" + ctlName ; 
    var controlIsValid = true ; 
    
    var ctl = document.getElementById(ctlName) ; 
    var displayName = ctlName.substring(ctlName.indexOf('_')+1); 
    var bIsRequired = false ; 
    if (ctl)
    {
        if (ctl.attributes["errorMessage"] && ctl.attributes["errorMessage"].value != "")
            displayName = ctl.attributes["errorMessage"].value ; 
        else if (ctl.attributes["errormessage"] && ctl.attributes["errormessage"].value != "")
            displayName = ctl.attributes["errormessage"] ; // thank you, firefox for downcasing
        bIsRequired = ((ctl.attributes["isRequired"]  && ctl.attributes["isRequired"].value=='true') ||
                       (ctl.attributes["isrequired"]  && ctl.attributes["isrequired"].value=='true'));             
    }    

    if (ctl && ctl.tagName == "SELECT")
    {
        if (bIsRequired)
        {
            var selectedValue = SFGetSelectValue(ctlName) ; 
            if (!selectedValue || selectedValue == "")
                controlIsValid = false ;             
        }

        SFRespondToValidation(controlIsValid, messageName, displayName) ; 
    }
    else if (ctl && ctl.tagName == 'INPUT' && ctl.type=='checkbox')
    {
        if (bIsRequired)
        {
            controlIsValid = ctl.checked ;
            SFRespondToValidation(controlIsValid, messageName, displayName) ; 
        }
    }
    else if (!ctl || (ctl.tagName == 'INPUT' && ctl.type=='radio'))
    {
        if (!ctl)
        {
            var ctlGroup = document.getElementsByName(ctlName) ; 
            if (ctlGroup && ctlGroup.length > 0)
                bIsRequired =  ((ctlGroup[0].attributes["isRequired"]  && ctlGroup[0].attributes["isRequired"].value=='true') ||
                                (ctlGroup[0].attributes["isrequired"]  && ctlGroup[0].attributes["isrequired"].value=='true')) ; 
        }
    
        if (bIsRequired)
        {
            var selectedValue = SFGetRadioValue(ctlName) ; 
            if (!selectedValue || selectedValue == "")
                controlIsValid = false ;             
        }

        SFRespondToValidation(controlIsValid, messageName, displayName) ; 
    }
    else // input and textareas
    {
        bNeedsValidation = (ctl.attributes["validationType"] && ctl.attributes["validationType"].value != 'None') ; 
    
        if (bIsRequired && !SFEditFieldHasValue(ctlName))
            controlIsValid = false ; 
        else if (bNeedsValidation && !SFEditFieldMatchesRegEx(ctlName, ctl.attributes["regExp"].value))
            controlIsValid = false ; 

        SFRespondToValidation(controlIsValid, messageName, displayName) ; 
    }
    
    return controlIsValid ; 
}

function internal_MaskEdit(ctl)
{
    ctl.readOnly = true ; 
    ctl.style.border = "0 solid #FFFFFF" ; 
    ctl.style.backgroundColor = "#FFFFFF" ; 
    ctl.style.color = "#000000" ; 
}

function SFEnableControl(ctlName)
{
    var ctls = document.getElementsByName(ctlName) ; 
    
    for (var ii=0 ; ii<ctls.length ; ++ii)
        ctls[ii].disabled = false ; 
}

function SFDisableControl(ctlName)
{
    var ctl = document.getElementById(ctlName) ; 
    if (ctl && ctl.tagName == "SELECT")
    {
        var parentNode = ctl.parentNode ;
        if (!parentNode)
            return window.alert ("No parent element found for " + ctlName); 
            
        var inputControl = document.createElement("input") ; 
        if (!inputControl)
            return window.alert ("Unable to create element for " + ctlName) ; 

        if (!ctl.multiple && ctl.selectedIndex >= 0)
            inputControl.value     = ctl.options[ctl.selectedIndex].text ;   
        else
        {
            var str = "" ;
            for (var ii=0 ; ii<ctl.length ; ++ii)
                if (ctl[ii].selected)
                    str += ((str.length>0)?", ":"") + ctl[ii].text ;
            inputControl.value = str ;
        }            
            
        inputControl.className = ctl.className ;              
        parentNode.insertBefore(inputControl, ctl) ;
        internal_MaskEdit(inputControl); 
        
        ctl.style.display = "none" ;         
    }
    else if (ctl && ctl.tagName == 'INPUT' && ctl.type=='checkbox')
        ctl.disabled = true ; 
    else if (!ctl || (ctl.tagName == 'INPUT' && ctl.type=='radio'))
    {
        var ctlGroup = document.getElementsByName(ctlName) ; 
        for (var ii=0 ; ii<ctlGroup.length ; ++ii)
            ctlGroup[ii].disabled = true ;
    }
    else // input and textareas
        internal_MaskEdit(ctl); 
}

function SFResetToDefault(ctlName)
{
    var ctl = document.getElementById(ctlName) ; 
    if (ctl && ctl.tagName == "SELECT")
    {
        var selectedIndex = -1 ; 
        for (var ii=0 ; ii<ctl.options.length ; ++ii)
            if (ctl.options[ii].defaultSelected)
                selectedIndex = ii ; 
                
        ctl.selectedIndex = selectedIndex ;                 
    }
    else if (ctl && ctl.tagName == 'INPUT' && ctl.type=='checkbox')
        ctl.checked = ctl.defaultChecked ; 
    else if (!ctl || (ctl.tagName == 'INPUT' && ctl.type=='radio'))
    {
        var ctlGroup = document.getElementsByName(ctlName) ; 
        if (ctlGroup)
            for (var ii=0 ; ii<ctlGroup.length ; ++ii)
                ctlGroup[ii].checked = ctlGroup[ii].defaultChecked ;
    }
    else if (ctl) // input and textareas
        ctl.value = ctl.defaultValue ; 
}

function SFControlIsEnabled(ctlName)
{
    return document.getElementById(ctlName)!=null && !document.getElementById(ctlName).disabled ;
}

function SFControlExists(ctlName)
{
    return SFGetControl(ctlName)!=null ;
}

/************************* Change Detection ******************************/
function SFValueHasChanged(ctlName)
{
    var ctl = SFGetControl(ctlName) ; 
    if (!ctl)
    {
        ctlSet = SFGetControlSet(ctlName) ; 
        if (ctlSet == null || ctlSet.length == 0)
            return false ; 
    }

    var value ;         
    if (!ctl || !ctl.tagName || (ctl.tagName=="INPUT" && ctl.type=="radio"))
        value = SFGetRadioValue(ctlName) ; 
    else if (ctl.tagName == "SELECT")
        value = SFGetSelectValue(ctlName) ;    
    else if (ctl.tagName == 'INPUT' && ctl.type=='checkbox')
        value = ctl.checked?ctl.value:"" ; 
    else
        value = ((!ctl.value)?"":ctl.value) ; 

    var defaultValue ;         
    if (!ctl || !ctl.tagName || (ctl.tagName=="INPUT" && ctl.type=="radio"))
        defaultValue = SFGetRadioDefaultValue(ctlName) ; 
    else if (ctl.tagName == "SELECT")
        defaultValue = SFGetSelectDefaultValue(ctlName) ;    
    else if (ctl.tagName == 'INPUT' && ctl.type=='checkbox')
        defaultValue = ctl.defaultChecked?ctl.value:"" ; 
    else
        defaultValue = ((!ctl.defaultValue)?"":ctl.defaultValue) ; 
        
    defaultValue = (defaultValue?defaultValue:"") ; 
    value = (value?value:"") ;        

    return (defaultValue != value) ; 
}

/****************** OnLoad Control Value Setting *************************/
function SFSetRadioValue(ctlName, ctlValue)
{
    var ctl = SFGetControlSet(ctlName) ; 
    if (ctl == null)
        return ; 
        
    if (ctl.length && ctl.length > 0)
        for (var ii=0 ; ii<ctl.length ; ++ii)
            ctl[ii].checked = (ctl[ii].value == ctlValue) ; 
    else 
        ctl.checked = (ctl.value == ctlValue) ; 
}

function SFClearRadioButton(ctlName, ctlValue)
{
    var ctl = SFGetControl(ctlName) ; 
    if (ctl == null)
        return ;
        
    for (var ii=0 ; clt.length && ii<ctl.length ; ++ii)        
        if (ctl[ii].value == ctlValue)
            ctl[ii].selected = ctl[ii].checked = false ; 
}
function SFSetControlValue(ctlName, ctlValue, bFireChangeEvent)
{
    var ctl = document.getElementById(ctlName) ; 
    if (ctl == null)
    {
        ctl = document.getElementsByName(ctlName) ; 
        if (ctl == null || ctl.length == 0)
            return ;
    }
    
    var arrayOfValues ; 
    if (ctl.tagName == "SELECT" && ctl.multiple)
        arrayOfValues = ctlValue.split(',') ; 
    else
        arrayOfValues = [ctlValue] ;
        
    if (ctl.length && ctl.length > 0)
    {   
	    for (var ii=0 ; ii<ctl.length ; ++ii)
	    {
            ctl[ii].selected = false ; 
            ctl[ii].checked = false ; 
            ctl[ii].defaultChecked = false ;
            ctl[ii].defaultSelected = false ;
	    }
        for (var jj=0 ; jj<arrayOfValues.length ; ++ jj)
        {
            for (var ii=0 ; ii<ctl.length ; ++ii)        
            {
               if (ctl[ii].value.replace(/ /g, '') == arrayOfValues[jj].replace(/ /g, ''))
                {
                    ctl[ii].selected = true ; 
                    ctl[ii].checked = true ; 
                    ctl[ii].defaultChecked = true ;
                    ctl[ii].defaultSelected = true ;
                    if (bFireChangeEvent && ctl[ii].onclick)
                        ctl[ii].onclick() ;
                }                                       
            }
        }
        
        // Handle dropdown's where the method is on the select            
        if (bFireChangeEvent && ctl.onchange)
            ctl.onchange() ;        
    }
    else if (ctl.tagName == 'INPUT' && ctl.type == 'radio')
    {
        var ctlGroup = document.getElementsByName(ctlName) ; 
        for (var ii=0 ; ii<ctlGroup.length ; ++ii)
            if (ctlGroup[ii].value == ctlValue)
            {
                ctlGroup[ii].checked = ctlGroup[ii].defaultChecked = true ; 
                if (bFireChangeEvent && ctlGroup[ii].onclick)
                    ctlGroup[ii].onclick() ;        
            }
    }
    else if (ctl.tagName == 'INPUT' && ctl.type == 'checkbox')
    {
        ctl.defaultChecked = ctl.checked = (ctlValue != "" && ctlValue != 0 && ctlValue != "No"  && ctlValue != "off" && ctlValue != false) ; 
        if (bFireChangeEvent && ctl.onclick)
            ctl.onclick() ;
    }
    else
    {        
        ctl.value = ctlValue ; 
        ctl.defaultValue = ctlValue ; 
        if (bFireChangeEvent && ctl.onchange)       
            ctl.onchange() ; 
    }
}

/******************* Message Area Manipulation ***************************/
function SFExtractMessageControl()
{
    return document.getElementById("cmsForms_DataNotProvided") ; 
}

function SFFindMessage(msgCtl, msgName)
{
    return document.getElementById(msgName) ;
}

function SFHideMessageArea()
{
    var msgCtl = SFExtractMessageControl() ; 
    msgCtl.style.display = "none" ; 
    
}

function SFAddMessage(msgName, msgText)
{
    var msgCtl = SFExtractMessageControl() ; 
    if (SFFindMessage(msgCtl, msgName))
        return ; 

    var newMessage = document.createElement("DIV") ; 
    newMessage.className = 'SFMessage' ; 
    newMessage.id = msgName ; 
    newMessage.innerHTML = "&nbsp;&nbsp;&nbsp;" + msgText;
    
    msgCtl.appendChild(newMessage);

    msgCtl.style.display = "block" ; 
    return true;
}

function SFRemoveMessage(msgName)
{
    var msgCtl = SFExtractMessageControl() ; 
    var ctlToRemove = SFFindMessage(msgCtl, msgName) ;
    if (ctlToRemove == null)
        return ; 
    msgCtl.removeChild(ctlToRemove) ;
}

function SFDisplayMessage(msgName, message) 
{
    if (SFFindMessage(SFExtractMessageControl(), msgName))
        return ; 

    SFAddMessage(msgName, message) ;
}

function SFRespondToValidation(testHasPassed, msgName, message)
{
    if (testHasPassed)
    {
        SFRemoveMessage(msgName) ; 
        return true ; 
    }
    else
    {
        SFDisplayMessage(msgName, message) ; 
        return false ; 
    }
}

// -----------

function Wkst_ValueIsNumber(ctlName)
{
    if (!Wkst_ControlShouldBeUsed(ctlName))
        return true ;

    return SFEditFieldMatchesRegEx(ctlName, "^\\d+$") ; 
}


function Wkst_GetEditDefaultValue(ctlName)
{
    var ctl = SFGetControl(ctlName) ; 
    if (!ctl)
        return null ; 

    return ctl.defaultValue ;     
}
function Wkst_GetEditDefaultValueLinked(ctlName)
{
    var ctl = SFGetControl(ctlName) ;
    if (!ctl)
        return null ;
    
    if (ctl.getAttribute('origLinkStaus') == '1')
        return Wkst_GetEditDefaultValue(document.getElementById(ctlName + "_Mover").getAttribute('sourceID')) ;           

    return ctl.defaultValue ;
}

function Wkst_GetEditValueLinked(ctlName)
{
    var ctl = SFGetControl(ctlName) ; 
    if (!ctl)
        return null ; 
    
    var moverControl = document.getElementById(ctlName + "_Mover") ;
    if (moverControl.checked)
        return SFGetEditValue(moverControl.getAttribute('sourceID')) ; 
           
    return ctl.value ;        
}

function Wkst_GetCheckBoxValue(ctlName)
{
    var ctl = SFGetControl(ctlName) ; 
    if (!ctl)
        return "" ; 
 
    return (ctl.checked?ctl.value:"") ;
}
function Wkst_GetCheckboxDefaultValue(ctlName)
{
    var ctl = SFGetControl(ctlName) ; 
    if (!ctl)
        return "" ; 
 
    return (ctl.defaultChecked?ctl.value:"") ;
}

function Wkst_GetCheckBoxState(ctlName)
{
    var ctl = SFGetControl(ctlName) ; 
    if (!ctl)
        return "" ; 
 
    return (ctl.checked?"Checked":"Unchecked") ;
}
function Wkst_GetCheckboxDefaultState(ctlName)
{
    var ctl = SFGetControl(ctlName) ; 
    if (!ctl)
        return "" ; 
 
    return (ctl.defaultChecked?"Checked":"Unchecked") ;
}

function Wkst_GetRadioDefaultValueById(oneID)
{
    return Wkst_GetRadioDefaultValue(document.getElementById(oneID).name) ;     
}
function Wkst_GetRadioValueById(oneID)
{
    return Wkst_GetRadioValue(document.getElementById(oneID).name) ;     
}

function Wkst_GetRadioDefaultValue(ctlSet)
{
    return SFGetRadioDefaultValue(ctlSet) ;
}
function Wkst_GetRadioValue(ctlSet)
{
    return SFGetRadioValue(ctlSet) ;
}
function Wkst_GetSelectDefaultValue(ctlSet)
{
    return SFGetSelectDefaultValue(ctlSet) ;
}
function Wkst_GetSelectValue(ctlSet)
{
    return SFGetSelectValue(ctlSet) ;
}

function Wkst_SelectHasValue(ctlName)
{
    if (!Wkst_ControlShouldBeUsed(ctlName))
        return true ;

    if (!document.getElementById(ctlName))
        return true ;
        
    return Wkst_GetSelectValue(ctlName) ;
}

function Wkst_GetSelectChangeMessage(ctlSet)
{
    var options = document.getElementById(ctlSet) ;
    if (!options)
        return ' changed' ; 
        
    return ' changed from ' + SFGetSelectDefaultText(ctlSet) + ' to ' + SFGetSelectText(ctlSet) ; 
}

function Wkst_SetControlValue(ctlName, ctlValue, bFireChangeEvent)
{
    var ctl = document.getElementById(ctlName) ; 
    if (ctl == null)
    { // Maybe it is a set of controls like radios
        ctl = document.getElementsByName(ctlName) ; 
        if (ctl == null || ctl.length == 0)
        { // Last chance it is a container for a RadCalendar
            try
            {
                radCtl = Wkst_GetRadCalendar(ctlName) ; 
                if (radCtl && radCtl.GetTextBox())
                    radCtl.GetTextBox().value = ctlValue ;
            }
            catch(e)
            {
                return "tomato" ;
            }
            return ;
        }
    }    
    
    var setValue = ctl.getAttribute('SetValue') ; 
    if (setValue && window[setValue])
        return window[setValue](ctlName, ctlValue, bFireChangeEvent) ;
    
    var arrayOfValues ; 
    if (ctl.tagName == "SELECT" && ctl.multiple)
        arrayOfValues = ctlValue.split(',') ; 
    else
        arrayOfValues = [ctlValue] ;
        
    if (ctl.length && ctl.length > 0)
    {   
	    for (var ii=0 ; ii<ctl.length ; ++ii)
	    {
                ctl[ii].selected = false ; 
                ctl[ii].checked = false ; 
	    }

        for (var jj=0 ; jj<arrayOfValues.length ; ++ jj)
        {
            for (var ii=0 ; ii<ctl.length ; ++ii)        
            {
               if (ctl[ii].value.replace(/ /g, '') == arrayOfValues[jj].replace(/ /g, ''))
                {
                    ctl[ii].selected = true ; 
                    ctl[ii].checked = true ; 
                    if (bFireChangeEvent && ctl[ii].onclick)
                        ctl[ii].onclick() ;
                }                                       
            }
        }
        
        // Handle dropdown's where the method is on the select            
        if (bFireChangeEvent && ctl.onchange)
            ctl.onchange() ;        
    }
    else if (ctl.tagName == 'INPUT' && ctl.type == 'radio')
    {
        var ctlGroup = document.getElementsByName(ctlName) ; 
        for (var ii=0 ; ii<ctlGroup.length ; ++ii)
            if (ctlGroup[ii].value == ctlValue)
            {
                ctlGroup[ii].checked = true ; 
                if (bFireChangeEvent && ctl.onclick)
                    ctl.onclick() ;        
            }
    }
    else if (ctl.tagName == 'INPUT' && ctl.type == 'checkbox')
    {
        ctl.checked = (ctlValue != "" && ctlValue != 0 && ctlValue != "No"  && ctlValue != "off" && ctlValue != false) ; 
        if (bFireChangeEvent && ctl.onclick)
            ctl.onclick() ;
    }
    else if (ctl.tagName == 'TEXTAREA')        
    {
        ctl.value = ctlValue ; 
        if (bFireChangeEvent && ctl.onchange)       
            ctl.onchange() ; 
    }
    else if (ctl.tagName == 'INPUT')
    {
        ctl.value = ctlValue ; 
        if (bFireChangeEvent && ctl.onchange)       
            ctl.onchange() ; 
    }
    else if (ctl.tagName == 'DIV' && ctl.className.indexOf('checkbox')==0)        
        tic_MultiEditCheck.SetChecked(ctl, ctlValue) ;
        
    var moverCtl = document.getElementById(ctlName + "_Mover") ;
    if (moverCtl)
    {
        var sourceCtl = document.getElementById(moverCtl.getAttribute('sourceID')) ; 
        if (sourceCtl.value == ctlValue)
        {
            moverCtl.checked = true ;
            moverCtl.onclick() ;
        }
    }        
}

function Wkst_SetAndCheckControlValue(ctlName, value)
{
    return Wkst_SetControlValue(ctlName, value, true) ;
}

function Wkst_ValueHasChanged(ctlName)
{
    var changeControl = Wkst_GetChangeControl(ctlName) ; 
    if (changeControl)
        return changeControl.checked || tic_MultiEditCheck.Checked(changeControl) ; 

    return SFValueHasChanged(ctlName) ;
}

function Wkst_ValueHasChangedLinked(ctlName)
{
    var changeControl = Wkst_GetChangeControl(ctlName) ; 
    if (changeControl && (changeControl.checked || tic_MultiEditCheck.Checked(changeControl)))
        return true; // We're linked, so if we're not checked, we still want to look if our controller is linked

    return (Wkst_GetEditDefaultValueLinked(ctlName) != Wkst_GetEditValueLinked(ctlName)) ;    
}

function Wkst_GetChangeControl(ctlName)
{
    return document.getElementById(ctlName + "_Changes") ;
}

function Wkst_ControlShouldBeUsed(ctlName)
{
    var changeControl = Wkst_GetChangeControl(ctlName) ; 
    if (!changeControl || document.getElementById(ctlName + "_Mover"))
        return true ; 

    return changeControl.checked || tic_MultiEditCheck.Checked(changeControl);         
}

function Wkst_EditHasValue(ctlName)
{
    if (!Wkst_ControlShouldBeUsed(ctlName))
        return true ;

    if (!document.getElementById(ctlName))
        return true ;
        
    return SFEditFieldHasValue(ctlName) ;        
}

function Wkst_ResetToDefault(ctlName)
{
    SFResetToDefault(ctlName) ;
}

function Wkst_FieldIsEmail(ctlName)
{
    return SFEditFieldMatchesRegEx(ctlName, "^ *[\\w._]+@[\\w._]*\\.[\\w._]* *$") ;
}

function Wkst_GetWrapperClass(ctl)
{
    var wrapper = ctl.parentNode ; 
    while (wrapper)
    {
        if (wrapper.className && wrapper.className.indexOf('fieldwrapper') == 0)
            return wrapper ;
        
        wrapper = wrapper.parentNode ;        
    }
    
    return null ;
}

function Wkst_ToggleMultiCheck(ctlName)
{
    var changeControl = Wkst_GetChangeControl(ctlName) ;
    if (!changeControl)
        return false ;
        
    tic_MultiEditCheck.Toggle(changeControl);    
    Wkst_PropChangeMessage(changeControl, ctlName, true) ;    
    return false;
}

function Wkst_SetErrorStatus(ctlName, turnOn)
{
    var ctl = document.getElementById(ctlName) ;
    if (!ctl)
        return ;

    var wrapper = Wkst_GetWrapperClass(ctl) ;
    if (!wrapper)
        return ;
        
    if (turnOn)        
        tic_Utilities.AddStyle(wrapper, "error") ;        
    else        
        tic_Utilities.RemoveStyle(wrapper, "error") ;        
}

function Wkst_PropChangeMessage(ctl, ctlName, noForceCheck)
{
    var changeControl = Wkst_GetChangeControl(ctlName) ;
    if (!noForceCheck && changeControl && !tic_MultiEditCheck.Checked(changeControl))
        changeControl.onclick() ;
        
    if (!ctl)
        ctl = (changeControl?changeControl:document.getElementById(ctlName)) ;         
    if (!ctl)
        return ;        
        
    var errorMessageSpan = document.getElementById(ctlName + "_EM") ;
    if (!errorMessageSpan)
        errorMessageSpan = document.getElementById(GetBaseID(ctlName) + "_EM") ;
    if (errorMessageSpan)
        errorMessageSpan.innerHTML = "" ;
        
    var wrapper = Wkst_GetWrapperClass(ctl) ;
    if (!wrapper)
        return ;
        
    if (wrapper.className != "fieldwrapper disabled")        
        wrapper.className = 'fieldwrapper' ;
    var changeFunction = wrapper.getAttribute('ChangeDetector') ;
    var suffix = "" ;
    if (changeFunction && window[changeFunction] && window[changeFunction](ctlName))
        suffix = ' changed' ;
            
    var validator = wrapper.getAttribute('Validator') ; 
    if (validator && window[validator] && !window[validator](ctlName))
    {
        suffix = ' error' ;

        errorMessage = wrapper.getAttribute("ErrorMessage") ;
        if (errorMessageSpan && errorMessage && window[errorMessage])
            errorMessageSpan.innerHTML = window[errorMessage](ctlName) ;
    }
    wrapper.className += suffix ;        
}

function Wkst_MoveValue(srcName, destName)
{
    var moverControl = document.getElementById(destName + "_Mover") ;
    var src = document.getElementById(srcName) ; 
    var dest = document.getElementById(destName) ;
    if (moverControl == null || src == null || dest == null)
        return ;

    var wrapper = Wkst_GetWrapperClass(moverControl) ;
    if (moverControl.checked)
    {
        dest.value = src.value ;
        dest.disabled = true ;
        tic_Utilities.AddStyle(wrapper, "disabled") ;
    }
    else
    {
        dest.value = src.value ;
        dest.disabled = false ;
        tic_Utilities.RemoveStyle(wrapper, "disabled") ;
    }
    Wkst_PropChangeMessage(moverControl, destName, false) ; 
}

function GetBaseID(ctlName)
{
    return ctlName.substring(0, ctlName.lastIndexOf("_")) ;
}

function Wkst_RadCalendarOnBlur(instance, renderDate)
{
    if (!instance || !instance.ClientID)
        return ;

    Wkst_PropChangeMessage(null, instance.ClientID.substring(0, instance.ClientID.lastIndexOf("_")) , false) ; 
}

function Wkst_GetRadCalendar(containerName)
{
    try
    {
        if (!Wkst_ControlShouldBeUsed(containerName))
            return null ;

        if (containerName.lastIndexOf('Container') == (containerName.length - String('Container').length))        
            containerName = containerName + '_' + 
                            containerName.substring(containerName.lastIndexOf('_') + 1, containerName.length - String('Container').length) ;
                            
        var retVal = window[containerName] ;
        if (retVal)
            retVal.HidePopup() ;  
            
        return retVal ;                                
    }
    catch(e)
    {
        return null ;
    }
}

function Wkst_RadCalendarIsValid(ctlName)
{
    var radCtl = Wkst_GetRadCalendar(ctlName) ; 
    if (!radCtl)
        return true ;

    if (radCtl.DateInput && radCtl.IsEmpty())
        return true ;        
    else if (!radCtl.GetTextBox())
        return true ;        
    else if (!radCtl.DateInput && radCtl.GetTextBox().value.replace(/[ \/]/gi, "")=="")
        return true ;
    
    return ValueIsDate(radCtl.GetTextBox().value) ; 
}

function Wkst_RadCalendarIsValidAndPresent(ctlName)
{
    var radCtl = Wkst_GetRadCalendar(ctlName) ; 
    if (!radCtl)
        return true ;

    if (radCtl.DateInput && radCtl.IsEmpty())
        return false ;        
    else if (!radCtl.GetTextBox())
        return false ;        
    
    return ValueIsDate(radCtl.GetTextBox().value) ; 
}

function Wkst_IsFutureDate(ctlName)
{
    var radCtl = Wkst_GetRadCalendar(ctlName) ; 
    if (!radCtl)
        return true ; 
        
    if (radCtl.DateInput && radCtl.IsEmpty())
        return false ;        
    else if (!radCtl.GetTextBox())
        return false ;        
               
    if (radCtl.DateInput && new Date() < radCtl.GetDate())
        return true ; 
    else if (!radCtl.DateInput && new Date() < new Date(radCtl.GetTextBox().value))
        return true ;
    else
        return false ;        
}

function Wkst_PageEndDate(ctlName)
{
    if (Wkst_IsFutureDate(ctlName))
        return true ;
        
    return (document.getElementById(Events_GetCalendarBaseID(ctlName) + "_propIsHiddenFlagOuter").checked) ;
}
function Wkst_HiddenFlagChange(ctlName)
{
    Wkst_PropChangeMessage(null, GetBaseID(ctlName) + "_propEndDateContainer", true) ;
    return true ;
}

function Wkst_ExtractRadCalendarValue(ctlName)
{
    var radCtl = Wkst_GetRadCalendar(ctlName) ; 
    if (!radCtl)
        return "" ;
        
    if (radCtl.DateInput && radCtl.IsEmpty())
        return "" ;            
    else if (!radCtl.GetTextBox())
        return "" ;                    
    else if (!radCtl.DateInput && radCtl.GetTextBox().value.replace(/[ \/]/gi, "")=="")
        return "" ;        
    
    return radCtl.GetTextBox().value ; 
}

function Wkst_ClearCalendarValue(ctlName)
{
    var radCtl = Wkst_GetRadCalendar(ctlName) ; 
    if (!radCtl)
        return ;
        
    if (radCtl.DateInput && radCtl.IsEmpty())
        return ;            
    else if (!radCtl.GetTextBox())
        return  ;                    
    
    radCtl.GetTextBox().value = "" ; 
}

function Wkst_ExtractRadCalendarDefaultValue(ctlName)
{
    var radCtl = Wkst_GetRadCalendar(ctlName) ; 
    if (!radCtl)
        return "" ;
        
    var defaultControl = document.getElementById(ctlName + "_Default") ;
    if (defaultControl)
        return defaultControl.value ;        
    
    var defVal = radCtl.GetTextBox().defaultValue ;
    if ((new Date(defVal)).valueOf() == radCtl.MinDate.valueOf())
        return "" ; 
    
    return defVal ; 
}

function Wkst_RadCalendarHasChanged(ctlName)
{
    return (new Date(Wkst_ExtractRadCalendarValue(ctlName))).toDateString() != (new Date(Wkst_ExtractRadCalendarDefaultValue(ctlName))).toDateString() ;
}

function Wkst_RequiredField(ctlName, friendlyName)
{
    return "Value is required." ;
}

function Wkst_MustBeNumber(ctlName, friendlyName)
{
    return "Value must be an number (no decimal places allowed)." ;
}

function Wkst_DateMustBeFuture(ctlName, friendlyName)
{
    return "Date must be a future date." ;
}

function Wkst_HiddenFieldHasData(ctlName)
{
    return document.getElementById(ctlName) &&
           document.getElementById(ctlName).innerHTML != "" ;
}

function Wkst_SpanFieldExtractor(ctlName)
{
    if (document.getElementById(ctlName))
        return document.getElementById(ctlName).innerHTML ;
    
    return "" ;                        
}

function Wkst_SpanFieldDefaultExtractor(ctlName)
{
    if (document.getElementById(ctlName + "Default"))
        return document.getElementById(ctlName + "Default").innerHTML ;
    
    return "" ;                        
}

function Wkst_SpanHasChanged(ctlName)
{   
    var ctl = document.getElementById(ctlName) ; 
    if (!ctl)
        return false ;

    return tic_Utilities.HasStyle(Wkst_GetWrapperClass(ctl), "changed") ;
}

function Wkst_SimpleChangedMessage(ctlName)
{
    return " changed."
}

function Wkst_SpinnerClick(ctl)
{
    var options = ctl.options ;

    var lastSelected = ctl.getAttribute("lastSelected") ;
    if (lastSelected != -1 && lastSelected < options.length)
       options[lastSelected].selected = false ;

    for (var ii=0 ; ii<options.length ; ++ii)
	if (options[ii].selected)
	{
	    ctl.setAttribute("lastSelected", ii) ;
	    return ;
        }
}

function Events_ValidEmail(ctlName)
{
    if (!Wkst_EditHasValue(ctlName))
        return true ;
        
    return Wkst_FieldIsEmail(ctlName) ;        
}

function Events_BadEmail(ctlName)
{
    return "Invalid email format detected" ;
}

function Events_GetCalendarBaseID(ctlName)
{
    var baseID = GetBaseID(ctlName) ;
    while (baseID && baseID.lastIndexOf('Container') == (baseID.length - String('Container').length))
        baseID = GetBaseID(baseID) ;
        
    return baseID ;        
}

function Events_SetEndDate(startDate, baseID)
{
    if (Wkst_ExtractRadCalendarValue(baseID + "_eventEndDateContainer"))
        return ; // it has a value, thank you

    var jsDate = new Date(startDate) ;
    var endDateCtl = Wkst_GetRadCalendar(baseID + "_eventEndDateContainer") ;
    endDateCtl.SetDate(jsDate) ;
    endDateCtl.SetInputDate(jsDate) ;
}

function Events_DateTest(baseID)
{
    var startDate = Wkst_ExtractRadCalendarValue(baseID + "_eventStartDateContainer") ;
    var endDate   = Wkst_ExtractRadCalendarValue(baseID + "_eventEndDateContainer") ;
    if (!endDate)
    {
        Events_SetEndDate(startDate, baseID) ;
        return true ;
    }        

    return (new Date(startDate) <= new Date(endDate)) ;
}

function Events_TestStartDate(ctlName)
{
    var baseID = Events_GetCalendarBaseID(ctlName) ; 

    return Events_DateTest(baseID) ;
}

function Events_TestEndDate(ctlName)
{
    var baseID = Events_GetCalendarBaseID(ctlName) ; 
    Wkst_PropChangeMessage(null, baseID + "_eventStartDateContainer", false) ;

    return true ;
}

function Events_ValidateAllDay(ctlName)
{
    return true ;
}

function Events_StartDateMessage(ctlName)
{
    return "Start Date must be before End Date" ;
}

function Events_EndDateMessage(ctlName)
{
    return "" ;
}

function Events_TestStartTime(ctlName)
{
    return true ;
}
function Events_TestEndTime(ctlName)
{
    return true ;
}
function Wkst_CalendarInputOnBlur(sender, args)
{
    if (!sender || !sender.ID)
        return ;
        
    var baseID = Events_GetCalendarBaseID(GetBaseID(sender.ID)) ; /* first GetBaseID clears _dateInput */
    Events_SetEndDate(Wkst_ExtractRadCalendarValue(baseID + "_eventStartDateContainer"), baseID)
}

function Wkst_PageLayoutValid(ctlName)
{
    if (!Wkst_ControlShouldBeUsed(ctlName))
        return true ;

    var ctl = document.getElementById(ctlName) ;
    if (!ctl)
        return true ;
    
    var value = Wkst_GetSelectValue(ctlName) ;
    if (!value || String(value) == "-1")
        return false ;
        
    return true ;                               
}