var GXLastValidRow;
var GXInvalidCtrlNum = '';
var GXFromValid=0;
var GXToValid=0;
var GXLastFocusCtrl=0;
var GXLastCurrentGrid=0;
var GXFocusCtrl;
var GXInvalidCtrl;
var GXInvalidFrmtCtrl;
var GXLastFocusCtrlRef=null;
var GXOldValue = new Array();
var GXCurrentRow = new Array();
var GXOldKeyValue = new Array();
var GXWCP = '';
var WCSV_ctx = '_';
var	GXDisableFocus = false;
var GXNewRow = new Array();
var gxSuggestControls = new Array();
var gxDisabledControls = new Object;
var GXUserFocus=null;
var GXLastEvtControl=null;

function gxpushElement( Array, Element, Key)
{
	if (Array[Key] == undefined)
	{	
			Array[Key] = Element;
	}
}

var gxCtrlKeyCode = [ 	0x03, 0x06, 0x08, 0x09, 0x0C, 0x0D, 0x0E, 0x10, 0x11, 0x12, 0x13, 
						0x14, 0x1B, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 
						0x2C, 0x2D, 0x2E];
 							
function isCtrlKeyCode( Code)
{
	for (var i=0; i<gxCtrlKeyCode.length;i++)
	{
		if (Code == gxCtrlKeyCode[i])
			return true;
	}
	return false;
}
function valid_decimal( Elem, ThSep, DecPoint, Dec)
{
	var gx_DecRegExp = new RegExp("^[ ]*([+-]?[0-9]*(\\" + ThSep + "[0-9]{3})*(\\" + DecPoint + "[0-9]*)?)?[ ]*$");
	if (gx_DecRegExp.test( Elem.value))
	{
		DecPointIndex = Elem.value.indexOf(DecPoint);
		if (DecPointIndex != -1)
			Elem.value = Elem.value.slice( 0, DecPointIndex + parseInt(Dec,10) + 1);
	}
	else
	{
		GXAlert( Elem, GXBadNumMsg);
	}
}

function valid_integer( Elem, ThSep)
{
	var gx_IntRegExp = new RegExp("^[ ]*([+-]?[0-9]*(\\" + ThSep + "[0-9]{3})*)?[ ]*$");
	if (! gx_IntRegExp.test( Elem.value))
	{ 
		GXAlert( Elem, GXBadNumMsg);
	}
}

function GX_js_close()
{
	if (document.forms[0].sCallerURL.value == "" || window.opener != undefined)
		window.close();
	else
		window.location.assign(document.forms[0].sCallerURL.value);
}

function GXsetGridCheckBoxValue(ControlId, sRow, Value, Checked)
{
	GXsetCheckBoxValue( ControlId + "_" + sRow, Value, Checked)
}
function GXsetGridDecimalValue(ControlId, sRow, Value, Dec, DecPoint)
{
	Value = Value.toString().replace( DecPoint, '.');
	Value = Number( Value).toFixed( Dec);
	Value = Value.replace( '.', DecPoint);
	return GXsetGridControlValue( ControlId, sRow, Value);
}


function GXsetGridControlValue( ControlId, sRow, PValue, GXCtrlFormat)
{
	return GXsetControlValue( ControlId + "_" + sRow, PValue, GXCtrlFormat);
}

function GXsetControlsValues( ControlsId, ControlsValue)
{
	for (var i=0; i<ControlsId.length;i++)
		GXsetControlValue( ControlsId[i], ControlsValue[i]);
}

function GXsetVarValues( VarIds, VarValues)
{
	for (var i=0; i<VarIds.length;i++)
	{
		var validStruct = gxControlStructForVar(VarIds[i]);
		if(validStruct != null)
		{
			validStruct.v2v(gxEncodeValue( VarValues[i]));
		}
		else
		{
			eval( VarIds[i] + '="' + gxEncodeValue( VarValues[i]) + '"');
		}
	}
}

function gxEncodeValue( Value)
{
	return gxCharReplace( Value, ['"',"'"], ['\\042','\\047']);
}

function gxCharReplace( Value, Chars, Repls)
{
	var Ret = '';
	for (var i=0;i<Value.length;i++)
	{
		var bFixed = false;
		for (var c=0;c<Chars.length;c++)
		{
			if ( Value.charAt(i) == Chars[c])
			{
				if (c < Repls.length)
				{
					Ret += Repls[c];
					bFixed = true;
					break;
				}
			}
		}
		if (bFixed == false)
			Ret += Value.charAt(i);
	}
	return Ret;
}

function GXsetControlValue( ControlId, Value, GXCtrlFormat)
{
	ControlId = GXCmpControlId( ControlId);
	setControlValue( ControlId, Value, GXCtrlFormat);
}


function GXsetDecimalValue(ControlId, Value, Dec, DecPoint)
{
	Value = Value.toString().replace( DecPoint, '.');
	Value = Number( Value).toFixed( Dec);
	Value = Value.replace( '.', DecPoint);
	GXsetControlValue( ControlId, Value);
}
function GXtoDecimalValue( Value, Dec, DecPoint)
{
	return gxparseFloat(Value, Dec, DecPoint);
}

function GXCmpControlId( ControlId)
{	
	if (ControlId.indexOf(GXWCP) == 0)
		return ControlId;
	return GXWCP + ControlId;
}

function GXsetCheckBoxValue( ControlId, Value, Checked)
{
	try
	{
		var Control = document.forms[0][ControlId];
		if (Control == null)
			Control = document.getElementById(ControlId);
		Control.checked = (Value==Checked);
	}
	catch(e) {}
}

function setControlValue( ControlId, Value, GXCtrlFormat)
{
	
	if (Value instanceof gxdate)
	{
		Value = Value.getString();
	}
	var CtrlFormat = GXCtrlFormat || 0;
	var Control = GXgetControlRef_impl( ControlId);	
    if (Control != null)
    {
		Control.value = Value ;
		if (Control.type == "text")
			return;
	}
	if ((Control != null) && (Control.length != undefined) && (Control[0].type == 'radio'))
		gxSetRadioValue( Control, Value);
	else
	{
		Control = document.getElementById( "span_"+ControlId);
	    if (Control != null)
		{
			if( CtrlFormat == 1 )
				Control.innerHTML = Value;
			else
			{
				if( CtrlFormat == 0 && typeof(Value) == 'string')
					Value = Value.replace( / +/g, ' ');
				if(Control.childNodes.length == 0)
					Control.appendChild( document.createTextNode(""));
				Control = Control.childNodes[0];
				Control.nodeValue = Value;
			}
		}
	}
}

function gxClearControlValue( Control)
{
	if (Control == null)
		return;
	if (Control.nodeName == "SPAN")
	{
		var Childs = Control.childNodes;
		for( var i=0;i<Childs.length;i++)
			Control.removeChild( Childs[i]);
		return;
	}
    if (Control != null)
		Control.value = '';
}

function change_control( newValue, checkCtrl)
{
	if (checkCtrl.value != newValue && checkCtrl.type == "checkbox" )
		checkCtrl.checked = !checkCtrl.checked;
}

function GXReturnAutosuggestValues( Var, adata)
{
	return adata;
}

function GXsetHideCode( ControlIds, adata)
{
	GXsetVarValues( ControlIds, adata);
}

function GXsetGridComboBoxValue(ControlId, sRow, Value)
{
	GXsetComboBoxValue(ControlId + "_" + sRow, Value);
}
 
function GXsetComboBoxValue(ControlId, Value)
{
	ControlId = GXCmpControlId( ControlId);
	var Ctrl = document.forms[0][ControlId];
	if (Ctrl == null)
		Ctrl = document.getElementById(ControlId);
	if (Ctrl == null)
		return;
	try
	{
		for ( var i=0;i<Ctrl.options.length;i++)
		{
			if (Ctrl.options[i].value == Value)
			{
				Ctrl.selectedIndex=i;
				return;
			}
		}
		Ctrl.selectedIndex=0;
	}catch(e){}
}

function GXsetComboValues( ControlId, adata)
{
	Ctrl = GXgetControlRef_impl( ControlId);
	if (Ctrl == null)
		return;
	var currValue = '';
	if (Ctrl.selectedIndex != -1)
		currValue = Ctrl.options[Ctrl.selectedIndex].value;
	while( Ctrl.options.length > adata.length)
		Ctrl.remove( Ctrl.options.length - 1);
	while( adata.length > Ctrl.options.length)
	{
		var E = document.createElement("OPTION");
		Ctrl.options.add( E);
	}
	for ( var i=0;i<adata.length;i++)
	{
		var E = Ctrl.options[i];
		E.value = adata[i].c;
		E.text = adata[i].d;
		if (E.value == currValue)
			Ctrl.selectedIndex=i;
	}
	if (Ctrl.options.length  == 0)
		Ctrl.selectedIndex = -1;
	else
	{
		if (Ctrl.selectedIndex == -1 || Ctrl.selectedIndex > Ctrl.options.length - 1)
		{
			Ctrl.options[0].selected = true;
		}
	}
}

function GXgetControlRef( ControlId)
{
	ControlId = GXCmpControlId( ControlId);
	Control = GXgetControlRef_impl( "span_"+ControlId);
    if (Control != null)
    	return Control;
	Control = GXgetControlRef_impl( ControlId);
    if (Control != null)
    	return Control;
	Control = GXgetControlRef_impl( "_"+ControlId);
    if (Control != null)
    	return Control;
	return null;
}

function GXScreen_CtrlRef( ControlId)
{
	var Control = GXgetControlGridRef( ControlId, gxControlGrid( ControlId));
	if (Control.type == 'hidden')
		Control = GXgetControlRef_impl( "span_"+gxSafeId(Control));	
	return Control;
}

function GXgetControlRef_impl( ControlId)
{
	Control = document.forms[0][ControlId];
	if (Control != null)
		return Control;
	Control = document.getElementById(ControlId);
	if (Control != null)
		return Control;
	ControlList = document.getElementsByName( ControlId);
	if (ControlList != null)
		return ControlList[0]; 
	return null;
}

function GXgetControlRef_list( ControlId)
{
	var ControlList = document.getElementsByName( ControlId);
	if (ControlList != null)
		return ControlList; 
	var Control = document.getElementById(ControlId);
	if (Control != null)
		return [Control];
	return null;
}


function gxCurrentGridRow( GridId)
{
	try
	{
		return GXCurrentRow[GridId];
	}
	catch(e){}
	return undefined;
}

function GXCurrentGridRow( GridId)
{
	var Ret = gxCurrentGridRow( GridId);
	return (Ret == undefined)?'0001':Ret;
}

function GXgetControlGridRef( ControlId, GridId)
{
	ControlId = GXCmpControlId( ControlId);
	try
	{
		if (GridId == 0)
			return GXgetControlRef_impl( ControlId);
		return GXgetControlRef_impl( ControlId + "_" + GXCurrentGridRow( GridId));
	}
	catch(e){}
}

function GXCheckRowChange( Ctrl)
{
	var GridId = 0;
	try
	{
		var GridId = GXValidStruct(Ctrl).grid;
		var GXValidRow = gxCurrentGridRow( GridId);
		if (GXValidRow != 0 && GXValidRow != GXLastValidRow && GXValidRow.length > 1 && GXLastValidRow.length > 1)
		{
			if (gxValidGridRowChange( GridId, GXValidRow) == true)
				eval( "GXCurrentRow[GridId]='" + GXValidRow + "'");
			return true;
		}
		
	}
	catch(e){}
	if (GXValidRow != undefined)
		eval( "GXCurrentRow[GridId]='" + GXValidRow + "'");
	return false;
}

function gxValidGridRow( GridId, GXValidRow)
{
	if (GXValidRow != undefined)
		eval( "GXCurrentRow[GridId]='" + GXValidRow + "'");
	var firstGridCtrl = gxFirstGridControl( GridId);
	var lastGridCtrl = gxLastGridControl( GridId);
	return GXValidControls( firstGridCtrl, lastGridCtrl + 1, true);
}

function gxValidGridRowChange( GridId, GXValidRow)
{
	if (GXLastValidRow != undefined)
		eval( "GXCurrentRow[GridId]='" + GXLastValidRow + "'");
	var firstGridCtrl = gxFirstGridControl( GridId);
	var lastGridCtrl = gxLastGridControl( GridId);
	var bRet = GXValidControls( firstGridCtrl, lastGridCtrl + 1, true);
	if (bRet)
		gxChangeGridRow( GridId, firstGridCtrl, GXValidRow);
	return bRet;
}

function gxChangeGridRow( GridId, firstGridCtrl, GXValidRow)
{
	var bRowisMod = GXGridRowIsMod( gxGridLvl( GridId), GXLastValidRow);
	if (bRowisMod)
		gxsetNewRow( GridId, GXLastValidRow, false);
	GXLastFocusCtrl = firstGridCtrl;
	if (GXFromValid > firstGridCtrl)
		GXFromValid = firstGridCtrl;
	GXLastValidRow = GXValidRow;
	Gx_BScreen = 1;
}

function gxFirstGridControl( GridId)
{
	for(i=0;i<=GXLastCtrlId();i++)
	{
		if (GXValidStruct(i) != undefined && GXValidStruct(i).grid == GridId)
			return i;
	}
	return -1;
}

function gxLastGridControl( GridId)
{
	for(i=GXLastCtrlId();i>=0;i--)
	{
		if (GXValidStruct(i) != undefined && GXValidStruct(i).grid == GridId)
			return i;
	}
	return -1;	
}

function GXgetGridDecimalValue(ControlId, sRow, ThSep, DecPoint)
{
	return GXgetDecimalValue( ControlId + "_" + sRow, ThSep, DecPoint);
}

function GXgetGridIntegerValue(ControlId, sRow)
{
	return GXgetIntegerValue( ControlId + "_" + sRow);
}

function GXgetGridControlValue( ControlId, sRow)
{
	return GXgetControlValue( ControlId + "_" + sRow);
}

function GXgetGridCheckBoxValue(ControlId,sRow,Checked,Unchecked)
{
	return GXgetCheckBoxValue( ControlId + "_" + sRow, Checked, Unchecked)
}

function GXgetCheckBoxValue( ControlId, Checked, Unchecked)
{
	ControlId = GXCmpControlId( ControlId);
	Control = document.forms[0][ControlId];
	if (Control == null)
	{
		ControlList = document.getElementsByName( ControlId);
		if (ControlList != null)
			Control = ControlList[0];
	}
	if (Control == null)
		return 0;
	if (Control.checked)
		return Checked;
	return Unchecked;
}

function GXgetControlValue( ControlId)
{
		return GXgetControlValue_impl( GXCmpControlId( ControlId));
}

function gxSetRadioValue( Control, Value)
{
	for (var i=0;i<Control.length;i++)
	{
		if (Control[i].value == Value)
		{
			Control[i].checked = true;
			return;
		}
	}
}

function gxGetRadioValue( Control)
{
	for (var i=0;i<Control.length;i++)
	{
		if (Control[i].checked)
			return Control[i].value;
	}
}

function GXgetControlValue_impl( ControlId)
{
	try
	{
	
		Control = GXgetControlRef_impl( ControlId);
		if (Control != null)
		{
			if (Control.type == "hidden")
						return Control.value;
		}
		Control = GXgetControlRef_impl( "span_"+ControlId);
        if (Control != null)
        	return Control.nodeValue;
		Control = document.forms[0][ControlId];
		if (Control != null)
			return gxGetControlValue( Control);
		Control = document.getElementById( "_"+ControlId);
		if (Control != null)
       		return Control.value;
		ControlList = document.getElementsByName( ControlId);
		if (ControlList && ControlList.length == 0)
			ControlList = document.getElementsByName( "_"+ControlId);
		if (ControlList != null)
		{
			for (var i=0;i<ControlList.length;i++)
			{
				Control = ControlList[i];
				if (Control != null)
					return gxGetControlValue( Control);
	    	}
	    	Control = ControlList[0];
	    	if (Control)
	    		return Control.value;
	    }
	}
	catch(e){}
	return "";
}

function gxGetControlValue( Control)
{
	if ((Control.length != undefined) && (Control[0].type == 'radio'))
		return gxGetRadioValue( Control);
	if (Control.type == "checkbox")
		return Control.checked;
	return Control.value;
}

function GXgetDateValue( ControlId)
{
	try
	{
		var Control = GXgetControlRef_impl( GXCmpControlId( ControlId));
		if(Control != null)
		{
			if(Control.type == "hidden")
			{
				var SDate = Control.value;
				return new gxdate( SDate, "Y4MD");
			}
		}
		return new gxdate( GXgetControlValue(ControlId), gxdate.SFmt);
	}
	catch(e){}
	return "";
}

function GXgetIntegerValue( ControlId)
{
	var nIntVal = parseInt( GXgetControlValue( ControlId),10);
	return isNaN( nIntVal) ? 0:nIntVal;
}

function GXgetDecimalValue( ControlId, ThSep, DecPoint)
{
	var nDecVal = gxparseFloat( GXgetControlValue( ControlId), ThSep, DecPoint);
	return isNaN( nDecVal) ? 0:nDecVal;
}

function GXCtrlSum( ControlId, ThSep, DecPoint)
{
	gxControlStruct( ControlId).v2c();
	var GridId = gxControlGrid( ControlId);
	ControlId = GXCmpControlId( ControlId);
	retVal = 0;
	CellId = new String(ControlId + "_0000");
	for (var i=1; i < 999; i++) 
	{	
		CellCtrl = GXgetControlRef_impl( ControlId + '_' + gxrpadwc( i.toString(), 4, '0'));
		if (CellCtrl == null)
		{
			if (i == 1)
				throw "GXGridCtrlNotFound"
			break;
		}
		var IsRemoved = GXgetControlValue( "_GXREMOVE" + GridId + '_' + gxrpadwc( i.toString(), 4, '0'));
		if (IsRemoved != true)
			retVal += gxparseFloat( CellCtrl.value, ThSep, DecPoint);
	}
	return retVal;
}

function GXCtrlCount( ControlId)
{
	var GridId = gxControlGrid( ControlId);
	var Lvl = gxControlLvl( ControlId);
	ControlId = GXCmpControlId( ControlId);
	retVal = 0;
	CellId = new String(ControlId + "_0000");
	for (var i=1; i < 999; i++) 
	{	
		CellCtrl = GXgetControlRef_impl( ControlId + '_' + gxrpadwc( i.toString(), 4, '0'));
		if (CellCtrl == null)
		{
			if (i == 1)
				throw "GXGridCtrlNotFound"
			break;
		}
		var IsRemoved = GXgetControlValue( "_GXREMOVE" + GridId + '_' + gxrpadwc( i.toString(), 4, '0'));
		var RecordExists = GXgetControlValue( "nRcdExists_" + Lvl + '_' + gxrpadwc( i.toString(), 4, '0'));
		var RecordIsMod = GXgetControlValue( "nIsMod_" + Lvl + '_' + gxrpadwc( i.toString(), 4, '0'));
		if (IsRemoved != true && ( RecordExists == "1" || RecordIsMod == "1"))
			retVal += 1;
	}
	return retVal;
}

function GXsetCtrlProperty( ControlId, Property, PValue)
{
	Control = GXScreen_CtrlRef( ControlId);
	if (Control == null)
		return;
	gxsetCtrlProperty( Control, Property, PValue);
}

function GXsetGridCtrlProperty( ControlId, Property, PValue)
{
	Control = GXScreen_CtrlRef( ControlId);
	if (Control == null)
		return;
	gxsetCtrlProperty( Control, Property, PValue);
	var Cell = Control.parentElement;
	if (Cell.tagName != 'TD')
		return;
	gxsetCtrlProperty( Cell, Property, PValue);	
}

function gxDisplaybyType( NodeName)
{
	if (NodeName == 'TABLE' || NodeName == 'P'|| NodeName == 'DIV')
		return "block";
	return "inline";	
}

function gxsetCtrlProperty( Control, Property, PValue)
{
	if (Control == null)
		return;
	switch( Property)
	{	
		case "Tooltiptext":	Control.title = PValue;
			break;
		case "Visible":	Control.style.display = (PValue == 0)?"none":gxDisplaybyType( Control.nodeName);
			break;
		case "Enabled":	
			{
				if (Control.type == "hidden")
					return;
				gxpushElement( gxDisabledControls, Control, gxSafeId(Control));
				Control.gxusrdisabled = (PValue == 0);
				if (Control.gxdisabled)
				{
					if (Control.gxdisabled == true)
						Control.disabled = true;
					else
						Control.disabled = Control.gxusrdisabled;
				}
				else
					Control.disabled = Control.gxusrdisabled;
				break;
			}
		case "Link":	
				GXsetCtrlLink( Control, PValue);
				break;
		case "Backcolor":
				Control.style.backgroundColor = '#' + gxrpadwc( PValue.toString(16), 6, '0');
				break;
		case "Forecolor":
				Control.style.color = '#' + gxrpadwc( PValue.toString(16), 6, '0');
				break;
	}
}

function GXgetCtrlProperty( ControlId, Property)
{
	Control = GXScreen_CtrlRef( ControlId);
	if (Control == null)
		return;
	switch( Property)
	{	
		case "Tooltiptext":	return Control.title;
		case "Visible": return Control.style.visibility == "visible";
		case "Enabled": return (Control.disabled) ? 0:1;
		case "Backcolor": return css_color( Control.style.backgroundColor);
		case "Forecolor": return css_color( Control.style.color);
	}
}

function css_color( Color)
{
	if (Color.substring(0,3) == 'rgb')
		return eval(Color);
	return (Color.charAt(0) == '#') ? parseInt( Color.substring(1), 16) : 0;
}

function GXsetCtrlLink( Control, Link)
{
	if (Control == null)
		return;
	if (Link == "")
	{
		GXunsetCtrlLink( Control);
		return;
	}
	var ParentTag = Control.parentNode;
	if (ParentTag.tagName == "A")
		ParentTag.href = Link;
	else
	{
		var newA = document.createElement("A");
		newA.href = Link;
		ParentTag.replaceChild( newA, Control);
		newA.appendChild( Control);
	}	
}

function GXunsetCtrlLink( Control)
{
	if (Control == null)
		return;
	var ParentTag = Control.parentNode;
	if (ParentTag.tagName == "A")
	{
		var ChildNode = ParentTag.firstChild;
		ParentTag2 = ParentTag.parentNode;
		if (ParentTag2 != null)
		{
			while( ChildNode != null)
			{
				ParentTag2.insertBefore( ChildNode,ParentTag);
				ChildNode = ParentTag.firstChild;					
			}
			ParentTag2.removeChild( ParentTag);
		}
	}
}

function GXAssignPromptField( PNum, PValue)
{
	changed = true;
	change_control( PValue, opener.GXPARAMETERS[PNum].Ctrl)
	if (opener.GXPARAMETERS[PNum].Ctrl.value != PValue && opener.GXPARAMETERS[PNum].isKey)
		opener.GXPkIsDirty = true;
	opener.GXPARAMETERS[PNum].Ctrl.value = PValue; 
	var spanObj; 
	var spanChild; 
	spanObj = opener.document.getElementById( 'span_' + opener.GXPARAMETERS[PNum].Ctrl.name); 
	if(spanObj != null) 
	{	
		if(spanObj.childNodes.length == 0) 
			spanObj.appendChild( opener.document.createTextNode(""));
		spanChild = spanObj.childNodes[0]; 
		spanChild.nodeValue = PValue;
	}
}

function GXLastValidationControl()
{
	var LastCtrl = -1;
	for (i=0;i<=GXLastCtrlId();i++)
	{
		if (GXValidStruct(i) != undefined)
		{
			try
			{
				Control = GXgetControlGridRef( GXValidStruct(i).fld, GXValidStruct(i).grid);
				if (gxControlIsAccepted( Control))
					LastCtrl = i;
			}
			catch(e){}
		}			
	}
	return LastCtrl;
}

function gxVisible( Control)
{
	try
	{
		while (Control)
		{
			if ( Control.style && (Control.style.visibility == 'hidden' || Control.style.display == 'none'))
				return false;
			Control = Control.parentNode;
		}
	}
	catch( e) {}
	return true;
}

function gxRefreshVars( validStruct)
{
	for( var i=0;i<validStruct.ip.length;i++)
	{
		try	
		{
			GXValidStruct(validStruct.ip[i]).c2v();
		}
		catch(e){}
	}
}

function gxRefreshControls( validStruct)
{
	for( var i=0;i<validStruct.op.length;i++)
	{
		try
		{
			GXValidStruct(validStruct.op[i]).v2c();
		}catch(e){}
	}
}

function GXVC( Ctrl, i, bForceCheck)
{
	var validStruct = GXValidStruct(i);
	if (validStruct == undefined || validStruct.fnc == null)
		return true;
	try
	{
		var jsCode = '';
		if (i != -1 && (bForceCheck || (Ctrl.getAttribute( "gxvalid") != "1")))
		{
			gxRefreshVars( validStruct);
			var validRet = validStruct.fnc();
			gxRefreshControls( validStruct);
			if (validRet == false)
			{
				gxSetControlFocus( GXInvalidCtrl);
				return false;
			}
			if (gxControlIsAccepted( Ctrl))
				Ctrl.setAttribute( "gxvalid", "1");
			else
				Ctrl.setAttribute( "gxvalid", "0");
		}
	}
	catch(e){}
	return true;
}

function GXValidControls( FromControl, TargetControl, bForceCheck)
{
	var bRet = true;
	var bFailedCtrl = -1;
	try
	{
		GXInvalidCtrl = null;
		GXInvalidCtrlNum = 0;
		for (var i=FromControl;i<TargetControl;i++)
		{
			var validStruct = GXValidStruct(i);
			if (validStruct != undefined)
			{
				if (validStruct.grid != 0)
				{
					var GXValidRow = GXCurrentGridRow( validStruct.grid);
					if (GXValidRow != undefined)
						GXCurrentRow[validStruct.grid] = GXValidRow;
				}
				validStruct.c2v();
				if (validStruct.fnc != null)
				{
					try
					{
						if (validStruct.lvl == 0 || ( (validStruct.grid != 0) && GXGridRowIsMod( validStruct.lvl, GXCurrentGridRow( validStruct.grid))))
						{
							var Control = GXgetControlGridRef( validStruct.fld, validStruct.grid);
							var bValid = GXVC( Control, i, bForceCheck);
							if (!bValid && bRet)
							{	
								GXInvalidCtrl = Control;
								GXInvalidCtrlNum = i;
								bFailedCtrl = i;
								bRet = false;
							}
							if (gxControlIsAccepted( Control) == false)
							{
								gxExecuteOnBlur(i);
								
								if (Control.getAttribute( "gxhiddenonchange") != Control.value)
								{
									Control.setAttribute( "gxhiddenonchange", Control.value);
									gxExecuteOnChange( Control);
								}
							}
						}
					}
					catch(e){}
				}
			}
		}
		if ( bFailedCtrl != -1)
		{
			Control = GXgetControlGridRef( GXValidStruct(bFailedCtrl).fld, GXValidStruct(bFailedCtrl).grid);
			GXDisableFocus = true;
			if (gxControlIsAccepted(Control))
				gxSetControlFocus( Control);
			else
				gxSetControlFocus( GXLastEvtControl);
		}
	}
	catch (e){}
	return bRet;
}

function GXGridRowIsMod( Lvl, Row)
{
	var bRet;
	try
	{
		bRet = eval( "document.forms[0]." + GXWCP + "nIsMod_" + Lvl + "_" + Row + ".value == 1");
	}
	catch(e)
	{
		bRet = false;
	}
	return bRet;
}

function gxExecuteOnBlur(gxCurrentFocusControl)
{
	var gxLastFocusCtrl = GXLastFocusCtrl;
	var gxFocusCtrl = GXFocusCtrl;
	
	GXFocusCtrl = gxCurrentFocusControl;
	GXOnBlur(GXFocusCtrl);
	
	GXFocusCtrl = gxFocusCtrl;
	GXLastFocusCtrl = gxLastFocusCtrl;
}

function GXOnBlur(gxLastFocusCtrl)
{
	try
	{
		var GridId = GXValidStruct(GXFocusCtrl).grid;
		if (GridId != 0)
			eval( WCSV_ctx + 'SubfileToVariables'+GridId+'()');
		eval( WCSV_ctx + 'ControlsToVariables()');
	}catch(e){}

	GXLastFocusCtrl = gxLastFocusCtrl;
	try
	{
		var Elem = GXLastFocusCtrlRef;
		var MaxLength = Elem.getAttribute("maxlength");
		if ( MaxLength > 0 && Elem.value.length >= MaxLength)
			Elem.value = Elem.value.substring( 0, MaxLength)
	}
	catch(e){};
}

function GXValidLast()
{
	try
	{
		if (GXValidStruct(GXFocusCtrl).grid != 0)
			return;
	}
	catch(e){}	
	try
	{
		var LastValidationCtrl = GXLastValidationControl();
		if (LastValidationCtrl == GXFocusCtrl)
		{
			GXValidControls( LastValidationCtrl, LastValidationCtrl + 1, true)
		}
	}
	catch(e){}
}

function GXVF( evt)
{	
	try
	{
		GXValidControls( GXFromValid, GXToValid, true);
		if (GXInvalidCtrl == null)
			GXFromValid = GXToValid;			
	}
	catch(e){}
}

function GXVFTail( evt)
{	
	try
	{
		GXValidControls( GXFocusCtrl, GXLastCtrlId() + 1, true);
	}
	catch(e){}
}

function GXValidForm()
{
	var bRet = true;
	try
	{
		if (GXgetControlValue( "IsConfirmed") != "1" && document.forms[0]._EventName.value == "EENTER.")
			bRet = GXValidControls( 1, GXLastCtrlId() + 1, true);
	}
	catch(e){}
	if (bRet)
		ForceEnableControls();
	return bRet;
}

function ForceEnableControls()
{
	for( var Ctrl in gxDisabledControls)
	{
		Ctrl = GXgetControlRef_list( Ctrl);
		for( var i=0;i<Ctrl.length;i++)
		{
			try{
				if (Ctrl[i].type != 'button' && Ctrl[i].type != 'submit')
					Ctrl[i].disabled=false;
			}catch(e){}
		}
	}
}

var dbgwindow = null;
function writedbg( texto)
{
	try
	{
	if (dbgwindow == null)
		dbgwindow = window.open( "", "debug","height=900,width=250");
	dbgwindow.document.write( texto + '<BR>');
	}
	catch (e){}
	
}

function GXAlert( Ctrl, Message)
{
	try
	{
		gxballoon = getGXBallon(Ctrl.id);
		gxballoon.setError( Message);
		gxballoon.show();
		GXInvalidFrmtCtrl = Ctrl;
	}
	catch (e)
	{
		alert( Message);
	}
}

function GXAddGridRow( GridId, sRowCount)
{
	var Ctrl = GXgetControlRef( GridId);
	if (Ctrl == null)
		return;
	var Node = Ctrl.firstChild;
	var nRowCount = parseInt( GXgetControlValue( sRowCount),10) + 1;
	GXsetControlValue( sRowCount, nRowCount);
	var sNewRowId = gxrpadwc( nRowCount.toString(), 4, '0');
	while( Node != null)
	{
		if (Node.nodeName == "TBODY")
		{
			var firstRow = Node.firstChild;
			while( firstRow != null)
			{
				if ((firstRow.nodeName == "TR") && gxHasChild( firstRow, "TD"))
				{
					var newRow = firstRow.cloneNode( true);
					gxResetRowValues( newRow);
					Node.appendChild( newRow);
					//newRow.innerHTML = 	newRow.innerHTML.replace( /0001/g, sNewRowId);
					return;
				}
				firstRow = firstRow.nextSibling;
			}
		}
		Node = Node.nextSibling;
	}
}

function gxResetRowValues( Row)
{
	var TD= Row.firstChild;
	while( TD != null)
	{
		var Childs = TD.childNodes;
		for( var i=0;i<Childs.length;i++)
			gxClearControlValue( Childs[i]);
		TD = TD.nextSibling;	
	}
}

function gxHasChild( Control, nodeName)
{
	var child = Control.firstChild;
	while( child != null)
	{
		if (child.nodeName == nodeName)
			return true;
		child = child.nextSibling;
	}
	return false;
}

function gxGetGridRowMode( GXLvl, GridId)
{
	var CurrentRow = GXCurrentGridRow( GridId);
	var IsRemoved = GXgetControlValue( "_GXREMOVE" + GridId + "_" + CurrentRow);
	var RecordExists = GXgetControlValue( "nRcdExists_" + GXLvl + '_' + CurrentRow);
	if (RecordExists == "0")
		return "INS";
	if (IsRemoved == "1")
		return "DLT";
	return "UPD";
}

function gxonload()
{
	var LastActiveControl = window.document.activeElement;
	window.document.forms[0].reset();
	gxdelayedsuggest();
	if (GXUserFocus)
	{
		gxSetControlFocusOnload(GXUserFocus);
	}
	else
	{
		if (LastActiveControl && gxControlIsAccepted(LastActiveControl))
			gxSetControlFocusOnload(LastActiveControl);
		else
			gxSetControlFocusOnload(gxGetFirstAcceptedFormElement());
	}
	try{GXOnloadUsr()}catch(e){}
}

function gxdelayedsuggest()
{
	for ( var C=0;C<gxSuggestControls.length;C++)
		gxinstallsuggest(gxSuggestControls[C]);
}

function gxinstallsuggest(Ctrl)
{	
	var jsCode;
	if (document.readyState != undefined && document.readyState != "complete")
	{
		gxSuggestControls.push(Ctrl);
		return;
	}
	try
	{
		jsCode = Ctrl.attributes["gxsgprm"].value;
		if (jsCode != '')
		{
			var gxsgprm = eval( jsCode);
			gxajaxSuggest( gxsgprm[1], Ctrl.id, gxsgprm[0], gxsgprm[2]);
			Ctrl.removeAttribute("gxsgprm");
		}
	}catch(e){}
}


function gxChangeComponentContext()
{
	try{
		eval('this.'+ WCSV_ctx + 'SetStandaloneVars()')
	}catch(e){}
}

function gxonfocus(Ctrl, gxFocusCtrl, gxWCP, gxCurrentRow, gxCurrentGrid, gxAddLines)
{
	GXLastFocusCtrlRef = Ctrl;
	gxinstallsuggest(Ctrl);
	GXCurrentRow[gxCurrentGrid] = gxCurrentRow;
	var NewComponentContext = false;
	if (GXLastCurrentGrid != gxCurrentGrid)
	{
		if(!gxAddLines)
		{
			GXLastCurrentGrid = gxCurrentGrid;
			var firstGridCtrl = gxFirstGridControl( GXLastCurrentGrid);
			if(GXFromValid > firstGridCtrl)
				GXFromValid = firstGridCtrl;
		}
	}
	if (GXWCP != gxWCP)
	{
		NewComponentContext = true;
		GXFromValid = 0;
	}
	GXWCP = gxWCP;
	try
	{
		WCSV_ctx = Ctrl.attributes["gxctx"].value;
	}
	catch(e){WCSV_ctx = '_';}
	if (NewComponentContext)
		gxChangeComponentContext();
	GXFocusCtrl = gxFocusCtrl;
	if (GXDisableFocus)
	{
		GXDisableFocus = false;
		return true;
	}
	try
	{
		if (document.forms[0].Mode.value == 'DLT' || document.forms[0].Mode.value == 'DSP')
			return true;
		if (Ctrl.type == 'submit' && !gxIsEventEnterControl(Ctrl, gxWCP) && !gxAddLines)
			return true;	
	}
	catch(e){}

	if ( isGXTrn())
	{
		if(Ctrl.gxdisabled && GXLastFocusCtrlRef != null)
		{
			cn = gxSearchControlOnForm(Ctrl) + 1;
			if(cn != -1)
			{
				NextFocus = gxSearchNextFocus(cn);
				if(NextFocus != null)
				{
					gxSetControlFocus( NextFocus);
					return true;	
				}
			}
			gxSetControlFocus( GXLastFocusCtrlRef);
			return true;	
		}
	}
	
	if ( isGXTrn())
	{
		if (GXInvalidFrmtCtrl)
		{
			gxSetControlFocus( GXInvalidFrmtCtrl);
			GXInvalidFrmtCtrl = null;
			return true;	
		}
	}
	if (GXInvalidCtrl != null && GXInvalidCtrl != Ctrl && GXFocusCtrl >= GXInvalidCtrlNum)
	{
		if (GXInvalidCtrl == Ctrl && GXVC( GXInvalidCtrl, GXInvalidCtrlNum, false))
		{
			GXInvalidCtrl = null;
			return true;
		}
	}
	Ctrl.setAttribute( "gxvalid", "0");
	if(gxAddLines)
	{
		GXFromValid = gxFirstGridControl( GXLastCurrentGrid);
		GXToValid = gxFirstCtrlAfterGrid( GXFromValid, GXLastCurrentGrid);
		GXFocusCtrl = GXToValid;
	}
	else
	{
		GXToValid = GXFocusCtrl;
		if (GXFocusCtrl < GXFromValid)
		{
			GXFromValid = GXFocusCtrl;
		}
	}
	if(GXLastValidRow==undefined && gxCurrentGrid != 0)
		GXLastValidRow = gxCurrentRow;
	GXCheckRowChange( GXLastFocusCtrl);
	if ( GXFocusCtrl >= GXLastFocusCtrl)
		GXVF();
	else
		GXToValid = GXFocusCtrl;
	if (GXInvalidCtrl == null)
		gxSetControlSelection( Ctrl);
	return false;
}

function gxonchange(Ctrl) 
{ 	
	GXLastEvtControl = Ctrl;
	var CtrlValue = GXgetControlValue( gxSafeId(Ctrl));
	if (Ctrl.getAttribute( "gxoldvalue") != CtrlValue)
	{
		var jsCode = ''; 
		var bRet = true;
		if (Ctrl.type == "select-one" || Ctrl.type == "checkbox" || Ctrl.type == "radio")
		{
			if (GXVC( Ctrl, GXFocusCtrl, false))
			{
				if (GXInvalidCtrl == Ctrl)
					GXInvalidCtrl = null;
			}
			else
				bRet = false;
		}
		Ctrl.setAttribute( "gxoldvalue", CtrlValue);
		if (bRet)
			gxExecuteOnChange( Ctrl);
	}
	return gxExecuteUsrOnChange( Ctrl);
}

function gxExecuteUsrOnChange( Ctrl)
{	var jsCode = '';
	try{jsCode = Ctrl.attributes["gxoch0"].value;} 
	catch(e)
	{
		return true;
	}
	var fnc = new Function(jsCode);
	var ret = fnc.call();
	return ret;
}


function gxExecuteOnChange( Ctrl)
{
	var jsCode = ''; 
	try{jsCode += Ctrl.attributes["gxoch1"].value + ';';} catch(e){}
	if (gxControlIsAccepted( Ctrl))
		try{jsCode += Ctrl.attributes["gxoch2"].value + ';';} catch(e){}
	try
	{
		if (jsCode != '')
			eval( jsCode);
	}catch(e){}
	Ctrl.setAttribute( "gxvalid", "0");
	Ctrl.setAttribute( "gxctrlchanged", '1');
}

function gxSetControlFocus( Control)
{
	if (Control)
	{
		try
		{
			try{document.getElementById(Control.id).focus();}
			catch(e){Control.focus()}
			gxSetControlSelection( Control);
		}
		catch(e){}
	}
}


function GXSetUserFocus( Control)
{
	GXUserFocus = Control;
}

function gxSetControlFocusOnload( Control)
{
	if (Control)
	{
		try
		{
			if (gxControlIsAccepted( Control))
				gxSetControlFocus( Control);
		}
		catch(e){}
	}
}

function gxSetControlSelection( Control)
{
	if (Control)
	{
		try
		{
			if (Control.type == "text" || Control.type == "password" || Control.type == "file")
				Control.select();
			else if (Control.type == "textarea")
				Control.focus();
			else
				if( document.selection != undefined)
					document.selection.empty();
		}
		catch(e){}
	}
}

function gxControlIsAccepted( Control)
{ return (Control != null && Control.type != undefined && Control.type != "hidden" && gxVisible( Control) && Control.disabled == false && (Control.readOnly == null || Control.readOnly == false))}


var bGXAutoskip = false;
function form_onkeyup(domevent)
{
	var event = window.event?window.event:domevent;
	var evel = (event.target || event.srcElement);
	var maxlen = evel.getAttribute("maxlength");
	var value = typeof(evel.value)=="undefined"?"":evel.value;
	if ((evel.type == "" && GXLastKeyCode == 9) || ( bGXAutoskip && evel.type != "" && !isCtrlKeyCode( GXLastKeyCode) && value.length >= maxlen))
	{
		var el = gxSearchControlOnForm( GXInvalidCtrl?GXInvalidCtrl:GXLastFocusCtrlRef);
		if (el == -1)
			return true;
		var Control = gxSearchFocus( GXShiftPressed?el-1:el+1, !GXShiftPressed);
		gxSetControlFocus( Control);
	}
}

function gxEnterBtnHasFocus()
{
	GXLastFocusCtrlRef;
	if (GXLastFocusCtrlRef == null)
		return false;
	return GXLastFocusCtrlRef.type == 'submit' && GXLastFocusCtrlRef.name == 'BTN_ENTER';
}

function gxSkipFocus()
{
	var el = gxSearchControlOnForm( GXLastFocusCtrlRef);
	if (el == -1)
		return true;
	var Control;
	for (Control = gxSearchFocus( ++el, true);;Control = gxSearchFocus( ++el, true))
	{
		if (Control == null || el == document.forms[0].elements.length)
			el = -1;
		else
		{
			if (Control.type == 'submit' && Control.name == 'BTN_ENTER')
				break;
			if (Control.type != 'submit' && Control.type != 'button')
				break;
		}
	}
	gxSetControlFocus( Control);	
}

function gxSearchControlOnForm( Ctrl)
{
	var el = -1;
	for(var i=0;i<document.forms[0].elements.length;i++)
	{
		if (Ctrl == document.forms[0].elements[i])
		{
			el = i;
			break;
		}
	}	
	return el;
}

function gxSearchFocus( el, Forward)
{
	if ( Forward)
		return gxSearchNextFocus( el);
	return gxSearchPrevFocus( el);
}

function gxSearchPrevFocus( el)
{
	for(var i=el;i>=0;i--)
	{
		if (gxControlIsAccepted( document.forms[0].elements[i]))
			return document.forms[0].elements[i];
	}
	return null;
}

function gxSearchNextFocus( el)
{
	for(var i=el;i<document.forms[0].elements.length;i++)
	{
		if (gxControlIsAccepted( document.forms[0].elements[i]))
			return document.forms[0].elements[i];
	}
	return null;
}

function gxControlGrid( Fld)
{
	try
	{
		for (i=0;i<=GXLastCtrlId();i++)
		{
			if (GXValidStruct(i) != undefined && GXValidStruct(i).fld == Fld)
				return GXValidStruct(i).grid;
		}
	}
	catch(e){}
	return 0;
}

function gxGridLvl( GridId)
{
	try
	{
		for (i=0;i<=GXLastCtrlId();i++)
		{
			if (GXValidStruct(i) != undefined && GXValidStruct(i).grid == GridId)
				return GXValidStruct(i).lvl;
		}
	}
	catch(e){}
	return 0;
}


function gxControlLvl( Fld)
{
	var GridId = 0;
	try
	{
		for (i=0;i<=GXLastCtrlId();i++)
		{
			if (GXValidStruct(i) != undefined && GXValidStruct(i).fld == Fld)
			{
				GridId = GXValidStruct(i).lvl;
				break;
			}
		}
	}
	catch(e){}
	return GridId;
}

function gxOld( Fld, Var)
{
	try
	{
		var Control = GXgetControlGridRef( Var, gxControlGrid( Fld));
		var ctrlId = gxSafeId( Control);
		if (GXOldValue[ctrlId] == null)
		{
			if (Control != null)
				GXOldValue[ctrlId] = Control.value;
		}
		return GXOldValue[ctrlId];
	}
	catch(e){}
	return '';
}

function gxControlStruct( CtrlId)
{
	try
	{
		for (i=0;i<=GXLastCtrlId();i++)
		{
			if (GXValidStruct(i) != undefined && GXValidStruct(i).fld == CtrlId)
			{
				return GXValidStruct(i);
			}
		}
	}
	catch(e){}
	return null;
}

function gxControlStructForVar( GXVarName)
{
	try
	{
		for (i=0;i<=GXLastCtrlId();i++)
		{
			if (GXValidStruct(i) != undefined && GXValidStruct(i).gxvar == GXVarName)
			{
				return GXValidStruct(i);
			}
		}
	}
	catch(e){}
	return null;
}

function gxFirstCtrlAfterGrid(fromCtrl, gridId)
{
	var lastCtrl = GXLastCtrlId();
	for(var i=fromCtrl; i<lastCtrl; i++)
	{
		var validStruct = GXValidStruct(i);
		if(validStruct != undefined && validStruct.grid != gridId)
			return i;
	}
	return lastCtrl;
}

function gxSafeId( Control)
{
	return ((Control.id == undefined || Control.id == '')? Control.name : Control.id);
}

function gxOldKey( Fld)
{
	try
	{
		return GXOldKeyValue[Fld];
	}
	catch(e){}
	return '';
}

function gxOldGridKey( Fld, GridId)
{
	try
	{
		return GXOldKeyValue[Fld + GXCurrentGridRow( GridId)];
	}
	catch(e){}
	return '';
}


function gxOldInteger( Fld, Var)
{	
	var nIntVal = parseInt( gxOld( Fld, Var),10);
	return isNaN( nIntVal) ? 0:nIntVal;
}

function gxOldDecimal( Fld, Var)
{
	var nDecVal = gxparseFloat( gxOld( Fld, Var), gxThSep, gxDecPoint);
	return isNaN( nDecVal) ? 0:nDecVal;
}

function gxSetKey( Fld, Var)
{
	if (Control != null)
	{
		var sAssignCode = 'GXOldKeyValue["' + Fld +'"]=' + Var ;
		eval( sAssignCode);
	}
}

function gxUnsetSetKey( Fld)
{
	if (Control != null)
	{
		var sAssignCode = 'GXOldKeyValue["' + Fld +'"]=undefined' ;
		eval( sAssignCode);
	}
}

function gxSetGridKey( Fld, GridId, Var)
{
	if (Control != null)
	{
		var sAssignCode = 'GXOldKeyValue["' + Fld + GXCurrentGridRow( GridId) +'"]=' + Var ;
		eval( sAssignCode);
	}
}

function gxUnsetSetGridKey( Fld, GridId)
{
	if (Control != null)
	{
		var sAssignCode = 'GXOldKeyValue["' + Fld + GXCurrentGridRow( GridId) +'"]=undefined' ;
		eval( sAssignCode);
	}
}

function gxSetOld( Fld, Ctrl, Var)
{
	var Control = GXgetControlGridRef( Ctrl, gxControlGrid( Fld));
	if (Control != null)
	{
		var ctrlId = gxSafeId( Control);
		var sAssignCode = 'GXOldValue["' + ctrlId + '"]=' + Var ;
		eval( sAssignCode);
	}
}

function gxRmvGridRow(CurrentRow, GridId)
{
	var IsRemoved = GXgetControlValue( "_GXREMOVE" + GridId + "_" + CurrentRow);
	try
	{
		for (i=0;i<=GXLastCtrlId();i++)
		{
			if ( GXValidStruct(i) != undefined && GXValidStruct(i).grid == GridId)
			{
				var Ctrl = GXgetControlRef_impl( GXValidStruct(i).fld + "_" + CurrentRow);
				if (Ctrl != null && !gxIsGxRemove(Ctrl))
				{
					Ctrl.gxdisabled = IsRemoved;
				}
			}
		}
	}
	catch(e){}
	gxValidGridRow( GridId, CurrentRow);
}

function gxIsGxRemove( Ctrl)
{
	if(Ctrl != null)
		return (Ctrl.name.indexOf("_GXREMOVE") != -1);
	return false;
}

function gxIsEventEnterControl(Ctrl, gxWCP)
{
	var eventAtt = Ctrl.attributes["gxevent"];
	if(eventAtt)
		return (eventAtt.value == (gxWCP+'EENTER.'));
	return false;
}

function gxArrayToSource( Arr)
{
	if (Arr.toSource != null)
		return Arr.toSource();
	var Result = "[";
	var size = Arr.length - 1;
	for (var i in Arr)
	{
		Result += gxObjectToSource(Arr[i]);
		if (i < size)
			Result += ',';
    }
	Result += ']';
	return Result;
}

function gxObjectToSource( Obj)
{
	if (typeof( Obj) == "object")
	{
		var Result = '{';
		var Sep = '';
   		for (var i in Obj)
   		{
      		Result += Sep;
      		Result += i + ":\'" + gxEncodeValue(Obj[i]) + "\'";
      		Sep = ',';
      	}
      	Result += '}';
   		return Result;
	}
	return '\'' + gxEncodeValue(Obj.toString()) + '\'';
}

function gxFormat()
{
	var msg = arguments[0];
	for (var i=1;i<arguments.length; i++)
		msg = msg.replace( '%'+i, gxtrim(arguments[i].toString()));
	return msg;
}

function gxNewLine()
{
	return '<BR>';	
}

function gxtostring( str)
{
	return str.toString();	
}
function gxtoformattedstring( str)
{
	return str;	
}

function gxSubmit()
{
	ForceEnableControls();
	document.forms[0].submit();
}

function isGXTrn()
{
	return typeof(ClearNonKeyFields) != 'undefined';
}

function GXValidStruct(Ctrl)
{
	try
	{
		return eval('this.'+ WCSV_ctx + 'GXValidFnc['+Ctrl+']')
	}
	catch(e){}
	return undefined;
}

function GXLastCtrlId()
{
	try
	{
		return eval('this.'+ WCSV_ctx + 'GXLastCtrlId')
	}
	catch(e){}
	return undefined;
}

function gxGetFormElements()
{
	return this[WCSV_ctx + 'GXValidFnc'];
}

function gxGetFirstAcceptedFormElement()
{
	try
	{
		var Elements = gxGetFormElements();
		for( var i=0;i<Elements.length;i++)
		{
			var Element = Elements[i];
			if (Elements[i] != null)
			{
				if ( Elements[i].lvl != 0)
					break;
				if (gxControlIsAccepted( GXgetControlRef( Elements[i].fld)))
					return Control;
			}
		}
	}
	catch(e){}
	return null;
}

function GXCtrlSerial( LastCountAtt, CountAtt , GridId , Inc )
{
	var CurrentRow = GXCurrentGridRow( GridId);
	var RowMode = gxGetGridRowMode( gxGridLvl( GridId), GridId)
	if (RowMode != 'INS' || gxgetNewRow( GridId, CurrentRow) == false)
		return eval(LastCountAtt);
	gxsetNewRow( GridId, CurrentRow, false);	
	sAssignCode = CountAtt + '=' + LastCountAtt + '+' + Inc;
	eval( sAssignCode);
	return eval(CountAtt);
}

function gxsetNewRow( GridId, GXValidRow, state)
{
	if (GXNewRow[GridId] == null)
		GXNewRow[GridId] = new Array();
	GXNewRow[GridId][GXValidRow] = state;
}

function gxgetNewRow( GridId, GXValidRow)
{
	try
	{
		return GXNewRow[GridId][GXValidRow];
	}
	catch(e)
	{
		return true;
	}
}

function GXDisableCtrl(ControlId)
{
	var Control = GXgetControlRef_list( ControlId);
	if (Control == null)
		return;
	for( var i=0;i<Control.length;i++)
		gxsetCtrlProperty( Control[i], "Enabled", 0);
}