// *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
// |
// | .i X   F o r m  C h e c k s    v . 1 . 0
// | 
// | by Christian Messow alias Vereiser / Eismond
// | Created in the days of may 2007
// | last updated on 12.06.2007
// |
// | All rights reserverd by Engineer.iX
// | http://www.ix-forms.de
// | http://www.engineerix.de
// |
// | This script is under Licence ....
// |
// *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*


// The Script will not run correctly, if
// 1. a name for a non array input field is set more than one in the formular
// 2. the type definition of an input field of the field type 'input' is not set
// 3. input fields of the type array are defined without [] in the name
// 4. the css styles for the input field highlighting is not in the following order:   needed, error, disabled

function ixFormChecks( check_form_object, browser )
{
	/**
	 *
	 * Parameters for the value types:
	 * -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
	 * DATE:        Datum
	 * EMAIL:       email address
	 * URL:         url-adress
	 * IP ADRESS:   IP address
	 * LETTER:      letters only
	 * INTEGER:     integer number
	 * DECIMAL:     decimal number
	 * STRING:      normal text
	 * TELEPHON:    telephon number
	 * BOOLEAN:     boolean value
	 *
	 */
	
	/* = = = = = = = = = = = = = = = = = = = = = CONFIGURATION = = = = = = = = = = = = = = = = = = = = = = */
	if (!check_form_object)
	{
		alert( "iX.formChecks : Please define the name of the instance of the ixFormChecks object." );
		return false;
	}
	
	// Config: objects of the formChecksObject
	this.config = new Object();
	this.check = new Object();
	this.event = new Object();
	
	this.config.error                   = new Boolean();
	this.config._field_settings         = new Array();
	this.config._languages              = new Array();
	this.config.css_syntax_error        = new String();
	this.config.css_disabled            = new String();
	this.config.childfield_disable      = new Boolean();
	this.config.field_number            = new Boolean();
	this.config.css_alert               = new Number();
	this.config.preventForWrongSigns = new Boolean();
	this.config.store                   = new Array();
	this.config.onChangeMode           = new String();            // highlight, alert, highlight_and_alert
	this.config.idSubmitButton           = new String();            // highlight, alert, highlight_and_alert
	this.config.cssSubmitButton           = new String();            // highlight, alert, highlight_and_alert
	this.config.disableSubmitButton    = new Boolean();
	this.config.browser    = new String();
	
	this.config.mode_alert              = "SYSTEM";           // window, form, system
	this.config.onSubmitMode           = "ALERT";            // highlight, alert, highlight_and_alert
	this.config.mode_order              = "STANDARD";
	this.config.check_form_object       = check_form_object;
	this.config.browser  = browser;
	
	this.event.alertIsShown              = new Boolean();
	
	
	/* = = = = = = = = = = = = = = = = = = = = = PUBLIC METHODS = = = = = = = = = = = = = = = = = = = = = */
	/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* CONFIGURATION -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* */
	
	// Config: order error messages by tabindex or its configuration order
	this.config.orderByTabIndex = function tabindex_order( order_mode )
	{
		if ( order_mode )
		{
			this.mode_order = "TABINDEX";
		}
	}
	
	// Config: modus onsubmit
	this.config.loader = function loader( switching  )
	{
		this.loader = switching;
	}
	
	// Config: modus onsubmit
	this.config.alertModeOnSubmit = function alertModeOnSubmit( mode  )
	{
		this.onSubmitMode = mode;
	}
	
	// Config: modus onchange
	this.config.alertModeOnChange = function alertModeOnChange( mode  )
	{
		this.onChangeMode = mode;
	}
	
	// Config: disable submit button as long as the form has not been completed
	this.config.disableSubmitButton = function disableSubmitButton( disable_submit_button, idButton, cssButton )
	{
		this.disableSubmitButton = disable_submit_button;
		this.idSubmitButton = idButton;
		this.cssSubmitButton = cssButton;
	}
	
	// Config: language
	this.config.language = function language( actual, languages )
	{
		this.actual_language = actual;
		this._languages = languages;
		
		for ( var m in this._languages )
		{
			if (this.actual_language==this._languages[m])
			{
				this.actual_language = m;
			}
		}
	}
	
	// Config: input field styles
	this.config.inputCss = function inputCss( css_needed, css_highlight, css_disabled )
	{
		this.css_syntax_error = css_highlight;
		this.css_disabled     = css_disabled;
		this.css_needed       = css_needed;
	}
	
	// Config: disable childs, if parent has child not been activated
	this.config.disableChilds = function disableChilds( disable_childs )
	{
		this.childfield_disable = disable_childs;
	}
	
	// Config: settings for the presentation of the alert message
	this.config.alertSettings = function alertSettings( mode, css, head_alert, message_alert, field_number )
	{
		// Mode= div or system
		if (!css&&mode!="WINDOW")
		{
			alert( "iX.formChecks | method - alertSettings: Please define a css-id for the alert window." );
			return false;
		}
		
		switch (mode)
		{
			case "WINDOW":
			case "SYSTEM":
			case "ELEMENT":
				break;
			
			default:
				alert("Only use 'WINODW, SYSTEN, ELEMENT' in argument 1 in alert_settings.");
				return false;
				break;
		}
		
		this.css_alert = css;
		this.mode_alert = mode;
		this.head_alert = head_alert;
		this.message_alert = message_alert;
		this.field_number = field_number;
	}
	
	// Config: check on impossible signs in all input fields
	this.config.inputControl = function inputControl( value )
	{
		this.preventForWrongSigns = value;
	}
	
	// Config: input field
	this.config.field = function field
	( 
		form_id, 
		name, 
		needed, 
		value_type, 
		default_value,
		possible_values,
		error_message_syntax, 
		error_message_possible_values, 
		error_message_missing, 
		min_length, 
		max_length, 
		parent_field,
		parent_activation_values
	)
	{
		var possible_values_array = new Array();
		var default_values = new Array();
		var e = this._field_settings.length;
		var setted = false;
		
		if (!form_id)                               { alert ( "Please define the id of the formular the input field is a part of." ); return false; }
		if (!name)                                  { alert ( "Please define a name of an input field that has to be checked." );    return false; }
		if (!value_type)                            { value_type = "STRING";                                                          }
		if (!needed)                                { needed = false;                                                                 }
		if (!error_message_syntax)                  { error_message_syntax = new Array(); error_message_syntax[0] = name+" has the wrong syntax.";                           }
		if (!error_message_missing&&needed)         { error_message_missing = new Array(); error_message_missing[0] = name+" is empty.";                                      }
		if (!error_message_possible_values&&needed) { error_message_possible_values = new Array(); error_message_possible_values[0] = "Only use "+possible_values+" in "+name;        }
		if (!min_length)                            { min_length = 0;                                                                 }
		if (!max_length)                            { max_length = 0;                                                                 }
		if (!possible_values)                       { possible_values = new Array();                                                  }
		if (!parent_activation_values)              { parent_activation_values = new Array();                                         }
		if (!parent_field)                          { parent_field = new String();                                                    }
		if (!default_value)                         { default_value = new String();                                                    }
		
		if (value_type=="boolean")
		{
			max_length = 1;
		}
		
		possible_values_array = possible_values;
		
		switch (value_type)
		{
			case "URL":
				if (possible_values!="")
				{
					for ( var i=0; i < possible_values_array.length; i++)
					{
						switch (possible_values_array[i])
						{
							case "!":
							case "FTP":
							case "HTTP":
							case "HTTPS":
							case "POP3":
							case "SMTP":
							case "IMAP":
							case "PPTP":
							case "PPP":
							case "IP":
							case "TCP":
							case "MYSQL":
							case "MAILTO":
							case "LOCALHOST":
								break;

							default:
								alert( "iX.formChecks | method - config.field: Definition wrong: '"+possible_values_array[i]+"' for field '"+name+"' in form '"+form_id+"'.\n\nOnly use FTP, HTTP, HTTPS, POP3, IMAP, SMTP, PPTP, PPP, TCP, MYSQL, IP." );
								return false;
								break;
						}
					}
				}
				break;
       
				case "TELEPHON":
					if (possible_values_array)
					{
						for ( var i=0; i < possible_values_array.length; i++)
						{
							switch (possible_values_array[i])
							{
								case 1:
								case 2:
								case 3:
								case "!":
								case "1":
								case "2":
								case "3":
									break;

								default:
									alert( "iX.formChecks | method - config.field: Definition wrong: '"+possible_values_array[i]+"' for field '"+name+"' in form '"+form_id+"'.\n\nOnly use 1 (number with state and location area code), 2 (number with location area code) and 3 (number only)." );
									return false;
									break;
							}
						}
					}
					break;    
			
			case "INTEGER":
				if (possible_values!="")
				{
					var reg_string = "^[0-9]*$";
					var reg = new RegExp(reg_string);

					for ( var i=0; i < possible_values_array.length; i++)
					{
						if (!reg.test(possible_values_array[i])&&possible_values_array[i]!="!")
						{
							alert( "iX.formChecks | method - config.field: Definition wrong: '"+possible_values_array[i]+"' for field '"+name+"' in form '"+form_id+"'.\n\nOnly use integer values.");
							return false;
						}
					}
				}
				break;

			case "DECIMAL":
				if (possible_values!="")
				{
					reg_string = "(^[0-9]{1,}$)|(^[0-9]{1,}[\.]{1}[0-9]{1,}$)";
					reg = new RegExp(reg_string);

					for ( var i=0; i < possible_values_array.length; i++)
					{
						if (!reg.test(possible_values_array[i])&&possible_values_array[i]!="!")
						{
							alert( "iX.formChecks | method - config.field: Definition wrong: '"+possible_values_array[i]+"' for field '"+name+"' in form '"+form_id+"'.\n\nOnly use decimal values.");
							return false;
						}
					}
				}
				break;
				
			case "LETTER":
				reg_string = "(^[a-zA-z鲣能]*$)";
				reg = new RegExp(reg_string);
				
				for ( var i in possible_values_array)
				{
					if (!reg.test(possible_values_array[i])&&possible_values_array[i]!="!")
					{
						alert( "iX.formChecks | method - config.field: Definition wrong: '"+possible_values_array[i]+"' for field '"+name+"' in form '"+form_id+"'.\n\nOnly use letters.");
						return false;
					}
				}
				break;
				
			case "STRING":
			case "EMAIL":
			case "DATE":
			case "IP ADRESS":
			case "BOOLEAN":
				break;
			
			default:
				alert( "iX.formChecks | method - config.field: Definition wrong of value type '"+value_type+"' for input field '"+name+"' not accepted'"+name+"'." );
				return false;
				break;
		}
		
		var full_name = form_id+"-"+name;
		for ( var c in this.store )
		{
			if (this.store[c]==full_name)
			{
				e = parseFloat(c);
				setted = true;
			}
		}
		
		if (!setted)
		{
			this.store[e]=full_name;
		}
		
		this._field_settings[e] = new Object();
		
		if (!this.store[0])
		{
			this.store[0] = full_name;
		}
		
		this._field_settings[e].name                          = name;
		this._field_settings[e].value_type                    = value_type;
		this._field_settings[e].needed                        = needed;
		this._field_settings[e].error_message_missing         = error_message_missing;
		this._field_settings[e].error_message_syntax          = error_message_syntax;
		this._field_settings[e].error_message_possible_values = error_message_possible_values;
		this._field_settings[e].form_id                       = form_id;
		this._field_settings[e].min_length                    = min_length;
		this._field_settings[e].max_length                    = max_length;
		this._field_settings[e].possible_values               = possible_values;
		this._field_settings[e].parent_activation_values      = parent_activation_values;
		this._field_settings[e].parent_field                  = parent_field;
		this._field_settings[e].default_value                 = default_value;
	}
	
	/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* EXTERNAL METHODS -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* */
	// basic public methods: check form reset
	this.reset = function reset( form_id )
	{
		this.onload( form_id );
	}

	// basic public methods: input field onchange event as onload event in the body
	this.onload = function onload( form_id )
	{
		var value          = new String();
		var obj_input_new  = new Array();
		var form_obj       = new Object();
		var obj_fields     = new Object();
		var obj_input      = new Object();
		var idSubmitButton = this.config.idSubmitButton;
		
		if (!document.getElementById(idSubmitButton))
		{
			alert( "iX.formChecks | method - onload: The submit button with the id '"+idSubmitButton+"' does not exist." );
			return false;
		}
		
		form_obj = document.getElementById( form_id );
		this.event.onload = true;
		
		if (!form_obj)   
		{
			alert( "iX.formChecks | method - onload: Formular with the id '"+form_id+"' not found." );
			return false;
		}
		else
		{
		for ( var a = 0; a < this.config._field_settings.length; a++)
		{
			var field_type = new String();
			
			if (form_id == this.config._field_settings[a].form_id )
			{
				obj_fields = form_obj[this.config._field_settings[a].name];
				
				if (obj_fields)
				{
					// field type of a single field
					if (obj_fields.name)
					{
						field_type = getFieldType( form_id, obj_fields.name );
					}
					else
					// field type of array fields
					{
						if (obj_fields[0].name)
						{
							field_type = getFieldType( form_id, obj_fields[0].name );
						}
						else
						{
							field_type = getFieldType( form_id, obj_fields.name );
						}
					}
					
					if (field_type=="")
					{
						field_type = "input_text";
					}
					
					if (obj_fields[0])
					// Wenn Eingabefeld aus mehreren Objekten besteht	
					{
						if (field_type!="select")
						{
							for ( var k=0; k < obj_fields.length; k++ )
							{
								obj_input_new[k] = obj_fields[k];
							}
						}
						else
						{
							if (obj_fields.options)
							{
								obj_input_new[0] = obj_fields;
							}
							else
							{
								for ( var k=0; k < obj_fields.length; k++ )
								{
									obj_input_new[k] = obj_fields[k];
								}
							}
						}
					}
					else
					// Wenn Eingabefeld aus einem Objekt besteht
					{
						obj_input_new[0] = obj_fields;
					}
					
					for ( var f = 0; f < obj_input_new.length; f++ )
					{
						obj_input = obj_input_new[f];
							
						if (obj_input&&(obj_input.name==this.config._field_settings[a].name)&&obj_input.name&&field_type!="")
						{
							obj_input.disabled = false;
						}
					}
					
					for ( var f = 0; f < obj_input_new.length; f++ )
					{
						obj_input = obj_input_new[f];

						if (obj_input&&(obj_input.name==this.config._field_settings[a].name)&&obj_input.name&&field_type!="")
						{
							obj_input.variables_cf = new Object();
							obj_input.variables_cf.check_form_object             = this.config.check_form_object;
							obj_input.variables_cf.name                          = this.config._field_settings[a].name;
							obj_input.variables_cf.form_id                       = this.config._field_settings[a].form_id;
							obj_input.variables_cf.value_type                    = this.config._field_settings[a].value_type;
							obj_input.variables_cf.error_message_syntax          = this.config._field_settings[a].error_message_syntax;
							obj_input.variables_cf.error_message_missing         = this.config._field_settings[a].error_message_missing;
							obj_input.variables_cf.error_message_possible_values = this.config._field_settings[a].error_message_possible_values;
							obj_input.variables_cf.min_length                    = this.config._field_settings[a].min_length;
							obj_input.variables_cf.max_length                    = this.config._field_settings[a].max_length;
							obj_input.variables_cf.needed                        = this.config._field_settings[a].needed;
							obj_input.variables_cf.possible_values               = this.config._field_settings[a].possible_values;
							obj_input.variables_cf.parent_field                  = this.config._field_settings[a].parent_field;
							obj_input.variables_cf.parent_activation_values      = this.config._field_settings[a].parent_activation_values;
							obj_input.variables_cf.count_name                    = f;
							obj_input.variables_cf.default_value                 = this.config._field_settings[a].default_value;
							
							var regstring = "(\\[\\]){1}$";
							var reg = new RegExp( regstring );
							
							if (!reg.test(obj_input.name))
							{
								obj_input.variables_cf.is_array = false;
							}
							
							if (reg.test(obj_input.name))
							{
								obj_input.variables_cf.is_array = true;
							}
							
							if (field_type=="input_text"&&obj_input.type=="text")
							{
								obj_input.setAttribute( "type", "text" );
							}
							
							switch (field_type)
							{
								case "input_checkbox":
								case "input_radio":
								case "select":
									obj_input.variables_cf.value_type = "STRING";
									this.config._field_settings[a].value_type = "STRING";
									break;
							}
							
							if (this.config._field_settings[a].needed&&this.config.css_needed!=undefined)
							{
								if (obj_input.className)
								{
									obj_input.className += " "+this.config.css_needed; 
								}
								else
								{
									obj_input.className = this.config.css_needed; 
								}
							}
							
							if (this.config._field_settings[a].default_value!="")
							{
								switch (getFieldType(this.config._field_settings[a].form_id, this.config._field_settings[a].name))
								{
									case "input_radio":
										if (typeof(this.config._field_settings[a].default_value)=="string"||typeof(this.config._field_settings[a].default_value)=="number")
										{
											if (this.config._field_settings[a].default_value==obj_input.defaultValue)
											{
												obj_input.checked = true;
											}
										}
										else
										{
											for ( var k=0; k < this.config._field_settings[a].default_value.length; k++ )
											{
												if (this.config._field_settings[a].default_value[k]==obj_input.defaultValue)
												{
													obj_input.checked = true;
												}
											}
										}
										break;
									
									case "select":
										if (obj_input.variables_cf.is_array)
										{
											for ( var v=0; v < obj_input.options.length; v++ )
											{
												if (typeof(this.config._field_settings[a].default_value)=="string"||typeof(this.config._field_settings[a].default_value)=="number")
												{
													if (obj_input.options[v].value==this.config._field_settings[a].default_value)
													{
														obj_input.options[v].selected = true;
													}
													else
													{
														obj_input.options[v].selected = false;
													}
												}
												else
												{
													if (obj_input.options[v].value==this.config._field_settings[a].default_value[f])
													{
														obj_input.options[v].selected = true;
													}
													else
													{
														obj_input.options[v].selected = false;
													}
												}
											}
										}
										else
										{
											for ( var v=0; v < obj_input.options.length; v++ )
											{
												if (typeof(this.config._field_settings[a].default_value)=="string"||typeof(this.config._field_settings[a].default_value)=="number")
												{
													if (obj_input.options[v].value==this.config._field_settings[a].default_value)
													{
														obj_input.options[v].selected = true;
													}
													else
													{
														obj_input.options[v].selected = false;
													}
												}
												else
												{
													obj_input.options[v].selected = false;
													for ( var k=0; k < this.config._field_settings[a].default_value.length; k++)
													{
														if (obj_input.options[v].value==this.config._field_settings[a].default_value[k])
														{
															obj_input.options[v].selected = true;
														}
													}
												}
											}
										}
										break;
									
									case "input_checkbox":
										if (obj_input.variables_cf.is_array)
										{
											if (typeof(this.config._field_settings[a].default_value)=="string"||typeof(this.config._field_settings[a].default_value)=="number")
											{
												if ( this.config._field_settings[a].default_value != null )
												{
													obj_input.checked = true;
												}
											}
											else
											{
												if ( this.config._field_settings[a].default_value[f] != null )
												{
													obj_input.checked = true;
												}
											}
										}
										else
										{
											if ( this.config._field_settings[a].default_value != null )
											{
												obj_input.checked = true;
											}
										}
									
										break;
									
									default:
										if (obj_input.variables_cf.is_array)
										{
											if (typeof(this.config._field_settings[a].default_value)=="string"||typeof(this.config._field_settings[a].default_value)=="number")
											{
												obj_input.value = this.config._field_settings[a].default_value;
											}
											else
											{
												obj_input.value = this.config._field_settings[a].default_value[f];
											}
										}
										else
										{
											obj_input.value = this.config._field_settings[a].default_value;
										}
										break;
								}
							}
							
							if (this.config.childfield_disable==true)
							{
								if (obj_input.value=="")
								{
									setInputAbility( obj_input, false, true );
								}
								else
								{
									setInputAbility( obj_input, true, true );
								}
							}
							
							if (reg.test(obj_input.name)&&field_type=="input_radio")
							{
								alert( "iX.formChecks | method - onload: An input field with the type 'radio' could not be an array: "+obj_input.name );
								return false;
							}
							
							// protect max length
							if ( this.config._field_settings[a].max_length>0 )
							{
								obj_input.maxLength = this.config._field_settings[a].max_length;
							}
							
							// for all field types
							if (this.config.preventForWrongSigns)
							{
								// after changing the data of the input field
								obj_input.onkeyup = new Function( this.config.check_form_object+".check.onkeyup( this )" );
							}
							
							switch (field_type)
							{
								case "select":
									// for Selection fields
									obj_input.onchange = new Function( this.config.check_form_object+".check.onChangeSelect( this, "+this.config.check_form_object+" )" );
									break;
							
								case "input_radio":
								  break;
								  
								case "input_checkbox":
									// for radio and checkboxes
									obj_input.onclick = new Function( this.config.check_form_object+".check.onclick( this, "+this.config.check_form_object+" )" );
									break;
									
								default:
									// while loosing focus on field
									obj_input.onblur = new Function( this.config.check_form_object+".check.onblur( this, "+this.config.check_form_object+" )" );
									break;
							}
						}
					}
				}
			}
		}
		
		// deactivated formular submit button
		if (this.config.disableSubmitButton)
		{
			var objButton = document.getElementById(this.config.idSubmitButton);
			
			if (this.onsubmit( form_id, true ))
			{
				objButton.disabled = false;
				setSubmitButtonEnabled( self[this.config.check_form_object] );
			}
			else
			{
				objButton.disabled = true;
				setSubmitButtonDisabled( self[this.config.check_form_object] )
			}
		}
	}
	}
	
	// basic public methods: formular onsumbit event
	this.onsubmit = function onsubmit( actual_form_id, alert_off )
	{
		if (!this.event.onload)
		{
			alert("iX.formChecks | method - onsubmit: Please start onLoad-method!");
			return false;
		}
		
		var error_string       = new String();
		var tabindex_saver     = new Array();
		var error_string_array = new Array();
    	var check_value        = new String();
    	var field_type         = new String();
    	var obj_form           = new Object();
    	var obj_input          = new Object();
    	var objects            = new Object();
		var count_name         = 0;
		var pos                = 0;
		var length             = 0;
    	var no_error           = true;
		var message            = new Array();
		
		this.config.alertIsShown = true;

		for ( var a = 0; a < this.config._field_settings.length; a++ )
		{
			var defined            = true;
			var real_length        = 0;
			
			switch (getFieldType(this.config._field_settings[a].form_id, this.config._field_settings[a].name))
			{
		        case "select":
		          obj_form = document.getElementById( this.config._field_settings[a].form_id );
		          obj_input = obj_form[this.config._field_settings[a].name];
				 
				  if (obj_input.name&&!obj_input.variables_cf.is_array)
				  {
					obj_input = obj_input;
					length = 1;
				  }
				  else
				  {
					real_length = obj_input.length;
					length = obj_input.length;
					obj_input = obj_input[0];
				  }
		          field_type = "select";
		          break;
				  
		        case "input_radio":
		          obj_form = document.getElementById( this.config._field_settings[a].form_id );
		          obj_input = obj_form[this.config._field_settings[a].name];
				  
		          if (obj_input[0])
		          {	
		            if (!obj_input[0].variables_cf.is_array)
					{
						length = 1;
						real_length = obj_input.length;
						obj_input = obj_input[0];
					}
		          }
		          else
		          {
		            length = 1;
		          }
				  
				  field_type = "input_radio";
		          break; 
		        
		        case "input_checkbox":
		          obj_form = document.getElementById( this.config._field_settings[a].form_id );
		          obj_input = obj_form[this.config._field_settings[a].name];
				  
		          if (obj_input[0])
		          {	
		            if (obj_input[0].variables_cf.is_array)
					{
						length = obj_input.length;
						obj_input = obj_input[0];
					}
					else
					{
						length = 1;
						obj_input = obj_input[0];
					}
		          }
		          else
		          {
		            length = 1;
		          }
				  
				  field_type = "input_checkbox";
		          break; 
		        
		        case "input_text":
		          obj_form = document.getElementById( this.config._field_settings[a].form_id );
		          obj_input = obj_form[this.config._field_settings[a].name];

		          if (obj_input[0])
		          {
		            length = obj_input.length;
		            obj_input = obj_input[0];
		          }
		          else
		          {
		            length = 1;
		          }
		          field_type = "input_text";
		          break; 
		          
			default:
				defined = false;
				break;
		        
      	}

		if (obj_input&&defined!=false)
        {
	    if (obj_input.name)
	    {
		
      	for ( var q=0; q < length; q++ )
	    {
			count_name = q;
			no_error = true;
			pos = a;
			
			if (obj_input.name)
			{
				var obj_check = obj_input;
			}
			else
			{
				var obj_check = obj_input[q];
			}	
			
			if (this.config.mode_order=="TABINDEX")
			{
				pos = getTabIndex( this.config._field_settings[a].form_id, this.config._field_settings[a].name );
				if (tabindex_saver[pos]!=this.config._field_settings[a].name&&tabindex_saver[pos]!=undefined)
				{
					alert( "iX.formChecks | method - onsubmit: Please do not define tabindex '"+pos+"' for input field '"+this.config._field_settings[a].name+"'. \nTabindex is still defined to input field '"+tabindex_saver[pos]+"'" );
					return false;
				}
				tabindex_saver[pos] = this.config._field_settings[a].name;
			}
  			
  			if (actual_form_id==this.config._field_settings[a].form_id)
  			{
  				check_value = getValue( this.config._field_settings[a].form_id, this.config._field_settings[a].name, count_name );
				
				if (isParentSet( this.config._field_settings[a].form_id, this.config._field_settings[a].name, count_name ))
				{
					if (no_error&&check_value!="")
					{
						no_error = isDataFormatOk( obj_check, this.config._field_settings[a].form_id, check_value, this.config._field_settings[a].value_type, this.config._field_settings[a].possible_values )
						
						if (!no_error)
						{
							error_string += this.config._field_settings[a].error_message_syntax+"\n";
							message = this.config._field_settings[a].error_message_syntax;
						}
					}

					if ( this.config._field_settings[a].needed==true && ( check_value=="" ) && no_error)
					{
						no_error = false;
						error_string += this.config._field_settings[a].error_message_missing+"\n";
						var message = this.config._field_settings[a].error_message_missing;
					}
					
					if ( check_value!="" && no_error )
	  				{
	  					if ( !isValueAccepted( this.config._field_settings[a].form_id, this.config._field_settings[a].name, this.config._field_settings[a].possible_values, count_name )&& no_error )
	  					{
	  						no_error = false;
	  						error_string += this.config._field_settings[a].error_message_possible_values+"\n";
							var message = this.config._field_settings[a].error_message_possible_values;
	  					}
	  					
	  					if (!isStringLengthOk( check_value, this.config._field_settings[a].min_length, this.config._field_settings[a].max_length )&&no_error)
	  					{
	  						no_error = false;
	  						error_string += this.config._field_settings[a].error_message_syntax+"\n";
							var message = this.config._field_settings[a].error_message_syntax;
	  					}
					}
				}
  			}

			if (!no_error)
			{
				if (!error_string_array[pos]) 
				{	
					error_string_array[pos] = new Array();	
				}
				
				if (!error_string_array[pos][q])
				{
					error_string_array[pos][q] = new Array();	
				}
				
				if (typeof(message)!="string")
				{
					if (message[this.config.actual_language]!=undefined)
					{
						error_string_array[pos][q]["message"] = message[this.config.actual_language];
					}
					else
					{
						error_string_array[pos][q]["message"] = message[0];
					}
				}
				else
				{
					error_string_array[pos][q]["message"] = message;
				}

				error_string_array[pos][q]["count"] = q+1;
				message = new Array();
			}
			
			if (!alert_off)
			{
	  			if (!no_error)
	  			{
	  				if (this.config.onSubmitMode=="HIGHLIGHT_AND_ALERT"||this.config.onSubmitMode=="HIGHLIGHT")
	  				{
	  					if (real_length&&field_type=="input_radio")
						{
							for ( var m = 0; m < real_length; m++ )
							{
								setColorOn( this.config._field_settings[a].form_id, this.config._field_settings[a].name, this.config.css_syntax_error, m );
							}
						}
						else
						{
							setColorOn( this.config._field_settings[a].form_id, this.config._field_settings[a].name, this.config.css_syntax_error, count_name );
						}
	  				}
	  			}
	  			else
	  			{
	  				if (this.config.onSubmitMode=="HIGHLIGHT_AND_ALERT"||this.config.onSubmitMode=="HIGHLIGHT")
	  				{
	  					if (real_length&&field_type=="input_radio")
						{
							for ( var m = 0; m < real_length; m++ )
							{
								setColorOff( this.config._field_settings[a].form_id, this.config._field_settings[a].name, m, this.config.css_syntax_error );
							}
						}
						else
						{
							setColorOff( this.config._field_settings[a].form_id, this.config._field_settings[a].name, count_name, this.config.css_syntax_error	);
						}
						
	  				}
	  			}
			}
			}
		}
      }
		}	

		if (error_string!="")
		{
			if (!alert_off)
			{
				var array_error_string = new Array();
				var x                  = 0;
							
				for ( var q=0; q < error_string_array.length; q++ )
				{
					for ( var c in error_string_array[q] )
					{
						if (this.config.field_number==true)
						{
							array_error_string[x] = error_string_array[q][c]["message"]+"("+error_string_array[q][c]["count"]+")\n";
						}
						else
						{
							array_error_string[x] = error_string_array[q][c]["message"]+"\n";
						}
						x++;
					}
				}
				
				
				switch (this.config.mode_alert)
				{
					case "SYSTEM":
						showAlertSystem( array_error_string, this.config.head_alert, this.config.message_alert )
						break;
						
					case "WINDOW":
						showAlertFlyingWindow( array_error_string, this.config.css_alert,  this.config.head_alert, this.config.message_alert, actual_form_id);
						break;
					
					case "ELEMENT":
						showAlertAsInnerHTMLOfAnElement( array_error_string, this.config.css_alert, this.config.head_alert, this.config.message_alert )
						break;
				}
			}
			
			return false;
		}
		else
		{
			if (this.config.loader)
			{
				pleaseWait( this.config.idSubmitButton, "standard_table" );
			}
			return true;
		}
	}
	
  	/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* INPUT EVENTS -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-* */
	// check leaving an input field
	this.check.onblur = function check_onblur( obj_check, obj_class )
	{
		var error_string                  = new String();
		var error_string_array            = new Array();
		var array_error_string            = new Array();
		var eventHasRocked        = new Boolean();
		var no_error                      = true;
		var form_id                       = obj_check.variables_cf.form_id;
		var value_type                    = obj_check.variables_cf.value_type;
		var error_message_missing         = obj_check.variables_cf.error_message_missing;
		var error_message_syntax          = obj_check.variables_cf.error_message_syntax;
		var error_message_possible_values = obj_check.variables_cf.error_message_possible_values;
		var needed                        = obj_check.variables_cf.needed;
		var min_length                    = obj_check.variables_cf.min_length;
		var max_length                    = obj_check.variables_cf.max_length;
		var possible_values               = obj_check.variables_cf.possible_values;
		var count_name                    = obj_check.variables_cf.count_name;
		var onChangeMode                 = obj_class.config.onChangeMode;
		var css_syntax_error              = obj_class.config.css_syntax_error;
		var css_disabled                  = obj_class.config.css_disabled;
		var css_alert                     = obj_class.config.css_alert;
		var mode_alert                    = obj_class.config.mode_alert;
		var head_alert                    = obj_class.config.head_alert;
		var message_alert                 = obj_class.config.message_alert;
		var field_type                    = getFieldType( form_id, obj_check.name );
		var value                         = getValue( form_id, obj_check.name, count_name );
		
		if (value!="")
		{
			if (no_error)
			{
				no_error = isDataFormatOk( obj_check, form_id, value, value_type, possible_values );

				if (!no_error)
				{
					error_string = error_message_syntax;
					error_string_array = error_message_syntax;
				}
				
				if ( !isValueAccepted( form_id, obj_check.name, possible_values, count_name )&&no_error )
				{
					no_error = false;
					error_string = error_message_possible_values;
					error_string_array = error_message_possible_values;
				}
				
				if (!isStringLengthOk( value, min_length, max_length )&&no_error)
				{
					no_error = false;
					error_string = error_message_syntax+"\n";
					error_string_array = error_message_syntax;
				}
			}
		}

		if (error_string!="")
		{
			if (error_string_array[obj_class.config.actual_language])
			{
				array_error_string[0] = error_string_array[obj_class.config.actual_language];
			}
			else
			{
				array_error_string[0] = error_string_array;
			}

			switch (onChangeMode)
			{
				case "ALERT":
					if (obj_class.event.alertIsShown==false)
					{
						switch (mode_alert)
						{
							case "SYSTEM":
								alert(error_string);
								break;
							
							case "WINDOW":
								showAlertFlyingWindow( array_error_string, css_alert, head_alert, message_alert, form_id );
								break;
								
							case "ELEMENT":
								showAlertAsInnerHTMLOfAnElement( array_error_string, css_alert, head_alert, message_alert );
								break;
						}
					}
					obj_class.event.alertIsShown = false;
					break;
					
				case "HIGHLIGHT_AND_ALERT":
					setColorOn( form_id, obj_check.name, css_syntax_error, count_name );
					setInputAbility( obj_check, false );
					
					if (obj_class.event.alertIsShown==false)
					{
						switch (mode_alert)
						{
							case "SYSTEM":
								showAlertSystem( array_error_string, head_alert, message_alert )
								break;
							
							case "WINDOW":
								showAlertFlyingWindow( array_error_string, css_alert, head_alert, message_alert, form_id );
								break;
								
							case "ELEMENT":
								showAlertAsInnerHTMLOfAnElement( array_error_string, css_alert, head_alert, message_alert );
								break;
						}
					}
					obj_class.event.alertIsShown = false;
					break;
					
				case "HIGHLIGHT":
					setColorOn( form_id, obj_check.name, css_syntax_error, count_name );
					setInputAbility( obj_check, false );
					break;
					
			}
			eventHasRocked = false;
		}
		else
		{
			if ( obj_check.className && needed==false || obj_check.className && needed && value != "" )
			{
				switch (onChangeMode)
				{
					case "HIGHLIGHT_AND_ALERT":
					case "HIGHLIGHT":
						setColorOff( form_id, obj_check.name, count_name, css_syntax_error );
						break;
				}
				
				setInputAbility( obj_check, false );
			}
			else
			{
				setInputAbility( obj_check, true );
			}
			eventHasRocked = true;
		}
		
		// deactivated formular submit button
		if (obj_class.config.disableSubmitButton)
		{
			var objButton = document.getElementById( obj_class.config.idSubmitButton );
			
			if (obj_class.onsubmit( form_id, true ))
			{
				objButton.disabled = false;
				setSubmitButtonEnabled( obj_class );
			}
			else
			{
				objButton.disabled = true;
				setSubmitButtonDisabled( obj_class );
			}
		}
		return eventHasRocked;
	}
	
	// check: while changing an input field of the type select
	this.check.onChangeSelect = function onChangeSelect( check_obj, obj_class )
	{
		var form_id    = check_obj.variables_cf.form_id;
		var name       = check_obj.variables_cf.name;
		var count_name = check_obj.variables_cf.count_name;
		var needed     = check_obj.variables_cf.needed;
		var css_syntax_error = obj_class.config.css_syntax_error;
		var css_disabled = obj_class.config.css_disabled;
		
		if (check_obj.value!="")
		{
			setColorOff( form_id, name, count_name, css_syntax_error, check_obj );
			setInputAbility( check_obj, true );
		}
		else
		{
			if (needed)
			{
				if (obj_class.config.onChangeMode=="HIGHLIGHT_AND_ALERT"||obj_class.config.onChangeMode=="HIGHLIGHT")
				{
					setColorOn( form_id, name, css_syntax_error, count_name, check_obj );
				}
				setInputAbility( check_obj, false );
			}
		}
	}
	
	// check: while changing an input field of the type check and radio
	this.check.onclick = function check_onclick( check_obj, obj_class )
	{
		var form_id          = check_obj.variables_cf.form_id;
		var count_name       = check_obj.variables_cf.count_name;
		var name             = check_obj.variables_cf.name;
		var css_syntax_error = obj_class.config.css_syntax_error;
		var css_disabled     = obj_class.config.css_disabled;
		var field_type       = getFieldType( form_id, name );
		var value = getValue( form_id, name, count_name );

		if (value!="")
		{
			if (field_type=="input_radio")
			{
				var obj_form = document.getElementById( form_id );
				var obj_input = obj_form[name];
				
				if (obj_input[0])
				{
					for ( var n = 0; n < obj_input.length; n++ )
					{
						setColorOff( form_id, name, n, css_syntax_error );
						setInputAbility( check_obj, true );
					}
				}
				else
				{
					setColorOff( form_id, name, count_name, css_syntax_error, check_obj );
					setInputAbility( check_obj, true );
				}
			}
			else
			{
				setColorOff( form_id, name, count_name, css_syntax_error, check_obj );
				setInputAbility( check_obj, true );
			}
		}
		else
		{
			if ( check_obj.variables_cf.needed )
			{
				if (obj_class.config.onChangeMode=="HIGHLIGHT_AND_ALERT"||obj_class.config.onChangeMode=="HIGHLIGHT")
				{
					setColorOn( form_id, name, css_syntax_error, count_name, check_obj );
				}
			}
			setInputAbility( check_obj, false );
		}
	}
	
	// check: analyse each entered key in a textarea and an input field of the type text
	this.check.onkeyup = function check_onkeyup( this_object )
	{
		var form_id           = this_object.variables_cf.form_id;
		var value_type        = this_object.variables_cf.value_type;
		var count_name        = this_object.variables_cf.count_name;
		var field_type        = getFieldType( form_id, this_object.name );

		switch (field_type)
		{
			case "input_text":
				var form_obj = document.getElementById( form_id );
				var input_obj = form_obj[this_object.name];

				if (!isASignWrong( form_id, this_object.name, value_type, count_name  ))
				{
					var correct_value = new String();

					if (input_obj[0])
					{
						input_obj = input_obj[count_name];
					}

					if (typeof input_obj.selectionStart != 'undefined')
					// gecko
					{
						var cursor_position = input_obj.selectionStart-1;

						if ( cursor_position >= 0 )
						{
							for ( var t = 0; t < input_obj.value.length; t++ )
							{
								if ( t != cursor_position )
								{
									correct_value += input_obj.value[t];
								}
							}
							
							input_obj.value = correct_value;
							input_obj.setSelectionRange(cursor_position, cursor_position);
						}
					}
					else
					// internet explorer
					{
						var value = new String();
						var length_string = 0;

						length_string = input_obj.value.length;

						input_obj.createTextRange;
						input_obj.caretPos = document.selection.createRange().duplicate();
						var caretPos = input_obj.caretPos;
						caretPos.moveStart( 'character', -input_obj.value.length );
						caretPos.select();

						cursor_position=caretPos.text.length - 1;

						if (cursor_position>=0)
						{
							for ( var t = 0; t < input_obj.value.length; t++ )
							{
								if ( t != cursor_position )
								{
									correct_value += input_obj.value.substring(t,t+1);
								}
							}
							
							input_obj.value = correct_value;
						}

						caretPos.moveStart( 'character', +cursor_position + 1 );
						caretPos.moveEnd( 'character', -length_string+cursor_position + 1 );
						caretPos.select();
					}
				}
				break;
		}
	}
  
	/* = = = = = = = = = = = = = = = = = = = = = PRIVATE METHODS = = = = = = = = = = = = = = = = = = = = = */
	function setFormDisabled( formId )
	{
		var objForm =new Object();
		var pos = new Object();
		
		objForm = document.getElementById( formId );
		
		for ( var n=0; n < objForm.length; n++ )
		{
			if (objForm.tagName!="button")
			{
				objForm.readOnly = true;
				pos = getPosition( objForm[n] );
				objDiv = document.createElement("div");
				objDiv.id = formId+"_checkFormDisableHandle";

				with (objDiv.style)
				{
					position = "absolute";
					left = pos.x+"px";
					top = pos.y+"px";
					width = objForm[n].clientWidth;
					minWidth = objForm[n].clientWidth;
					height = objForm[n].clientHeight;
					minHeight = objForm[n].clientHeight;
					display = "block";
				}
				document.body.appendChild( objDiv );
			}
		}
	}
	
	function setFormEnabled( formId )
	{
		// Gecko
		try
		{
			var elements = new Object();
			
			elements = document.body.childNodes;
			
			for ( var l in elements )
			{
				if (elements[l])
				{
					if ( formId+"_checkFormDisableHandle" == elements[l].id )
					{
						elements[l].readOnly = false;
						
						with (elements[l].style)
						{
							width = "0px";
							minWidth = "0px";
							height = "0px";
							minHeight = "0px";
							display="none";
						}
						
						document.body.childNodes[l]=null;
						
						delete elements[l];
						elements[l] = null;
					}
				}
			}
		}
		// IE, Opera
		catch(e)
		{
			var elements = new Object();
			
			elements = document.getElementsByTagName("div");

			for ( var l =0; l < elements.length; l++ )
			{
				try
				{
					if (elements[l])
					{
						if ( formId+"_checkFormDisableHandle" == elements[l].id )
						{
							elements[l].readOnly = false;
							
							with (elements[l].style)
							{
								width = "0px";
								minWidth = "0px";
								height = "0px";
								minHeight = "0px";
								display="none";
							}
							document.all.removeChild(elements[l]);
							delete elements[l];
							elements[l] = null;
						}
					}
				}
				catch(e){}
			}
		}
	}
	
	function setSubmitButtonDisabled( objClass )
	{
		if (objClass.config.cssSubmitButton!="")
		{
			var objButton = document.getElementById( objClass.config.idSubmitButton );
			
			var regexstring_1        = "[\\s]{0,1}"+objClass.config.cssSubmitButton+"{1}";
			var myregexp_1           = new RegExp(regexstring_1);
			
			if ( objButton.className )
			{
				if (!myregexp_1.test(objButton.className))
				{
					objButton.className += " "+objClass.config.cssSubmitButton;
				}
			}
			else
			{
				objButton.className = objClass.config.cssSubmitButton;
			}
		}
	}
	
	function setSubmitButtonEnabled( objClass )
	{
		if (objClass.config.cssSubmitButton!="")
		{
			var objButton = document.getElementById( objClass.config.idSubmitButton );
			var regexstring_1        = "[\\s]{0,1}"+objClass.config.cssSubmitButton+"{1}";
			var myregexp_1           = new RegExp(regexstring_1);
			
			objButton.className = objButton.className.replace( myregexp_1, "" );
		}
	}
	
	// unset a hightlight css for an input field
	function setColorOff( form_id, name, count_name, css_class, obj_inputs )
	{
		var regexstring_1 = new String();
		var regexstring_2 = new String();
		var myregexp_1    = new Object();
		var myregexp_2    = new Object();
		var obj_form      = new Object();
		
		if (obj_inputs==undefined)
		{
			obj_form = document.getElementById( form_id );
			obj_inputs = obj_form[name];
		}

		if ( (obj_inputs.options && getFieldType(form_id,name) == "select")  || (getFieldType(form_id,name)!="select" && obj_inputs.name != undefined)  )
		// Input als Array
		{
			var field_type        = getFieldType( form_id, name )
			
			if (obj_inputs.className&&css_class!="")
			{
				regexstring_1        = "[\\s]{0,1}"+css_class+"{1}";
				myregexp_1           = new RegExp(regexstring_1);
				obj_inputs.className = obj_inputs.className.replace( myregexp_1, "" );
			}
		}
		else
		// Single Input or Selection
		{
			if (count_name==undefined)
			{
			  var count_name=0;
			}
	
			var field_type        = getFieldType( form_id, name );
			
			if (obj_inputs[count_name].className&&css_class!="")
			{
				regexstring_1                    = "[\\s]{0,1}"+css_class+"{1}";
				myregexp_1                       = new RegExp(regexstring_1);
				obj_inputs[count_name].className = obj_inputs[count_name].className.replace( myregexp_1, "" );
			}
		}
	}
		
	// set a hightlight css for an input field
	function setColorOn( form_id, name, css_class, count_name, obj_inputs )
	{
		if (!obj_inputs)
		{
			var obj_form  = new Object();
			obj_form = document.getElementById( form_id );
			obj_inputs = obj_form[name];
		}
		
		if (count_name==undefined)
		{
		  var count_name="0";
		}
		
		if (css_class!="")
		{
			var field_type    = getFieldType( form_id, name );
			var regexstring_1 = css_class;
			var myregexp_1    = new RegExp(regexstring_1, '');

			if (obj_inputs.options||(field_type!="select"&&obj_inputs.name))
			// non array inputs
			{
				if ( obj_inputs.className )
				{
					if (!myregexp_1.test(obj_inputs.className))
					{
						obj_inputs.className += " "+css_class;
					}
				}
				else
				{
					obj_inputs.className = css_class;
				}
			}
			else
			// array inputs
			{
				if ( obj_inputs[count_name].className )
				{
					if (!myregexp_1.test(obj_inputs[count_name].className))
					{
						obj_inputs[count_name].className += " "+css_class;
					}
				}
				else
				{
					obj_inputs[count_name].className = css_class;
				}
			}
		}
	}
	
	// switch of an input field, cause it is not activated by its parent field
	function setInputAbility( obj_check, switching, start )
	{
		var obj_class = self[obj_check.variables_cf.check_form_object];  // Klassenobjekt laden
		var length = obj_class.config._field_settings.length;
		var _field_settings = obj_class.config._field_settings;
		var config_disabled = obj_class.config.childfield_disable;
		var css_disabled = obj_class.config.css_disabled;
		var count = obj_check.variables_cf.count_name;
		var is_array = obj_check.variables_cf.is_array;

		if (config_disabled==true)
		{
			for ( var r=0; r < length; r++ )
			{
				if ( obj_check.name == _field_settings[r].parent_field )
				{
					var obj_inputs = new Array();
					var check_values = new Array();
					var obj_form = document.getElementById( _field_settings[r].form_id );
					var obj_input = obj_form[_field_settings[r].name];
					
					// get an array for an easier handling
					if (obj_input.options||obj_input.name)
					{
						obj_inputs[0] = obj_input;
						
					}
					else
					{
						obj_inputs = obj_input;
					}
					
					for ( var z=0; z < obj_inputs.length; z++ )
					{
						if (!is_array)
						{
							count = parseFloat(z);
						}
						
						if (obj_inputs[count])
						{
							var obj_input = obj_inputs[count];

							if (obj_inputs[count].variables_cf!=undefined)
							{
							if (switching)
							{
								if ( isParentSet( obj_input.variables_cf.form_id, obj_input.name, obj_input.variables_cf.count_name ) )
								{
									obj_input.disabled = false;
									if (!start)
									{
										setColorOff( _field_settings[r].form_id, _field_settings[r].name, count, css_disabled );
									}
								}
								else
								{
									obj_input.disabled = true;
									setColorOn( _field_settings[r].form_id, _field_settings[r].name, css_disabled, count, obj_input );
								}
							}
							else
							{
								if ( !isParentSet( obj_input.variables_cf.form_id, obj_input.name, obj_input.variables_cf.count_name ) )
								{	
									obj_input.disabled = true;
									setColorOn( _field_settings[r].form_id, _field_settings[r].name, css_disabled, count, obj_input );
								}
								else
								{
									obj_input.disabled = false;
									if (!start)
									{
										setColorOff( _field_settings[r].form_id, _field_settings[r].name, count, css_disabled );
									}
								}
							}
							}
						}
					}
				}
			}
		}
	}
	
	// Show: System Alert
	function showAlertSystem( error_string_array, head_alert, message_alert )
	{
		var error_message = new String();
		
		if ( head_alert )
		{
			error_message += head_alert+"\n\n";
		}	
		
		if ( message_alert )
		{
			error_message += message_alert+"\n\n";
		}
		
		for ( var f=0; f < error_string_array.length; f++)
		{
			if (error_string_array[f])
			{
				error_message += error_string_array[f];
			}
		}
		
		alert(error_message);
	}
	
	// Show: Alert in an specific element
	function showAlertAsInnerHTMLOfAnElement( error_string_array, error_message_id, head_alert, message_alert )
	{
		var obj_error_message = document.getElementById(error_message_id);
		var obj_window = new Object();
		var obj_h1     = new Object();
		var obj_h2     = new Object();
		var obj        = new Object();
		
		if (!obj_error_message)
		{
			alert( "iX.formChecks | method - showAlertAsInnerHTMLOfAnElement: Field for error message is not declared: "+error_message_id );
			return false;
		}
		else
		{
			obj_error_message.innerHTML = "";
			
			if ( head_alert )
			{
				obj = document.createElement( "h1" );
				obj.innerHTML = head_alert;
				obj_error_message.appendChild(obj);
			}	
			
			if ( message_alert )
			{
				obj_h2 = document.createElement('h2');
				obj_h2.innerHTML = message_alert;
				obj_error_message.appendChild(obj_h2);
			}
			
			for ( var f=0; f < error_string_array.length; f++)
			{
				if (error_string_array[f])
				{
					var obj = document.createElement( "p" );
					obj.innerHTML = error_string_array[f];
					obj_error_message.appendChild(obj);
				}
			}
		}
	}
	
	// Show: Alert in self designed window
	function showAlertFlyingWindow( error_messages, css_alert, head_alert, message_alert, form_id )
	{
		var obj_window = new Object();
		var obj_h1 = new Object();
		var obj_h2 = new Object();
		var obj_p = new Object();
		var obj_button = new Object();
		var obj_table = new Object();
		
		if (!document.getElementById(css_alert))
		{
	    	obj_window = document.createElement('div');
			obj_window.id        = css_alert;
		}
		else
		{
			obj_window = document.getElementById(css_alert);
			obj_window.innerHTML = "";
		}
		
		if (!obj_window)
		{
			alert( "iX.formChecks | method - showAlertFlyingWindow: The stylesheet '"+css_alert+"' for the alert window is not set." );
			return false;
		}
		else
		{
			document.getElementById(form_id).disabled = true;
			setFormDisabled(form_id);
			
		 	if ( head_alert )
			{
				obj_h1 = document.createElement('h1');
				obj_h1.innerHTML = head_alert;
				obj_window.appendChild(obj_h1);
			}
			
			if ( message_alert )
			{
				obj_h2 = document.createElement('h2');
				obj_h2.innerHTML = message_alert;
				obj_window.appendChild(obj_h2);
			}
			
			obj_table = document.createElement('table');
			
			for ( var s = 0; s < error_messages.length; s++ )
			{
				if (error_messages[s])
				{
					var r = s + 1;
					
					obj_p = document.createElement('p');
					obj_p.innerHTML = error_messages[s];
					obj_window.appendChild(obj_p);
				}
			}
			
			obj_button = document.createElement('button');
			obj_button.variables_cf = new Object();
			obj_button.innerHTML = "ok";
			obj_button.style.display = "block";
			obj_button.variables_cf.div_id = css_alert;
			obj_button.variables_cf.form_id = form_id;
			
			obj_button.onclick = function onclick()
			{
				var div_id = this.variables_cf.div_id;
				var form_id = this.variables_cf.form_id;
				var obj_form = document.getElementById( div_id );
				document.body.removeChild(obj_form);
				document.getElementById(form_id).disabled = false;
				setFormEnabled(form_id);
			}
			
			obj_window.appendChild(obj_button);
			document.body.appendChild(obj_window);
			
			obj_window = document.getElementById(css_alert);
			
			var width = 1;
			var left = document.body.scrollLeft+document.body.scrollWidth/2-obj_window.clientWidth/2;
			var top = document.body.scrollTop+document.body.scrollHeight/2-obj_window.clientHeight/2;
			var rel_left = left / document.body.scrollWidth * 100;
			var rel_top = top / document.body.scrollHeight * 100;
			
			var obj_span = document.createElement('span');
			
			if ( obj_window.clientWidth-20 >= 1)
			{
				width = obj_window.clientWidth-20;
			}
		
			obj_span.style.width = width;
			obj_span.style.minWidth = width;
			obj_span.style.display = "block";
			obj_span.style.marginTop = "20px";
			obj_span.style.paddingRight = "20px";
			obj_span.style.textAlign = "right";
			obj_span.style.fontSize = "0.8em";
			obj_span.style.backgroundColor = "#afafaf";
			// obj_span.innerHTML = "Form check by Engineer.iX";
			
			obj_window.appendChild(obj_span);
			
			obj_window.style.position = "absolute";
			obj_window.style.left = rel_left+"%";
			obj_window.style.top = rel_top+"%";
		}
	}
	
	// Position of an element on the site
  	function getPosition( obj ) 
  	{
  		var pos = { x:0, y:0 };
  
  		do 
  		{
  			pos.x += obj.offsetLeft;
  			pos.y += obj.offsetTop;
  		} 
  		while 
  		(
  			obj = obj.offsetParent
  		);

  		return pos;
  	}
	
	// get possible telephon data formats
	function getRegTelephon( possible_values )
	{	
		var possible_values_array = new Array();
		var pos_values            = new Array();
		var pv_telephon           = new Array( "1", "2", "3" );
		var found                 = false;
		var lowest                = 3;
		
		possible_values_array = possible_values;
	
		if (possible_values_array[0]=="!")
		{
			for ( var f=0; f < pv_telephon.length; f++ )
			{
				found = false;
				
				for ( var s=0; s < possible_values_array.length; s++ )
				{
					if (pv_telephon[f]==possible_values_array[s])
					{
						found = true;
						s = possible_values_array.length;
					}
				}
				
				if (!found)
				{
					var n = pos_values.length;
					pos_values[n] = pv_telephon[f];
				}
			}	
			possible_values_array = pos_values;
		}
		
		for (var g=0; g < possible_values_array.length; g++ )
		{
			var check = parseFloat(possible_values_array[g]);
			if ( check < lowest )
			{
				lowest = check;
			}
		}
		
		return lowest;
	}
	
	// get possible formats of an url address
	function getRegUrlProtocol( form_id, name, possible_values )
	{
	    var protocol_string       = new String();
		var possible_values_array = new Array();
		var protocol_types        = new Array( "POP3", "IP", "IMAP", "PPTP", "PPP", "TCP", "UDP", "SMTP", "MYSQL", "HTTP", "HTTPS", "FTP", "MAILTO", "LOCALHOST" );
		var found                 = false;

		possible_values_array = possible_values;
		
		if (possible_values!="")
		{
			if ( possible_values_array[0]!="!" )
			{
				for ( var u=0; u < possible_values_array.length; u++ )
				{
					if (u!=0)
					{
						protocol_string += "|";
					}
					
					protocol_string += "("+possible_values_array[u].toLowerCase()+")";
				}
			}
			else
			{
				for ( var u=0; u < protocol_types.length; u++ )
				{
					found = false;
					
					for ( var r=0; r < possible_values_array.length; r++ )
					{
						if (protocol_types[u]==possible_values_array[r])
						{
							found = true;
							r = possible_values_array.length;
						}
					}
					
					if (!found)
					{
						protocol_string += "("+protocol_types[u].toLowerCase()+")";
					}
				}
			}
			
			protocol  = "(("+protocol_string+"){1}(:\/\/){1}){1}";
		}
		else
		{
			protocol  = "(((pop3)|(ip)|(imap)|(pptp)|(ppp)|(tcp)|(udp)|(smtp)|(mysql)|(http)|(ftp)|(mailto)|(localhost)|(https)){1}(:\/\/){1}){1}";
		}
		return protocol;
	}
	
	// get form index of an input field
	function getTabIndex( form_id, name )
	{
		var obj_form = document.getElementById( form_id );
		var obj_inputs = obj_form[name];
		var field_type = getFieldType( form_id, name );
		
		if (obj_inputs[0])
		{
			 if (obj_inputs[0].tabIndex>0)
			{
				return obj_inputs[0].tabIndex;
			}
			else
			{
				if (field_type=="select"&&obj_inputs.tabIndex)
				{
		          return obj_inputs.tabIndex;
		        }
		        else
		        {
		          alert( "iX.formChecks | method - getTabIndex: Please set a tabindex for the field '"+name+"' in form '"+form_id+"'" );
				  return false;
		        }
			}
			
		}
		else
		{
		  if (obj_inputs.tabIndex>0)
			{
				return obj_inputs.tabIndex;
			}
			else
			{
				alert( "iX.formChecks | method - getTabIndex: Please set a tabindex for the field '"+name+"' in form '"+form_id+"'" );
				return false;
			}
		}
	}
	
	// field type
	function getFieldType( form_id, field_name )
	{	
		var field_type = new String();
		var obj        = new Object();
		var obj_inputs = new Object();
		var obj_form   = new Object();
		
		var obj_form = document.getElementById( form_id );
		var obj_inputs = obj_form[field_name];
		
		if (obj_inputs)
		{
			if (obj_inputs[0])
			{
				obj = obj_inputs[0];
			}
			else
			{
				obj = obj_inputs;
			}

			if (obj.tagName == "OPTION"||obj.tagName == "SELECT")
			{
				var field_type = "select";
			}
			
			if (obj.tagName == "TEXTAREA")
			{
				var field_type = "input_text";
			}

			if (obj.tagName == "INPUT")
			{
				var type = obj.getAttribute( "type" );
				switch (type)
				{
					case "radio":
						var field_type = "input_radio";
						break;
						
					case "checkbox":
						var field_type = "input_checkbox";
						break;
					
					case "file":
					case "hidden":
					case "text":
						var field_type = "input_text";
						break;
				}
			}
		}
		
		return field_type;
	}
	
	function getValueType( form_id, field_name )
	{
		var value_type = new String();
		var obj_inputs  = new Object();
		var obj_form  = new Object();
		
		obj_form = document.getElementById( form_id );
		obj_inputs = obj_form[field_name];
		
		var field_type = getFieldType( form_id, field_name );
		
		if (obj_inputs)
		{
			switch (field_type)
			{
				case "select":
					if (obj_inputs.options!=undefined)
					{
						value_type = obj_inputs.variables_cf.value_type;
					}
					else
					{
						value_type = obj_inputs[0].variables_cf.value_type;
					}
					break;
					
				default:
					if ( obj_inputs[0] )
					{
						value_type = obj_inputs[0].variables_cf.value_type;
					}
					else
					{	
						value_type = obj_inputs.variables_cf.value_type;
					}
					break;
			
			}
		}
		return value_type;
	}
	
	function getValue( form_id, name, count_name )
	{
		var value = new String();
		var field_type = getFieldType( form_id, name );

		if (field_type)
		{
			switch ( field_type )
			{
				case "input_checkbox":
					value = getValueInputCheckbox( form_id, name, count_name );
					break;
				
				case "input_radio":
					value = getValueInputRadio( form_id, name, count_name );
					break;
				
				case "select":
					value = getValueSelection( form_id, name, count_name );
					break;
				
				case "input_text":
					value = getValueInputText( form_id, name, count_name );
					break;
			}
		}
		
		return value;
	}
	
	function getValueInputRadio( form_id, name, count_name )
	{
		var value     = new String();
		var obj_input  = new Object();
		var obj_form  = new Object();
		
		obj_form = document.getElementById( form_id );
		obj_input = obj_form[name];
		
		if (obj_input)
		{
			if (obj_input[0])
			{
				for (var c = 0; c < obj_input.length; c++)
				{
					if (obj_input[c].checked==true)
					{
						value = obj_input[c].value;
					}
				}
			}
			else
			{
				value = obj_input.value;
			}
		}
		return value;
	}
	
	function getValueSelection( form_id, name, count_name )
	{
		var value = new String();
		var options = new Object();
		var obj_form  = new Object();
		var obj_select  = new Object();
		
		obj_form = document.getElementById( form_id );
		obj_select = obj_form[name];
		
		if (count_name==undefined)  {count_name=0;}
		
		if (!obj_select)
		{
			alert( "iX.formChecks | method - getValueSelection: Selection does not exist: "+name );
			return false;
		}
		else
		{
			if (obj_select.options!=undefined)
			{
				options = obj_select.getElementsByTagName( "option" );
				
				for ( var m = 0; m < options.length; m++)
				{
					if (options[m].selected==true)
					{
						value += ""+options[m].value;
					}
				}
			}
			else
			{
				options = obj_select[count_name].options;
				
				for ( var m = 0; m < options.length; m++)
				{
					if (options[m].selected==true)
					{
						value += ""+options[m].value;
					}
				}
			}
		}

		return value;
	}
  
	function getValueInputCheckbox( form_id, name, count_name )
	{
		var value = new String();
		var obj_input  = new Object();
		var obj_form  = new Object();
		
		obj_form = document.getElementById( form_id );
		obj_input = obj_form[name];
		
		if (!obj_input)
		{
			alert( "iX.formChecks | method - getValueInputCheckbox: Input field does not exists: "+name );
			return false;
		}
		else
		{
			if (obj_input[0])
			{
				if (obj_input[count_name].checked==true)
				{
					if (obj_input[count_name].value)
					{
						value = obj_input[count_name].value;
					}
					else
					{
						value = 1;
					}
				}
			}
			else
			{
				if (obj_input.checked==true)
				{
					if (obj_input.value)
					{
						value = obj_input.value;
					}
					else
					{
						value = 1;
					}
				}
			}
		}

		return value;
	}
  
	function getValueInputText( form_id, name, count_name )
	{
		var value      = new String();
		var obj_input  = new Object();
		var obj_form   = new Object();
		
		count_name = parseFloat(count_name);
		
		obj_form = document.getElementById( form_id );
		obj_input = obj_form[name];
		
		if (!obj_input)
		{
			alert( "iX.formChecks | method - getValueInputText: Input field dos not exists: "+name );
			return false;
		}
		else
		{
			if (obj_input[0])
			{
				if (obj_input[count_name])
				{
					value = obj_input[count_name].value;
				}
			}
			else
			{
				if (obj_input.value)
				{
					value = obj_input.value;
				}
			}
		}
		
		return value;
	}
	
	function getAcceptedValues( form_id, name )
	{
		var values = new String();
		
		var obj_form = window.document.getElementById( form_id );
		var obj_input = obj_form[name];
		
		if (obj_input[0]!=undefined && !obj_input.options)
		{
			values = obj_input[0].variables_cf.possible_values;
		}
		else
		{
			values = obj_input.variables_cf.possible_values;
		}
		return values;
	}
	
	function isInArray( needle, haystack )
	{
		if (haystack)
		{
			for ( var u = 0; u < haystack.length; u++ )
			{
				if ( haystack[u] == needle )
				{
					return true;
				}
			}
			return false;
		}
		else
		{
			return true;
		}
	}
	
	function isDataFormatOk( obj_check, form_id, value, value_type, possible_values )
	{
		var no_error = true;
		
		switch ( value_type )
		{
			case "DATE": 
				no_error = isDate( form_id, obj_check.name, value );
				break;
				
			case "EMAIL":
				no_error = isEmail( value );
				break;
			
			case "IP ADRESS":
				no_error = isIpAdress( value );
				break;
			
			case "URL":
				no_error = isUrl( form_id, obj_check.name, value, possible_values );
				break;
				
			case "DECIMAL":
				no_error = isDecimal( value );
				break;
				
			case "INTEGER":
				no_error = isInteger( value );
				break;
				
			case "LETTER":
				no_error = isLetter( value );
				break;
				
			case "STRING":
				no_error = isString( value );
				break;
				
			case "TELEPHON":
				no_error = isTelephonNumber( form_id, obj_check.name, value, possible_values );
				break;
				
			case "BOOLEAN":
				no_error = isBoolean( value );
				break;
		}
		
		return no_error;
	}
	
	function isValueAccepted( form_id, name, possible_values, count_name )
	{
		var values     = new String();
		var accepted   = false;
		var value_type = getValueType( form_id, name );
		var value      = getValue( form_id, name, count_name );
		
		if (possible_values!=""&&value!=""&&value_type)
		{
			switch (value_type)
			{
				case "DATE":
					accepted = true;
					break;
				
				case "INTEGER":
				case "DECIMAL":
					values = possible_values;
					value = parseFloat(value);

					if (values[0]!="!")
					{
						if ( values[0] <= value && values[1] >= value )
						{
							accepted = true;
						}
					}
					else
					{
						if ( values[1] <= value && values[2] >= value )
						{
							accepted = false;
						}
						else
						{
							accepted = true;
						}
					}
					break;
					
				case "STRING":
				case "LETTER":
					values = possible_values;
					
					for ( var l = 0; l < values.length; l++ )
					{
						if (values[0]=="!")
						{
							if (values[l]==value&&values[l]!="!")
							{
								l = values.length+1;
								accepted = false;
							}
							else
							{
								accepted = true;
							}
						}
						else
						{
							if (value == values[l]&&value)
							{
								accepted = true;
							}
						}
					}
					
					break;
				
				case "URL":
				case "TELEPHON":
				case "EMAIL":
				case "BOOLEAN":
				default:
					accepted = true;
					break;
			}
		}
		else
		{
			accepted  = true;
		}
		
		return accepted;
	}
	
	function isParentSet( form_id, name, count_name )
	{
		var obj_input                = new Object();
		var obj_form                 = new Object();
		var obj_form_parent          = new Object();
		var obj_input_parent         = new Object();
		var obj_in                   = new Object();
		var parent_field             = new String();
		var parent_activation_values = new String();
		var field_type               = new String();
		
		obj_form = document.getElementById(form_id);
		obj_input = obj_form[name];
		field_type = getFieldType( form_id, name );

		if (obj_form[name])
		{
			if (obj_input[0])
			{
				switch (field_type)
				{
					case "select":
						if (obj_input.options!=undefined)
						{
							obj_in = obj_input;
						}
						else
						{
							obj_in = obj_input[0];
						}
						break;
						
					default:
						obj_in = obj_input[0];
						break;
				}
			}
			else
			{
				obj_in = obj_input;
			}
			
			parent_field             = obj_in.variables_cf.parent_field;
			parent_activation_values = obj_in.variables_cf.parent_activation_values;

			if ( parent_field!="" )
			{
				obj_form_parent = document.getElementById(form_id);
				obj_input_parent = obj_form[parent_field];
				
        var parent_value = getValue( form_id, parent_field, count_name );
				
				if (!obj_input_parent)
				{
					return false;
				}
				
				if (obj_input_parent.name||obj_input_parent.options)
				{
					var obj_parent = obj_input_parent;
					var obj_class = self[obj_parent.variables_cf.check_form_object];
				}
				else
				{
					var obj_parent = obj_input_parent[count_name];
					var obj_class = self[obj_parent.variables_cf.check_form_object];
				}
				
				if (obj_parent.name)
				{
					var obj_check = obj_parent;
				}
				else
				{
					var obj_check = obj_parent[count_name];
				}
				
				/*
				if (obj_input_parent==undefined)
				{
					alert( "Parent object '"+parent_field+"' for field '"+name+"' in form '"+form_id+"' does not exist." );
					return false;
				}
				*/
				
				if ( parent_activation_values[0] )
				{
					if ( parent_value != "" )
					{
						var values = parent_activation_values;

						for ( var u=0; u < values.length; u++ )
						{
							if ( parent_value == values[u] )
							{
								return true;
							}
						}
						return false;
					}
					else
					{
						return false;
					}
				}
				else
				{
					if 
          (
            parent_value != "" &&
            isDataFormatOk( obj_check, obj_check.variables_cf.form_id, parent_value, obj_check.variables_cf.value_type, obj_check.variables_cf.possible_values ) &&
						isValueAccepted( obj_check.variables_cf.form_id, obj_check.name, obj_check.variables_cf.possible_values, obj_check.variables_cf.count_name ) &&
						isStringLengthOk( parent_value, obj_check.variables_cf.min_length, obj_check.variables_cf.max_length ) 
					)
					{
						return true;
					}
					else
					{
						return false;
					}
				}
			}
			else
			{
				return true;
			}
		}
		else
		{
			alert("iX.formChecks | method - isParentSet: Can not find input field with the name:"+name );
			return false;
		}
	}
	
	function isASignWrong( form_id, name, value_type, count_name  )
	{
		var reg_string = new String();
		var exp = new Object();
		var value = getValue( form_id, name, count_name );
		
		if (value_type)
		{
			switch (value_type)
			{
				case "DATE": 
					var possible_values = getAcceptedValues( form_id, name );
					
					if (possible_values[1])
					{
						var reg_string = possible_values[1];
					}
					else
					{
						var reg_string  = "(^[0-9]{1,2}$)|";
						    reg_string  += "(^[0-9]{1,2}[\\.\\/_\\-]{1}$)|";
						    reg_string  += "(^[0-9]{1,2}[\\.\\/_\\-]{1}[0-9]{1,2}$)|";
						    reg_string  += "(^[0-9]{1,2}[\\.\\/_\\-]{1}[0-9]{1,2}[\\.\\/_\\-]{1}$)|";
						    reg_string  += "(^[0-9]{1,2}[\\.\\/_\\-]{1}[0-9]{1,2}[\\.\\/_\\-]{1}[0-9]{1,4}$)";
					}
					break;
					
				case "EMAIL":
				  return true;
					var reg_string  = "(^([0-9A-Za-z-_]){1,}$)|"
				    reg_string += "(^(([0-9A-Za-z-_]){1,}[\\.]{0,1}){1,}$)|"
				    reg_string += "(^(([0-9A-Za-z-_]){1,}[\\.]{0,1}){1,}@{1}$)|"
						reg_string += "(^(([0-9A-Za-z-_]){1,}[\\.]{0,1}){1,}@{1}([0-9A-Za-z-_]{1,})*$)|"
						reg_string += "(^(([0-9A-Za-z-_]){1,}[\\.]{0,1}){1,}@{1}([0-9A-Za-z-_]{1,}[\\.]{0,1}){1,}$)";
					break;
					
				case "URL":
					var reg_string  = "^[0-9a-z潼瞿周_@\:\.\?\&\/#=]*$";
					break;
				
				case "IP ADRESS":
					var reg_string  = "(^[0-9]{1,3}$)|";
					    reg_string += "(^[0-9]{1,3}\\.{1}$)|";
					    reg_string += "(^[0-9]{1,3}\\.[0-9]{1,3}$)|";
					    reg_string += "(^[0-9]{1,3}\\.[0-9]{1,3}\\.{1}$)|";
					    reg_string += "(^[0-9]{1,3}\\.[0-9]{1,3}\\.[x0-9]{1,3}$)|";
					    reg_string += "(^[0-9]{1,3}\\.[0-9]{1,3}\\.[x0-9]{1,3}\\.{1}$)|";
					    reg_string += "(^[0-9]{1,3}\\.[0-9]{1,3}\\.[x0-9]{1,3}\\.[x0-9]{1,3}$)|";
					    reg_string += "(^[0-9]{1,3}\\.[0-9]{1,3}\\.[x0-9]{1,3}\\.[x0-9]{1,3}[/]{1}$)|";
					    reg_string += "(^[0-9]{1,3}\\.[0-9]{1,3}\\.[x0-9]{1,3}\\.[x0-9]{1,3}[/]{1}[x0-9]{1,3}$)";
					break;
				
				case "LETTER":
					var reg_string = "^[A-Za-z鲣能]*$";
					break;
				
				case "DECIMAL":
					var reg_string = "(^[-]{0,1}[0-9]{1,}$)|(^[-]{0,1}[0-9]{1,}\\.?$)|(^[-]{0,1}[0-9]{1,}\\.?[0-9]{1,}$)";
					break;
					
				case "INTEGER":
					var reg_string = "^[-]{0,1}[0-9]{1,}$";
					break;
					
				case "TELEPHON":
					var reg_string = new String();
					
					var state = "(([\\+]{1})|[\\+]{1}[0-9]{1,2}){1}";
					var location = "(((\\(){1})|((\\(0){1})|((\\(0\\)){1})|((\\(0\\)){1}[0-9]{1,7})|([0-9]{1,7})){1}";
					var connection = "(([0-9]{1,}[\\s]{0,1}){0,5}){1}";

					var possible_values = getAcceptedValues( form_id, name );
					
					if (possible_values!="")
					{
						lowest = getRegTelephon( possible_values );		

			            switch (lowest)
			            {
			              case 1:
			                var reg_string = "(^"+state+"$)|(^"+state+location+"$)|(^"+state+location+connection+"$)";
			                break;
			                
			              case 2:
			                var reg_string = "(^"+location+"$)|(^"+location+connection+"$)";
			                break;
			                
			               case 3:
			                var reg_string = "(^"+connection+"$)";
			                break;
			            }
					}
					else
					{
						var reg_string = "(^"+state+"$)|(^"+state+location+"$)|(^"+state+location+connection+"$)|(^"+location+connection+"$)|(^"+connection+"$)";
					}
					break;
					
				case "STRING":
					break;
					
				case "BOOLEAN":
					var reg_string = "^[0-1]{1}$";
					break;
			}
		}
		
		if ( value )
		{
			if ( reg_string != "" )
			{
				exp = new RegExp( reg_string );

				if ( value.match( exp ) )
				{
					switch (value_type)
					{
						case "IP ADRESS": 
							var split_values = value.split(".");
							for (var h = 0; h < split_values.length; h++)
							{
								if (split_values[h]>255)
								{
									return false;
								}
							}
							return true;
							break;
							
						default:
							return true;
							break;
					}
				}
				else
				{
					return false;
				}
			}
			else
			{
				return true;
			}
		}
		else
		{
			return true;
		}
	}
	
	function isStringLengthOk( value, min_length, max_length )
	{
	    if ( value.length < min_length && min_length > 0 )
	    {
	      return false;
	    }
	    
	    if ( value.length > max_length && max_length > 0 )
	    {
	      return false;
	    }
	    
	    return true;
	}
  
	function isEmail( value )
	{
		if ( value.match( /((([A-Za-z0-9]+_+)|([A-Za-z0-9]+\-+)|([A-Za-z0-9]+\.+)|([A-Za-z0-9]+\++a))*[A-Za-z0-9]+@((\w+\-+)|(\w+\.))*\w{1,63}\.[a-zA-Z]{2,3})(;|,|)/ ) )
		{
			return true;
		}
		else
		{
			return false;
		}
	}
  
	function isDate( form_id, name, date_value )
	{
		var possible_values = getAcceptedValues( form_id, name );
		
		if (possible_values[0])
		{
			var reg_string = possible_values[0];
		}
		else
		{
			var reg_string = "^[0-9]{1,2}\\.[0-9]{1,2}\\.[0-9]{4}$";
		}
		
		var expression = new RegExp( reg_string );

		if ( expression.test( date_value ) )
		{
			return true;
		}
		else
		{
			return false;
		}
	}
  
	function isIpAdress( value )
	{
		if ( value.match( /^[0-9]{1,3}\.[0-9]{1,3}\.[0-9x]{1,3}\.[0-9x]{1,3}$/ ) )
		{
			var split_values = value.split(".");
			for (var h = 0; h < split_values.length; h++)
			{
				if (split_values[h]>255)
				{
					return false;
				}
			}
			return true;
		}
		else
		{
			return false;
		}
	}
  
	function isUrl( form_id, name, value, possible_values )
	{
		var url_reg               = new String();
		var protocol              = new String();
		var domain                = new String();
		var port                  = new String();
		var path                  = new String();
		var file                  = new String();
		var query                 = new String();
		var ancor                 = new String();
		var user_pwd              = new String();

	    protocol          = getRegUrlProtocol( form_id, name, possible_values );
		user_pwd          = "(([a-z]{1,}[@]{1})|([a-z]{1,}[:]{1}[@]{1})|([a-z]{1,}[:]{1}[a-z]{1,}[@]{1})){0,1}";
		domain            = "((([a-z]{1,}[\.]{1}){1,}([a-z]{2,3}){1})|(([0-9]{1,3}[\.]{1}){3}[0-9]{1,3})){1}";
		port              = "([\:]{1}[0-9]{1,4}){0,1}";
		path              = "([\/]{1}[a-z]{1,}){0,}";
		file              = "([\/]{1}([a-z]{1,}[\\.]{1})*[a-z]{1,3}){0,1}";
		query             = "([\?]{1}([a-z0-9]{1,}[=]{1}[a-z鲣能]{0,}){1}){0,1}([&]{1}[a-z0-9]{1,}[\=]{1}[a-z鲣能]{0,}){0,1}";
		ancor             = "([#]{1}[a-z0-9]{1,}){0,1}";
		
		url_reg  = "(^"+protocol+user_pwd+domain+port+path+file+query+ancor+"$)";
		
		var reg_string = new RegExp( url_reg );
		
		if ( value.match( reg_string ) )
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	
	function isLetter( value )
	{
		if ( value.match( /^[a-zA-z鲣能]*$/ ) )
		{
			return true;
		}
		else
		{
			return false;
		}
	}
  
	function isTelephonNumber( form_id, name, value, possible_values )
	{
		var reg                   = new Object();
		var reg_string            = new String();
		var state                 = new String();
		var location              = new String();
		var connection            = new String();
		var lowest                = 3;
    
		state = "[+]{1}[0-9]{2}";
		location = "(\\(0\\)){0,1}[0-9]{2,6}";
		connection = "([\\s]{0,1}[0-9]{2,12}){1,12}";
		
		if (possible_values!="")
		{
			lowest = getRegTelephon( possible_values );
			
			switch (lowest)
			{
				case 1:
					reg_string = "(^"+state+location+connection+"$)";
					break;

				case 2:
					reg_string = "(^"+location+connection+"$)";
					break;

				case 3:
					reg_string = "(^"+connection+"$)";
					break;
			}
			
		}
		else
		{
			reg_string = "(^"+state+location+connection+"$)|(^"+location+connection+"$)|(^"+connection+"$)";
		}
    
		reg = new RegExp(reg_string);
		
		if ( value.match( reg ) )
		{
			return true;
		}
		else
		{
			return false;
		}
	}
  
	function isDecimal( value )
	{
		if ( value.match( /^[-]{0,1}[0-9]{1,}(([\\.]){0,1}[0-9]{1,}){0,}$/ ) )
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	
	function isInteger( value )
	{
		if ( value.match( /^[-]{0,1}[0-9]*$/ ) )
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	
	function isString( value )
	{
		return true;
	}

	function isBoolean( value )
	{
		if ( value == 0 || value == 1 )
		{
			return true;
		}
		else
		{
			return false;
		}  
	}
}