var HelpWin = null;
var ServiceWin = null;
var lastOpenHelpTime = 0;

var thisIFrameWidth = 0;
var thisIFrameHeight = 0;

//-----------------------------------------------------------------------------
function seeObj(obj)
	{
	for (var i in obj)
		document.write(i + ' = ' + obj[i] + '<br>');
	}
	
//-----------------------------------------------------------------------------
function resizeWindow(newWidth, newHeight)
	{
    try
        {
		if (window.opener)
			{
			// e' un popup quello che si deve ridimensionare
			window.innerWidth = newWidth;
			window.innerHeight = newHeight;
			}
		else if (window.parent)
			{
			// e' un iframe quello che si deve ridimensionare
			// di fatto, senza la chiamata a questa funzione l'iframe non 
			// e' visibile...
			var mamma = window.parent;
			var iframe = mamma.document.getElementById(window.name);
			if (iframe)
				{
				iframe.width = thisIFrameWidth = newWidth;
				iframe.height = thisIFrameHeight = newHeight;
				iframe.scrolling = 'auto';
				}
			// ridimensioniamo tutti gli iframe contenitori
			var nonna = mamma.parent;
			while (nonna != mamma)
				{
				iframe = nonna.document.getElementById(mamma.name);
				if (iframe)
					{
					iframe.scrolling = 'no';
					iframe.width = newWidth;
					iframe.height = newHeight;
					mamma = nonna;
					nonna = mamma.parent;
					}
				else
					break;
				}
			}
		}
	catch(exception)
		{
		}
	}
	
//-----------------------------------------------------------------------------
function closeServiceWin(win)
{
		
    if (win != null)
        {
        try
	        {
			if (win.opener)
				{
				// e' un popup quello che si deve chiudere
		       	if (!win.closed)
		                win.close();
				}
			else if (win.parent)
				{
				// e' un iframe quello che si deve chiudere
				var mamma = win.parent;
				win.document.location.href = "about:blank";
				var iframe = mamma.document.getElementById(win.name);
				if (iframe)
					{
					// nascondiamo l'iframe corrente (lo mettiamo a 1 per
					// fregare le scrollbars di msie)
					iframe.width = 1;
					iframe.height = 1;
					if (iframe.className.indexOf('_hidden') == -1)
						iframe.className += '_hidden';
					
					var nonna = mamma.parent;
					if (nonna != mamma)
						{
						// l'iframe in chiusura era figlio di un altro iframe;
						// gli restituiamo il suo size
						iframe = nonna.document.getElementById(mamma.name);
						if (iframe)
							{
							iframe.width = mamma.thisIFrameWidth;
							iframe.height = mamma.thisIFrameHeight;
							iframe.scrolling = 'auto';

							// finche' ci sono iframe genitori di quello che sta
							// per andare on top, li ridimensioniamo allo stesso
							// size di quello che sta per andare on top
							mamma = nonna;
							nonna = mamma.parent;
							var parentiframe;
							while (nonna != mamma)
								{
								parentiframe = nonna.document.getElementById(mamma.name);
								if (parentiframe)
									{
									parentiframe.scrolling = 'no';
									parentiframe.width = iframe.width;
									parentiframe.height = iframe.height;
									mamma = nonna;
									nonna = mamma.parent;
									}
								else
									break;
								}
							}
						}
					}
				}
	        }
		catch(exception)
			{
			}
        }
}

//-----------------------------------------------------------------------------
function openServiceWin(target)
	{
	if (document.getElementById('serviceiframe'))
		return openServiceIFrame(target);

	var winW = arguments[1];
	var winH = arguments[2];
	if (!winW) winW = 660;
	if (!winH) winH = 700;
	
	closeServiceWin(ServiceWin);
	ServiceWin = window.open(target,"",
							"width=" + winW +
							",height=" + winH +
							",bgcolor=white,scrollbars=yes,resizable=yes,status=yes");
	}
	
//-----------------------------------------------------------------------------
function openServiceIFrame(target)
	{
	// questa funzione carica il documento nell'iframe, ma di fatto non lo
	// rende visibile (width e height restano ancora uguali 0); il ridimen-
	// sionamento avviene mediante chiamata a resizeWindow; in questo modo
	// le form possono ridimensionarsi correttamente dopo che hanno calcolato
	// le proprie dimensioni;
	// l'effetto collaterale e' che bisogna chiamare la resizeWindow anche
	// per quelle tabelle che si aprono in iframe (tipicamente per una ricerca
	// di un elemento)
	var serviceIFrame = document.getElementById('serviceiframe');
	serviceIFrame.className='serviceiframe';
	serviceIFrame.style.top = getDocumentVerticalOffset()  + 'px';
    if (serviceIFrame.contentWindow)
   		serviceIFrame.contentWindow.document.location.href = target;
    else if (document.all)
		document.all.serviceiframe.src=target;  

    }
    
//-----------------------------------------------------------------------------
function ChiudiUnaFinestra(win)
	{
	// mantenuta per compatibilita' all'indietro (non so francamente di che...)
	closeServiceWin(win);
	}
		
//-----------------------------------------------------------------------------
function Helpa(page, field, maxLen)
	{
	var title = '';
	var elems;
	var pagehdr = document.getElementById('PageHdr');
	if (pagehdr)
		{
		elems = pagehdr.innerHTML.split(">", 2);
		if (elems[1])
			elems = elems[1].split("<", 2);
		title = elems[0];
		}
		
	var qs = '?page=' + encodeBase64(page) + '&title=' + encodeBase64(title);
	
    if (field)
        {
        if (field != '')
        	{
        	var type = '';
        	var label = '';
        	var mandatory = '';
        	for (var i = 0; i < formFields.length; i++)
        		{
        		if (field == formFields[i].name)
        			{
        			type = formFields[i].type;
        			label = formFields[i].label;
        			mandatory = formFields[i].mandatory ? '1' : '0';
        			break;
        			}
    			}
            qs += '&field=' + field + 
    				"&label=" + label + 
    				"&maxlen=" + maxLen +
    				"&mandatory=" + mandatory + 
    				"&type=" + type;
        	}
        }
    WhereToGo = helpPage + qs;

	if (document.getElementById('helpiframe'))
		return openHelpIFrame(WhereToGo);
    closeServiceWin(HelpWin);
    HelpWin = window.open(WhereToGo,"Help","width=400,height=230,bgcolor=white,scrollbars=yes,resizable=yes");
	}

//-----------------------------------------------------------------------------
function StdDocLoad (FocusOnFirstControl)
{
	var firstControlType = '';
	if (document.forms.length && FocusOnFirstControl)
		{
		if (document.forms[0].elements[0].type)
			{
			for (cntr = 0; cntr < document.forms[0].elements.length; cntr++)
				{
				if (document.forms[0].elements[cntr].type.toLowerCase() != 'hidden' &&
					document.forms[0].elements[cntr].style.visibility.toLowerCase() != 'hidden' &&
					(!document.forms[0].elements[cntr].disabled))
					{
					firstControlType = document.forms[0].elements[cntr].type.toLowerCase()
					if (firstControlType == 'button')
						continue;
					if (firstControlType != 'select-one')
						document.forms[0].elements[cntr].focus();
					break;
					}
				}
			}
		}
}

//-----------------------------------------------------------------------------
function StdDocUnload()
{
	closeServiceWin(HelpWin);
	closeServiceWin(ServiceWin);
}

//-----------------------------------------------------------------------------
// deserializza i parametri di una finestra child
function getChildJobParams(whatHaveChildDone)
	{
	var childJob = decodeBase64(whatHaveChildDone);
	var elems = childJob.split("|||");
	var param;
	var toRet = new Array();
	for (var i = 0; i < elems.length; i++)
		{
		 param = elems[i].split("=", 2);
		 if (param[0] != "")
		 	toRet[param[0]] = param[1];
		}
	return toRet;
	}

//-----------------------------------------------------------------------------
// funzioni per base 64 - urlencode...
function urlDecode(str){
    str=str.replace(new RegExp('\+','g'),' ');
    return unescape(str);
}
//-----------------------------------------------------------------------------
function urlEncode(str){
    str=escape(str);
    str=str.replace(new RegExp('\+','g'),'%2B');
    return str.replace(new RegExp('%20','g'),'+');
}

//-----------------------------------------------------------------------------
var END_OF_INPUT = -1;

var base64Chars = new Array(
    'A','B','C','D','E','F','G','H',
    'I','J','K','L','M','N','O','P',
    'Q','R','S','T','U','V','W','X',
    'Y','Z','a','b','c','d','e','f',
    'g','h','i','j','k','l','m','n',
    'o','p','q','r','s','t','u','v',
    'w','x','y','z','0','1','2','3',
    '4','5','6','7','8','9','+','/'
);

var reverseBase64Chars = new Array();
for (var i=0; i < base64Chars.length; i++){
    reverseBase64Chars[base64Chars[i]] = i;
}

var base64Str;
var base64Count;

//-----------------------------------------------------------------------------
function setBase64Str(str){
    base64Str = str;
    base64Count = 0;
}
//-----------------------------------------------------------------------------
function readBase64(){    
    if (!base64Str) return END_OF_INPUT;
    if (base64Count >= base64Str.length) return END_OF_INPUT;
    var c = base64Str.charCodeAt(base64Count) & 0xff;
    base64Count++;
    return c;
}
//-----------------------------------------------------------------------------
function encodeBase64(str){
    setBase64Str(str);
    var result = '';
    var inBuffer = new Array(3);
    var lineCount = 0;
    var done = false;
    while (!done && (inBuffer[0] = readBase64()) != END_OF_INPUT){
        inBuffer[1] = readBase64();
        inBuffer[2] = readBase64();
        result += (base64Chars[ inBuffer[0] >> 2 ]);
        if (inBuffer[1] != END_OF_INPUT){
            result += (base64Chars [(( inBuffer[0] << 4 ) & 0x30) | (inBuffer[1] >> 4) ]);
            if (inBuffer[2] != END_OF_INPUT){
                result += (base64Chars [((inBuffer[1] << 2) & 0x3c) | (inBuffer[2] >> 6) ]);
                result += (base64Chars [inBuffer[2] & 0x3F]);
            } else {
                result += (base64Chars [((inBuffer[1] << 2) & 0x3c)]);
                result += ('=');
                done = true;
            }
        } else {
            result += (base64Chars [(( inBuffer[0] << 4 ) & 0x30)]);
            result += ('=');
            result += ('=');
            done = true;
        }
        lineCount += 4;
        if (lineCount >= 76){
            result += ('\n');
            lineCount = 0;
        }
    }
    return result;
}
//-----------------------------------------------------------------------------
function readReverseBase64(){   
    if (!base64Str) return END_OF_INPUT;
    while (true){      
        if (base64Count >= base64Str.length) return END_OF_INPUT;
        var nextCharacter = base64Str.charAt(base64Count);
        base64Count++;
        if (reverseBase64Chars[nextCharacter]){
            return reverseBase64Chars[nextCharacter];
        }
        if (nextCharacter == 'A') return 0;
    } 
}

//-----------------------------------------------------------------------------
function ntos(n){
    n=n.toString(16);
    if (n.length == 1) n="0"+n;
    n="%"+n;
    return unescape(n);
}

//-----------------------------------------------------------------------------
function decodeBase64(str){
    setBase64Str(str);
    var result = "";
    var inBuffer = new Array(4);
    var done = false;
    while (!done && (inBuffer[0] = readReverseBase64()) != END_OF_INPUT
        && (inBuffer[1] = readReverseBase64()) != END_OF_INPUT){
        inBuffer[2] = readReverseBase64();
        inBuffer[3] = readReverseBase64();
        result += ntos((((inBuffer[0] << 2) & 0xff)| inBuffer[1] >> 4));
        if (inBuffer[2] != END_OF_INPUT){
            result +=  ntos((((inBuffer[1] << 4) & 0xff)| inBuffer[2] >> 2));
            if (inBuffer[3] != END_OF_INPUT){
                result +=  ntos((((inBuffer[2] << 6)  & 0xff) | inBuffer[3]));
            } else {
                done = true;
            }
        } else {
            done = true;
        }
    }
    return result;
}

//-----------------------------------------------------------------------------
var digitArray = new Array('0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f');
function toHex(n){
    var result = ''
    var start = true;
    for (var i=32; i>0;){
        i-=4;
        var digit = (n>>i) & 0xf;
        if (!start || digit != 0){
            start = false;
            result += digitArray[digit];
        }
    }
    return (result==''?'0':result);
}

//-----------------------------------------------------------------------------
function pad(str, len, pad){
	str = str + '';
    var result = str;
    for (var i=str.length; i<len; i++){
        result = pad + result;
    }
    return result;
}

//-----------------------------------------------------------------------------
function rPad(str, len, pad)
	{
	str = str + '';
    var result = str;
    for (var i=str.length; i<len; i++)
        result = result + pad;
    return result;
	}

//-----------------------------------------------------------------------------
function encodeHex(str){
    var result = "";
    for (var i=0; i<str.length; i++){
        result += pad(toHex(str.charCodeAt(i)&0xff),2,'0');
    }
    return result;
}

//-----------------------------------------------------------------------------
function decodeHex(str){
    str = str.replace(new RegExp("s/[^0-9a-zA-Z]//g"));
    var result = "";
    var nextchar = "";
    for (var i=0; i<str.length; i++){
        nextchar += str.charAt(i);
        if (nextchar.length == 2){
            result += ntos(eval('0x'+nextchar));
            nextchar = "";
        }
    }
    return result;
    
}

//-----------------------------------------------------------------------------
function checkEstemporanee()
	{
	if (document.location.search.indexOf("&sw=") != -1)
		{
		var params = document.location.search.split("&");
		for (var i=0; i < params.length; i++)
			{
			elems = params[i].split("=", 2);
			if (elems[0] == "sw")
				openServiceWin(decodeBase64(elems[1]));
			}
		}
	}

//-----------------------------------------------------------------------------
function getCurrentRecId(paramName)
	{
	var i;
	var elems = document.forms['frmlista'].elements;
	var ctrl;
	var id = 0;
	for (i = 0; i < elems.length; i++)
		{
		ctrl = elems[i];
		if (ctrl.name.substr(0, ('chk').length)  == 'chk')
			{
			if (ctrl.value == 1)
				{
				id = ctrl.name.substr(('chk').length);
				return "&" + paramName + "=" + id;
				}
			}
		}
	return '';
	}
	
		
//-----------------------------------------------------------------------------
function checkMailAdrress(address)
	{
	//var emailPattern = /^(\w+(?:\.\w+)*)@((?:\w+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i;
	var emailPattern = /^[\w-\.]{1,}\@([\da-zA-Z-]{1,}\.){1,}[\da-zA-Z-]{2,4}$/i;
	if (!emailPattern.test(address.value))
		{
		address.value = '';
		alert('Attenzione: indirizzo email non corretto!');
		}
	}
	
//-----------------------------------------------------------------------------
// funzioncelle per posizionamento mouse
// Detect if the browser is IE or not.
// If it is not IE, we assume that the browser is NS.
var IE = document.all?true:false;

// If NS -- that is, !IE -- then set up for mouse capture
if (!IE) document.captureEvents(Event.MOUSEMOVE);

// Set-up to use getMouseXY function onMouseMove
document.onmousemove = getMouseXY;

// Temporary variables to hold mouse x-y pos.s
var mousex = 0;
var mousey = 0;
var cacca = null;

// Main function to retrieve mouse x-y pos.s

function getMouseXY(e) {
  if (IE) { // grab the x-y pos.s if browser is IE
    mousex = event.clientX + document.body.scrollLeft
    mousey = event.clientY + document.body.scrollTop
  } else {  // grab the x-y pos.s if browser is NS
    mousex = e.pageX
    mousey = e.pageY
    return true;
  }  
}    
    
//-----------------------------------------------------------------------------
function openHelpIFrame(target)
	{
	try
		{
		// ox e oy vengono definite in overlib.js, che 
		// ricopre la nostra onmousemove!!!
		mousex = ox;
		mousey = oy;
		}
	catch (exception)
		{
		}
	var helpIFrame = document.getElementById('helpiframe');
    if (helpIFrame.contentWindow)
   		helpIFrame.contentWindow.document.location.href = target;
    else if (document.all)
		document.all.helpiframe.src=target;  
	helpIFrame.className='helpiframe';
	helpIFrame.style.left = mousex + 'px'; 
	helpIFrame.style.top = mousey + 'px';
	lastOpenHelpTime = (new Date()).getTime();
    }

//-----------------------------------------------------------------------------
function chiudiHelp()
	{
	if ((new Date()).getTime() - lastOpenHelpTime < 300)
		return;
	var iframe = document.getElementById('helpiframe');
	if (iframe)
		{
		if (iframe.className.indexOf('_hidden') == -1)
			iframe.className += '_hidden';
		iframe.width = 0;
		iframe.height = 0;
		iframe.contentWindow.document.location.href = "about:blank";
		}
	}
	
//-----------------------------------------------------------------------------
function removeFilter()
	{
	var qs = document.location.search;
	qs = qs.substr(1);
	var prms = qs.split('&');
	var elems;
	var newqs = '';
	for (var i = 0; i < prms.length; i++)
		{
		elems = prms[i].split('=');
		if (elems[0] != 'watbl_params' && elems[0] != '')
			newqs += "&" + elems[0] + "=" + (elems[1] ? elems[1] : '');
		}
	
	if (newqs != '')
		newqs = "?" + newqs.substr(1);
	document.location.href = document.location.protocol + '//' +
					document.location.host +
					document.location.pathname +
					newqs;
	}

//-------------------------------------------------------------------------
function stdSelect_Change(ctrl)
	{
	if (document.forms[0].elements['cmdMod' + ctrl.name])
		{
		if (ctrl.value == '')
			waform_disableField('cmdMod' + ctrl.name);
		else
			waform_enableField('cmdMod' + ctrl.name);
		}
	}
	
//-------------------------------------------------------------------------
function stdSelect_cmdNew_Click(remoteForm)
	{
	openServiceWin(remoteForm);
	}
	
//-------------------------------------------------------------------------
function stdSelect_cmdMod_Click(remoteForm, fldName, relKeyFldName)
	{
	var target = remoteForm +
				"&" + relKeyFldName + "=" + document.forms[0].elements[fldName].value;
	openServiceWin(target);
	}
	
//-------------------------------------------------------------------------
function stdSelect_reload(whatHaveChildDone, fldName)
	{
	waform_emptySelectX(fldName);
	
	var childJobParams = getChildJobParams(whatHaveChildDone);
	var ID = childJobParams[fldName];
	if (ID == '')
		ID = childJobParams['insertId'];
	var esito = waform_callRPCX("reload_" + fldName);
	if (esito == waform_rpc_error)
		return false;
		
	var ctrl = document.forms[0].elements[fldName];
	waform_fillSelectX(ctrl, esito, ID);			
	stdSelect_Change(ctrl);									
	}
	
//-------------------------------------------------------------------------
function getDocumentVerticalOffset()
	{
	var y = 0;
	try
		{
		if (document.documentElement && document.documentElement.scrollTop)
			y = document.documentElement.scrollTop;
		else if (document.body && document.body.scrollTop)
			y = document.body.scrollTop;
		else if (window.pageYOffset)
			y = window.pageYOffset;
		}
	catch(exception){}
	return y;
	}

//-------------------------------------------------------------------------
// La classica delle funzioni di sincronizzazioni che una finestra child 
// chiama per far si che la mamma si sincronizzi; nel caso piu' semplice
// (questo), praticamente si ricarica. se avete bisogno di qualcosa di
// piu' complesso, definite una vostra "syncfunc"
function childWinPleaseCallMe(whatHaveChildDone)
	{
	// in caso di ricaricamento di finestra a causa di inserimento/modifica record
	// non dobbiamo chiudere  ne' la finestra di help, ne' quella service, quindi
	// dobbiamo ridefinire l'evento onUnload del documento
	if (document.layers)
		window.captureEvents(Event.ONUNLOAD);
	window.onunload = '';

	// ricarichiamo la finestra... sarebbe facile fare una reload; e invece no
	// perche' senno' il browser ci chiede l'autorizzazione in caso di precedente
	// submit. 
	// gia' che ci siamo, togliamo anche un eventuale parametro &sw=, che
	// in caso di ricaricamento della pagina farebbe ripartire la service win
	// definita da &sw=
	// OCCHIO! si perdono eventuali parametri POST! se servono, fatevi 
	// una syncfunc apposta
	var qs = '';
	if (document.location.search.length)
		{
		var kv = new Array();
		var coppie = (document.location.search.substr(1)).split('&');
		for (var i = 0; i < coppie.length; i++)
			{
			kv = coppie[i].split('=');
			if (kv[0] != 'sw' && kv[0] != 'waappy')
				qs += (qs == '' ? '?' : '&') + kv[0] + "=" + (kv[1] ? kv[1] : '');
			}
		}
		
	qs += (qs == '' ? '?' : '&') + 'waappy=' + getDocumentVerticalOffset();
	document.location.href = document.location.pathname + qs;
	}