/* ==================================================================
 *The JavaScript Validation objects to be used in form validation.
 * Copyright (c) 2001 by Blackboard, Inc.,
 * 1899 L Street, NW, 5th Floor
 * Washington, DC, 20036, U.S.A.
 * All rights reserved.
 * Submit RFC & bugs report to: aklimenko@blackboard.com
 * This software is the confidential and proprietary information
 * of Blackboard, Inc. ("Confidential Information").  You
 * shall not disclose such Confidential Information and shall use
 * it only in accordance with the terms of the license agreement
 * you entered into with Blackboard.
 * ==================================================================*/

/************************************************************
* Object formCheckList. Use this object to hold form objects
* to be validated and perform form validation
************************************************************/

var formCheckList = new formCheckList();
var dblSubmit = false;
var skipValidation=false;

function formCheckList(){
	this.checkList  = new Array();
	//this.superGroups= new Array(); // Create empty array for objects representing groups of radio/checkbox groups
	this.addElement = addElement;
	this.check      = checkForm;
}

function addElement(element){
	if (typeof element.group != 'undefined'){
		for (var i=0; i < this.checkList.length;i++){
			if (this.checkList[i].name == element.group){
				this.checkList[i].addElement(element);
				return;
			}
		}
		var grp = new CheckGroup(element);
		grp.addElement(element);
		this.checkList[this.checkList.length] = grp;
		return;
	}
	this.checkList[this.checkList.length] = element;
}

function checkForm(){
	var valid =true;
	for (var i=0;i<this.checkList.length;i++){
		if (!this.checkList[i].check()){
		  if(this.checkList[i].answerChk){valid=false;}
		  else {return false};
		}
	}
	return valid;
}
///////////////////End of object formCheckList////////////////

/************************************************************
* Object: inputText. Use this object to validate text input in
* your form (for input type == text|password|textarea|file)
************************************************************/
function inputText(h){
	this.element        = 'document.forms[0]["'+h.name+'"]';
	this.formatElement  = 'document.forms[0]["'+h.display_format+'"]';
	this.fieldName      = h.name;
	this.disable_script = h.disable_script;
	this.ref_label      = h.ref_label;
	this.custom_alert   = h.custom_alert;
	this.minlength      = h.minlength;
	this.maxlength      = h.maxlength;
	this.trim           = h.trim;
	this.regex          = h.regex;
	this.regex_msg      = h.regex_msg;
	this.regex_match    = h.regex_match;
	this.verify         = h.verify;
	this.check          = inputTextCheck;
	this.valid_number   = h.valid_number;
	this.valid_float    = h.valid_float;
	this.valid_email    = h.valid_email;
	this.valid_url      = h.valid_url;
	this.required_url   = h.required_url;
	this.invalid_chars  = h.invalid_chars;
	this.cmp_element    = 'document.forms[0]["'+h.cmp_field+'"]';
	this.cmp_ref_label  = h.cmp_ref_label;
	this.xor            = h.xor;
	this.cmp_required   = h.cmp_required;
	this.activeX        = h.activeX;   // synch activeX to hidden field before submission
	this.isHtmlDoc      = h.isHtmlDoc; // is portfolio with body and html
	this.img_check      = h.img_check;
  if (document.all && document.getElementById(h.name+'_ax')){this.axobj = document.getElementById(h.name+'_ax');}
  
    // Add here anything you need to validate
}


// Do actual check here
function inputTextCheck(){

	var element = eval(this.element);	
	var cmp_element = eval(this.cmp_element);
	if (typeof element != 'undefined'){
	  var focusElement = element;
	  if (this.axobj) { focusElement = this.axobj; }
		this.custom_alert = (typeof this.custom_alert != 'undefined') ? this.custom_alert : '';
		this.ref_label = (typeof this.ref_label != 'undefined') ? this.ref_label :"'"+element.name + "' input field";
		var val    = element.value;
		if (!val.replace(/<p><\/p>/gi,'').trim()){val='';}  
		
		if (typeof eval(this.formatElement) != "undefined"){       
			//Check if it is a mathml where;
			if(/<APPLET ID="(\d+)" NAME="(\w+)"/.test(element.value)){
				if (getRadioValue(eval(this.formatElement)) == 'P'){
					if(!confirm(JS_RESOURCES.getString('confirm.plain_text'))) {
						element.focus();return false;
					}
				}
			}
		}
		if (this.trim) {val = val.trim(); element.value = val;} //Remove leading & trailing spaces if needed
		
		if (typeof cmp_element != 'undefined'){
			if(this.xor){
				if(val.trim()=='' ^ cmp_element.value.trim()==''){
				  if(val.trim()==''){
				    alert(JS_RESOURCES.getFormattedString('cmp_field.required',
					                                                new Array(this.ref_label, this.cmp_ref_label)));
				    shiftFocus(focusElement);
				  }else{
				    alert(JS_RESOURCES.getFormattedString('cmp_field.required',
					                                                new Array(this.cmp_ref_label, this.ref_label)));
				    cmp_element.focus(); 
				  }					
					return false;
				}
			}
		}
		
		if (this.disable_script){
			if (typeof eval(this.formatElement) == "undefined" || getRadioValue(eval(this.formatElement)) != 'P'){
				var re	= /<\s*script/ig;
				var re1 = /<\s*\/\s*script\s*>/ig;
				val     = val.replace(re,'<disabled-script');
				val		= val.replace(re1,'</disabled-script>');
				var re2 = /href\s*=\s*(['"]*)\s*javascript\s*:/ig;
				val     = val.replace(re2,"href=$1disabled-javascript:");
				element.value = val;
			}
		}
	    if (this.valid_number){
	        var trimmedVal = val.trim();
	        var numVal = parseInt(trimmedVal);
	        var isValidNum = !isNaN(numVal) && (numVal.toString().length == trimmedVal.length);
	        if (!isValidNum){
	          alert(JS_RESOURCES.getFormattedString('validation.number', new Array(this.ref_label)));
		      element.focus();
			  return false;
	        }  
	    }
        if (this.valid_float) {
            var trimmedVal = val.trim();
            var numFormat = JS_RESOURCES.getString('float.format');
            var numVal, isValidNum;
            if ( typeof( numFormat ) != 'undefined' )
            {
                //hand parse for l10n
                var re = new RegExp( numFormat );
                isValidNum = trimmedVal.search( re ) == 0;
            }
            else
            {
                //try to use platform native (non-localized)
                numVal = parseFloat(trimmedVal);
                isValidNum = !isNaN(numVal);
                if (isValidNum && numVal.toString().length != trimmedVal.length) {
                    /* Allow strings with trailing zeros to pass */
                    var re = /^[\.0]+$/;
                    isValidNum = re.test(trimmedVal.substring(numVal.toString().length));
                }
            }
            if (!isValidNum){
	          alert(JS_RESOURCES.getFormattedString('validation.number', new Array(this.ref_label)));
		      element.focus();
			  return false;
	        }  
        }
		if (this.valid_email){
			re = /^(['a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9])+$/; 
			if (!re.test(val)){
				alert(JS_RESOURCES.getFormattedString('validation.email', new Array(this.ref_label)));
				element.focus();
				return false;
			}     
		}
    // required_url, unlike valid_url, flags empty strings as invalid URLs.
    if (this.required_url) 
    {
      if (val.trim() == '') {
        alert(JS_RESOURCES.getFormattedString('validation.required', new Array(this.ref_label)));
        return false;
      }
      if (!isValidUrl(val)) {
        alert(JS_RESOURCES.getFormattedString('validation.url', new Array(this.ref_label)));
        element.focus();
        return false;
      }
    }
		if (this.valid_url) 
        {
            if (val.trim()=='') 
              return true;

            var oRegExp = /[^:]+:\/\/[^:\/]+(:[0-9]+)?\/?.*/;
            if (!oRegExp.test(val))
            {
                alert(JS_RESOURCES.getFormattedString('validation.url', new Array(this.ref_label)));
                element.focus();
                return false;
            }
        }
		if (typeof(this.regex) == 'string'){this.regex=eval(this.regex);}
		if ((typeof(this.regex) == 'object' || typeof(this.regex) == 'function') && val.trim() != ''){
			re =this.regex;        
			if (this.regex_match && val.search(re) == -1){
				alert(this.regex_msg + this.ref_label + '.');
				shiftFocus(focusElement);
				return false;
			}
			if (!this.regex_match && re.test(val)){
				alert(this.regex_msg + this.ref_label + '.');
				shiftFocus(focusElement);
				return false;
			}
		}

		if (this.invalid_chars){
			var arr = val.invalidChars(this.invalid_chars);
        
			if (arr && arr.length){
				alert(JS_RESOURCES.getFormattedString('validation.invalid_chars',
				                                                new Array(this.ref_label, arr.join('\n'))));
				shiftFocus(focusElement);
				return false;       
			}
		}
		if (val.length < this.minlength){
			if (this.minlength == 1){
				alert(this.custom_alert ? this.custom_alert
					: JS_RESOURCES.getFormattedString('validation.required', new Array(this.ref_label)));
			}else{
				alert(this.custom_alert ? this.custom_alert
					: JS_RESOURCES.getFormattedString('validation.minimum_length',
					                                            new Array(this.minlength, this.ref_label)));
			}
			shiftFocus(focusElement);
			return false;
		} 
		if (this.maxlength < val.length){
		    if ((val.length - this.maxlength) > 1) {
	    		alert(JS_RESOURCES.getFormattedString('validation.maximum_length.plural',
					new Array(this.ref_label,this.maxlength,(val.length-this.maxlength))));
			} else {
				alert(JS_RESOURCES.getFormattedString('validation.maximum_length.singular',
					new Array(this.ref_label,this.maxlength)));
			}
			shiftFocus(focusElement);
			return false;
		}
		if (this.verify){
			var chk_field = document.forms[0][element.name.replace(/_inp$/,'_chk')];
			var field     = document.forms[0][element.name.replace(/_inp$/,'')]; 

			if (chk_field.value != val){
				alert(JS_RESOURCES.getFormattedString('validation.mismatch', new Array(this.ref_label)));
				chk_field.focus();
				return false;
			}        
			// Encode password
			if (element.type == 'password'){
				element.value = element.value.trim();
				if (element.value != ''){
					element.value = field.value = chk_field.value = calcMD5(element.value);
				}else{
				  alert(JS_RESOURCES.getString('validation.password'));
				  element.value = field.value ='';
				  element.focus();
				  return false;
				}          
			}         
		}
		
		if (this.cmp_required && element.value.trim()!=''){
		    if (!cmp_element.value.trim().length){
				alert(JS_RESOURCES.getFormattedString('validation.cmp_field.rejected',
					new Array(this.ref_label, this.cmp_ref_label)));
		        cmp_element.focus();
		        return false;
		    }
		}
		if (this.img_check){
		  return image_check(element);
		}  
	}
	return true;
}

///////////////////End of object inputText///////////////////


function image_check(element){

  ext = element.value.match(/.*\.(.*)/); 
  ext = ext ? ext[1] :'';  
  re = /gif|jpeg|png|tif|bmp|jpg/i; 
  if (! re.test(ext) && element.value) {
    if (! confirm(JS_RESOURCES.getFormattedString('validation.image_type', new Array(ext)))){
      element.focus();
      return false;
    }   
  }
  return true;  
}





/************************************************************
*    Object: Check_EventTime. Use this object to make sure
*    that the end time is not before the start time, confirm pastdue time,
*    check duration of the event. 
*************************************************************/

function Check_EventTime(obj){
	this.start      = "document.forms[0]['"+obj.name+"']";
	this.ref_lbl    = obj.ref_label;
	this.end        = "document.forms[0]['"+obj.cmp_field+"']";
	this.cmp_ref_lbl= obj.cmp_ref_label;
	this.notEqual   = obj.duration;
	this.pastDue    = obj.past_due;
	//restrict flags fields
	this.restrict   = "document.forms[0]['"+obj.restrict_flag+"']";
	this.cmp_restrict="document.forms[0]['"+obj.cmp_restrict_flag+"']";
	this.show_end_time = obj.show_end_time;
	// define method
	this.check      = Check_EventTime_check;
}

function Check_EventTime_check(){
	var start, end, restr, cmp_restr;
	start = eval(this.start);		// first datetime field
	end   = eval(this.end);			// second datetime field to be compared with first
	restr = eval(this.restrict);	// Restrict checkbox field
	cmp_restr = eval(this.cmp_restrict);  // Restrict checkbox field to compare to

	restr     = (typeof(restr)     != 'undefined') ? restr.checked : true;      // True if restrict checkbox
	cmp_restr = (typeof(cmp_restr) != 'undefined') ? cmp_restr.checked : true;  // is checked or not defined

	// Update time in hidden field
	// Set time to empty string if it is not restricted
	if (!restr){start.value = '';}
	if (!cmp_restr || (this.show_end_time && !restr)){end.value   = '';} // Second field has to be set also
	start = start.value;
	if (typeof end != 'undefined'){
		end = end.value;
	}
	// Do not compare fields if at least one checkbox is unchecked
	if(!restr || !cmp_restr){
		this.notEqual = 0;
	}
	// Do not test for past due if restiction is not applied

	if (!restr){this.pastDue = 0;}
	if (this.pastDue){
		var confirm;
		var start_ms = Date.parse(start.replace(/-/g,'/'));      
		if (start_ms < Date.parse(new Date())-this.pastDue*1000*60){
			if (!window.confirm(this.ref_lbl+" is in the past.\nWould you like to continue with this "+this.ref_lbl+"?")){
				return false;
			}
		}
	}
	if (start > end && this.notEqual){
		alert(JS_RESOURCES.getFormattedString('validation.date_past',
			                                             new Array(this.cmp_ref_lbl, this.ref_lbl)));
		return false;
	}
	else if (end == start && this.notEqual){
		alert(JS_RESOURCES.getFormattedString('validation.date_equal',
													    new Array(this.cmp_ref_lbl, this.ref_lbl)));
		return false;
	}    
	return true;
}

/*We always need time in our favorite format
*/
function sql_datetime(dat){
	var year = dat.getFullYear();
	var mon  = dat.getMonth();
	mon++;						mon = (mon<10)?'0'+mon:mon;
	var day = dat.getDate();	day = (day<10)?'0'+day:day;
	hh		= dat.getHours();	hh  = (hh<10)?'0'+hh:hh;
	mi		= dat.getMinutes();	mi  = (mi<10)?'0'+mi:mi;
	ss		= dat.getSeconds();	ss  = (ss<10)?'0'+ss:ss;
	return  year+'-'+mon+'-'+day+' '+hh+':'+mi+':'+ss;
}
///////////////////End of object Check_EventTime/////////////

/********************************************************************************
* Object DoubleSubmit():
* Use this object to prevent multiple times form submission
* Second argument is wait image source; first argument is image name (string) or
* instance of ImageSwapper object created for submit button (if it has rollovers)
*********************************************************************************/

// Prevent multiple form submission
function DoubleSubmit(){


	this.submitted = 0;
	this.check = checkDoubleSubmit;
}

function checkDoubleSubmit(){






	if (this.submitted > 0){
	  alert (JS_RESOURCES.getString('notification.submit'));
		return false;
	}else{
		this.submitted++;
	}
	return true;
}
///////////////////End of Object DoubleSubmit()//////////////////

/********************************************************************************
* Object CheckRadioBox():
* Use this object to make sure that at least one item is selected from the group of
* radio/checkbox groups. Just attach this code to checkbox/radio group (refered below as 'element'):
* formCheckList.addElement(new CheckRadioBox({name:'element or subgroup name',group:'group name',ref_label:"group label in alerts"}));
*********************************************************************************/
// Constructor function
function RadioCheckBox(h){
	return h;
}

function CheckGroup(h){
	this.name       = h.group;
	this.ref_label  = h.ref_label;
	this.elements   = new Array();
	this.addElement = groupAddElement;
	this.check      = checkGroupChecked;
}

function groupAddElement(h){
	this.elements[this.elements.length]   = h.name;	
}

function checkGroupChecked(){
	var list = this.elements;
	var chk  = false;
	for (var i = 0; i < list.length; i++){
		if (groupIsChecked(list[i])){return true;};
	}

	var msg = null;
	var group = document.forms[0][list[0]];		
	group = (typeof group[0] != 'undefined') ? group[0]:group;
	
	if ( group.type == "radio" )
		msg = JS_RESOURCES.getFormattedString('validation.radio.required', new Array(this.ref_label));
	else
		msg = JS_RESOURCES.getFormattedString('validation.option.required', new Array(this.ref_label));
	
	alert(msg);
	group.focus();
	return false;
}

function groupIsChecked(groupName){
	var group = eval('document.forms[0]["'+groupName+'"]');
	var checked = false;
	if (typeof group != 'undefined'){
		if (group.length  > 1){
			for (var i=0;i< group.length; i++){
				if (group[i].checked){
					checked = true;
					return checked;
				}
			}
		}else{
			if (group.checked){
				checked = true;
				return checked;
			}
		}
	}
	return checked;
}
///////////////////End of Object CheckGroup()////////////////////


//////////////// Start some useful generic functions ////////////

/* FUNCTION  strip() : removes all white spaces from the provided string:
   Usage: strippedString = originalString.strip();
*/
function strip(){
	return this.replace( /\s+/g,'');
}
String.prototype.strip= strip;


/* 	Function ltrim(): Remove leading  spaces in strings:
	Usage:trimmedString = originalString.ltrim();
*/
function ltrim(){
	return this.replace( /^\s+/g,'');
}
String.prototype.ltrim = ltrim;

/* 	Function rtrim(): Remove trailing spaces in strings:
	Usage:trimmedString = originalString.rtrim();
*/
function rtrim(){
	return this.replace( /\s+$/g,'');
}
String.prototype.rtrim = rtrim;


/* 	Function trim(): Remove leading and trailing spaces in strings:
	Usage:trimmedString = originalString.trim();
*/
function trim(){
	return this.rtrim().ltrim();;
}
String.prototype.trim = trim;

/*  
// Function trim_all is same as trim() but it treats string as multiple lines
function trim_all() {
	return this.replace( /^\s+|\s+$/gm,'');
}

//Function nice_striper will remove all whitespaces except new line from the string 
function nice_striper {
	return this.trim_all().replace(/(.)+\s+/gm,\1);
}  
*/


/* Function invalidChars(): Returns an array of illegal chars 
   Usage: var listOfChars = myStringToSearch.invalidChars(regularExpression); 
   regularExpression = /[illegal chars]/g; Sample re = /[! &^$#]/g
*/  
function invalidChars (re){  
	var chrs = this.match(re);
	if (chrs){
		for (j=0;j<chrs.length;j++){
			if(chrs[j]==' '){chrs[j]=JS_RESOURCES.getString('invalid_char.space');}
			if(chrs[j]==','){chrs[j]=JS_RESOURCES.getString('invalid_char.comma');}    
		}       
	}
	return chrs; 
}
String.prototype.invalidChars = invalidChars;

/** Function getRadioValue(): Returns selected value for group of radio buttons
* Usage: var selectedValue = getRadioValue(radio); radio - reference to radio group
*/
function getRadioValue(radio){
	for (var i=0;i< radio.length;i++){
		if (radio[i].checked){
			return radio[i].value;
		}
	}  
}

/** Function isEmptyWysiwyg(): Checks WYSIWYG control for value
*/

var wysiwyg_empty_regexp = /^(\s|\<P\>|\<\/P\>|\&nbsp\;)*$/i;
function isEmptyWysiwyg(field) {
  return wysiwyg_empty_regexp.test(field.value);
}

/** Function isValidUrl(): Checks if given string is in the general URL format
*/
function isValidUrl(string) {
  var oRegExp = /[^:]+:\/\/[^:\/]+(:[0-9]+)?\/?.*/;
  return ( oRegExp.test(string) );
}

/*Function submitForm()
  Call this function to validate and submit form
*/
function submitForm(){
	if (validateForm()){      
		document.forms[0].submit();
	}
}

/*Function validateForm()
  Call this function onSubmit inside <form> tag
*/
function validateForm(){
	var ismath = (typeof(api) !='undefined'); //True if webeq is there
	
	/* Transform equations place holders into html before validation*/
	if (ismath){api.setHtml();}
	if (skipValidation){return true;}
	/* Validate form*/
	var valid = formCheckList.check();	
	/*Check for invalid answers if any present*/
	var list='';
	var x=0;
	var tmp="";

	if (typeof(invalidAnswers) == 'object' && invalidAnswers.length > 0){
	//list += invalidAnswers.join('\n')+'\n'; 
	  for (x=0; x<invalidAnswers.length; x++) {
		list += invalidAnswers[x]

		if (((x+1) % 10)==0) {
				list += ",\n";
		}  
		else {
		  list +=",";
		}
	  }	

	}
	if (typeof(invalidAnswersTmp) == 'object' && invalidAnswersTmp.length > 0){
	//	list += invalidAnswersTmp.join(', '); 
	  for (x=0; x<invalidAnswersTmp.length; x++) {
		list += invalidAnswersTmp[x]

		if (((x+1) % 10)==0) {
				list += ",\n";
		}  
		else {
			list +=",";
		}
	  }		
	}

	
	if (list != '' && valid){
	  if(!confirm(JS_RESOURCES.getFormattedString('assessment.incomplete.confirm', new Array(list)))){
	    valid = false; //User decided not to submit	    
	  }
	  invalidAnswersTmp = []; //Clearing up
	}
	/* Go back to placeholders if validation failed (valid == false)*/
	if (ismath && !valid){api.setMathmlBoxes();}
	/* If everything is OK and ready to go,check that the form was not already submitted */
	if (valid && dblSubmit != false){	  
	  valid = dblSubmit.check();
	}
	return valid;
}

/*Function boxSelector()
* Use this function to select, unselect or invert selection for specified checkbox groups
* Call: boxSelector(['name1','name2',...,'namen'],action), here action is 'select', or 'unselect', or 'invert'
*/
function boxSelector(list,action){
	var action = (action == 'select') ? true : (action == 'unselect') ? false : action;
	for (var i=0;i<list.length;i++){
		var group = 'document.forms[0]["'+list[i]+'"]';
		if (typeof (group = eval(group)) != 'undefined'){
			if (action == 'invert'){
				for (var j=0;j<group.length;j++){
					group[j].checked = !group[j].checked;
				}
			} else {
				for (var j=0;j<group.length;j++){
					group[j].checked = action;
				}
			}
		}
	}
}


function setHidden (from,to){
	var hide = eval(to);
	hide.value = from.value;
}


//////////////////////////////////////////////////////////////////
/**
* Check_Answer object was added by request specified in mscr 524
* to provide validation to student answers
* Variable invalidAnswers has to be added to the page where assessment is submitted
* It should contain the list of unfinished questions excluding  question(s) on current page
* Check_Answer object will perform final validation and display all unfinished questions in confirm box
*/

var invalidAnswers = new Array(); // the java code will populate this array on final QbyQ page
/** Object constructor for answers walidation
* 
*/

function Check_Answer (vobj){ 
  if (typeof(window.invalidAnswersTmp)=='undefined'){window.invalidAnswersTmp=[];}
  this.element    = 'document.forms[0]["'+vobj.name+'"]';
  this.name       = vobj.name;
  this.answerChk  = true; //Check_Answer is special check, it makes a list of unfinished questions and always return true
  this.ref_label  = vobj.ref_label;  
  this.check      = Check_Answer_check;  
}

function Check_Answer_check(){
  
  //create form element object
  el = eval(this.element); 
  
  //Extract question type information from element name  
  var qtype =  /^(\w+)-/.exec(this.name);
  qtype = qtype[1];  
  if (qtype == 'ma'){
    qtype = /-\d+$/.test(this.name) ? 'mat' : 'ma';
  }
  
  // Perform actual check-up
  if (qtype == 'tf' || qtype == 'mc' || qtype == 'ma'){
    if(!isChecked(el)) {invalidAnswersTmp[invalidAnswersTmp.length]=this.ref_label;}  
  }  
  else if (qtype == 'ord' || qtype == 'mat'){
    if(el.selectedIndex == 0 && this.ref_label != invalidAnswersTmp[invalidAnswersTmp.length-1]){
        invalidAnswersTmp[invalidAnswersTmp.length]= this.ref_label;
      }  
  }
  else if (qtype == 'fitb' || qtype == 'essay'){
    if (el.value.trim() == ''){
      invalidAnswersTmp[invalidAnswersTmp.length]= this.ref_label; 
    }
  } 
  return true; //Always true, we can make decision later through confirm
}

// Test if at least one member of radio or checkbox group is selected
function isChecked(grp){
	for (var i=0;i< grp.length;i++){
		if (grp[i].checked){
			return true;
		}
	}
	return false; 
}

// wrapper function for focus() calls
function shiftFocus(el) {
  if (!el.disabled && !el.readOnly && el.type != "hidden") {
    el.focus() 
  }
  return;
}

/* This is a sample code that has to be added to every corresponding form element in take assessment page,
where you perform question validation for completness; 
ref_lablel value is used to refer to element, name is field full name:

<script type="text/javascript">
formCheckList.addElement(new Check_Answer({ref_label:"Question 3",name:"tf-ans-_190_1"}));
</script>

*/