function refreshvideo() { var vidDivBorder = document.getElementById('flash_video').style.border; if(vidDivBorder == '0px solid rgb(0, 0, 0)'){ document.getElementById('flash_video').style.border = "0px solid rgb(255, 0, 255)"; } else{ document.getElementById('flash_video').style.border = "0px solid rgb(0, 0, 0)"; }

}

/**
    @returns Browserio pavadinimo trumpini (moz/ie).
    @type bool
    @deprecated
*/
function detectMacXFF2() {
  var userAgent = navigator.userAgent.toLowerCase();
  if (/firefox[\/\s](\d+\.\d+)/.test(userAgent)) {
    var ffversion = new Number(RegExp.$1);
    if (ffversion < 3 && userAgent.indexOf('mac') != -1) {
      return true;
    }
  }
}
function detectB()
{
	bname = navigator.appName
	if (bname.indexOf("Netscape") != -1)return('moz');
	if (bname.indexOf("Microsoft") != -1)return('ie');
}
//---------------------------------------------------------------------
/** Parodo ar naudojamas browseris yra Internet Explorer */
var cIE = false;
/** Parodo ar naudojamas browseris yra Mozilla FireFox */
var cFF = false;
if(navigator.appName.indexOf('Netscape') != -1)cFF = true;
if(navigator.appName.indexOf('Explorer') != -1)cIE = true;
//---------------------------------------------------------------------
/** Kelias iki ajax serverio. */
cSERVER = 'server.php';

var objEditor2 = null;
var g_blnShowConsole = true;
var g_blnJsWindowOpened = false; // Konstanta reikalinga patikrinti ar atidarytas js langas
//---------------------------------------------------------------------
/** Reiksme kuria grazinam i sena langa*/
var _ret = null;
/** Reiksme kuria perduodam i nauja langa*/
var _val = null;
/** Funkcija kuria kviesim senajame lange noredami pranest jog perduodami duomenys is vaikinio lango (perduodamas hashas)*/
var _fReturn = null;
/** Funkcija kuria kviesim senajame lange noredami pranest jog langas uzsikrove*/
var _fOnChildLoad = null;
/** Funkcija kuria kviesim senajame lange noredami pranest jog langas uzdaromas*/
var _fOnChildUnload = null;
//---------------------------------------------------------------------
/**
    Leidzia ivykiui priskirti funkcija, kuri neleakintu
    http://laurens.vd.oever.nl/weblog/items2005/closures/
    @Brought to you by: KM :)
    @Version 1 2006.10.20
*/
Function.prototype.closure = function(obj)
{
  // Init object storage.
  if (!window.__objs)
  {
    window.__objs = [];
    window.__funs = [];
  }

  // For symmetry and clarity.
  var fun = this;

  // Make sure the object has an id and is stored in the object store.
  var objId = obj.__objId;
  if (!objId)
    __objs[objId = obj.__objId = __objs.length] = obj;

  // Make sure the function has an id and is stored in the function store.
  var funId = fun.__funId;
  if (!funId)
    __funs[funId = fun.__funId = __funs.length] = fun;

  // Init argument storage.
  if (!obj.__args)
    obj.__args = [];

  // See if we previously created a closure for this object/function pair.
  obj.__args[funId] = [];
  for (var i = 1, intLength = arguments.length; i < intLength; i++)
  {
    obj.__args[funId].push(arguments[i]);
  }
  // Init closure storage.
  if (!obj.__closures)
    obj.__closures = [];

  // See if we previously created a closure for this object/function pair.
  var closure = obj.__closures[funId];
  if (closure)
    return closure;

  // Clear references to keep them out of the closure scope.
  obj = null;
  fun = null;

  // Create the closure, store in cache and return result.
  return __objs[objId].__closures[funId] = function (p_objEvent)
  {
    if (ftypeof(p_objEvent) == 'event')// instanceof Event)
    {
        var hshArg = {};
        var objElement = getSrcElement(p_objEvent)
        hshArg['event'] = p_objEvent;
        hshArg['object'] = objElement;
        if (__objs[objId])
        {
            hshArg['args'] = __objs[objId].__args[funId];
        }
        return __funs[funId].apply(__objs[objId], [hshArg]);
    }
    // else
    return __funs[funId].apply(__objs[objId], arguments);
  };
};

// sitas valymas yra nebutinas, nes ir taip closurai neleakina
//addEvent(window, 'unload', g_fCleanClosures);

/**
    Pasalinam visus objektus is globalaus masyvo.
*/
function g_fCleanClosures()
{
    if (window.__objs == null)
        return;
    for (var i = 0, intLength = window.__objs.length; i < intLength; i++)
    {
        window.__objs[i] = null;
        //window.__funs[i] = null;
    }
}
//--------------------------------------------------------------------------------------
/**
    Nustato reiksme, kuria pasiims iskviestasis langas (tik FF).
    @param p_objArg Perduodami duomenys
    @param p_fRet funkcija kuri bus iskvieciama langui uzsidarant
*/
function setVal(p_objArg, p_fRet, p_fOnLoad, p_fOnUnload)
{
	_val = p_objArg;
	_fReturn = p_fRet;
	_fOnChildLoad = p_fOnLoad;
	_fOnChildUnload = p_fOnUnload;
}

//--------------------------------------------------------------------------------------
try
{
    if(window.opener)
    {
        if(window.opener._fOnChildLoad != null)
        {
            addEvent(window, 'load', callParent);
        }
        if(window.opener._fOnChildUnload != null)
            addEvent(window, 'unload', callParent);
    }
}
catch(exception){}
//--------------------------------------------------------------------------------------
function callParent(e)
{
    if(e.type == 'load' && window.opener._fOnChildLoad)
        window.opener._fOnChildLoad(window);
    if(e.type == 'unload' && window.opener._fOnChildUnload)
        window.opener._fOnChildUnload(window);
}
//--------------------------------------------------------------------------------------
/*
    Grazina reiksme is modalinio lango. Funkcija atskiria ar langas yra remelyje ar ne ir
    galutinai iskviecia setRet funkcija virsutiniame lange arba lange, kuriame parametras blnMainWindow = true.
*/
function setRet(arg)
{
	var objMainWind = g_obj_fGetMainWindow();
	if (objMainWind && objMainWind != window)
	{
	    objMainWind.setRet(arg);
	}
	else
	{
	    try
	    {
		    window.opener._ret = arg;
		    if(window.opener._fReturn)
		        window.opener._fReturn(arg);
	    }
	    catch(ee)
	    {
		    window.returnValue = arg;
	    }
	}
}
//--------------------------------------------------------------------------------------
/**
    Pasiima reiksme is iskvieciancio lango. Funkcija atskiria ar iskviestasis langas yra remelyje ar ne ir
    galutinai iskviecia getVal funkcija virsutiniame lange arba lange, kuriame parametras blnMainWindow = true.
*/
function getVal()
{
    var objMainWind = g_obj_fGetMainWindow();
	if (objMainWind && objMainWind != window)
	{
	    return objMainWind.getVal();
	}
    else
	{
	    try
        {
	        return(window.opener._val);
	    }
	    catch (ee)
	    {
	        return(window.dialogArguments);
	    }
	}
}
//--------------------------------------------------------------------------------------
/**
    Suranda pagrindini langa, kuris turi parametra blnMainWindow lygu true.
*/
function g_obj_fGetMainWindow()
{
    var obj = window;
    if (obj.blnMainWindow) return obj;
    while (obj.parent != obj)
    {
        obj = obj.parent;
        if (obj.blnMainWindow) return obj;
    }
    return null;
}
//--------------------------------------------------------------------------------------
/**
    Suranda pagrindini langa, kurio tevas yra jis pats
*/
function g_obj_fGetSuperParentWindow()
{
    var obj = window;
    while (obj.parent != obj)
    {
        obj = obj.parent;
    }
    return obj;
}
//--------------------------------------------------------------------------------------
/**
    Universali uzdarymo funkcija, jei langas turi teva, tai uzdaro teva, jei ne tai uzdaro langa.
*/
function g_fSHClose()
{
    if (window.parent != window)
    {
        window.parent.g_fSHClose();
    }
    else
    {
        window.close();
    }
}
//--------------------------------------------------------------------------------------
/**
    Atidaro modalini dialoga. Aukstis ir plotis nurodomi pagal mozilla.
    @param p_strUrl dialogo turinio adresas
    @param p_intWidth  lango plotis
    @param p_intHeight lango aukstis
    @param p_strParams parametrai perduodami is tevinio lango dialogo langui
    @param p_strResizable parametras nusakantis ar galima keist lango ismatavimus
    @returns Grazina dialogo grazinamus parametrus.
    @type hsh
*/
function openDialog(p_strUrl, p_intWidth, p_intHeight, p_strParams, p_strResizable)
{
    if ( cIE )
    {
         p_intWidth = p_intWidth + 5;
         p_intHeight = p_intHeight + 25;
    }
    if(p_strParams == null)
    {
        p_strParams = new Object();
        p_strParams['window'] = window;
    }
    if(p_strResizable == null)
    {
        p_strResizable = 'yes';
    }
    if(p_strResizable == true)
    {
        p_strResizable = 'yes';
    }
    if(p_strResizable == false)
    {
        p_strResizable = 'no';
    }
	if(cIE)
	{
		return (window.showModalDialog(p_strUrl, p_strParams, 'dialogWidth:' + p_intWidth + 'px; dialogHeight:' + p_intHeight + 'px; center:yes; status:no; help:no; resizable:' + p_strResizable + '; scroll:no;') );
	}
	else
	{
		try
		{
		    setVal(p_strParams);
		    netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserWrite");

		 // lango X  ir Y
		    var intScreenX = parseInt(window.screenX);
		    var intScreenY = parseInt(window.screenY);

		 // randamas top'inis window
            var objTemp = window;
            while(objTemp != window.top)
            {
                objTemp = objTemp.parent;
            }

         // window plotis ir aukstis
            var intInnerHeight = objTemp.outerHeight;
		    var intInnerWidth = objTemp.outerWidth;

         // lango centras
            var intCenterLeft = parseInt(intScreenX);
            var intCenterTop = parseInt(intScreenY);
            intCenterLeft += parseInt(intInnerWidth/2);
            intCenterTop += parseInt(intInnerHeight/2);

         // window pasirodymo left ir top
            var intLeft = intCenterLeft - parseInt(p_intWidth/2);
            var intTop = intCenterTop - parseInt(p_intHeight/2);

			var objWindow = window.open(p_strUrl, '_blank', 'left='+ intLeft + ',top=' + intTop + ',width=' + p_intWidth + ',height=' + p_intHeight + ',modal=yes,dialog=yes,resizable=' + p_strResizable);
			return(_ret);
		}
		catch(ee)
		{
			return(ee);
		}
	}
}
//---------------------------------------------------------------------
/**
    Atidaro nauja paprasta langa. Aukstis ir plotis nurodomi pagal mozilla.
    @param p_strUrl Puslapio adresas
    @param p_intWidth Lango plotis
    @param p_intHeight Lango aukstis
    @param p_intLeft Lango atstumas nuo ekrano kaires
    @param p_intTop Lango atstumas nuo ekrano virsaus
    @param p_strTarget puslapio target atributas (atidarant antra puslapi su tu paciu target atributu, naujasis atsidaro ant senojo)
    @param p_strResizable parodo ar vartotojas gal?s keisti naujo lango dydi (yes/no)
    @param p_fRet funkcija kuri bus kvieciama uzsidarant langui
    @param p_fOnLoad funkcija kuri bus iskvieciama teviniame lange kai vaikinis langas uzsikraus (paduodamas window)
    @param p_fOnUnload funkcija kuri bus iskvieciama teviniame lange kai vaikinis langas bus uzdaromas (paduodamas window)
*/
function openWindow(p_strUrl, p_intWidth, p_intHeight, p_intLeft, p_intTop, p_strTarget, p_strResizable, p_hshData, p_fRet, p_fOnLoad, p_fOnUnload)
{
    if ( cIE )
    {
         p_intWidth = p_intWidth - 5;
         p_intHeight = p_intHeight - 3;
    }

	var strTarget = '_blank';
	var strResizab = 'yes';
	if(p_strTarget != null)
	    strTarget = p_strTarget;
	if(p_strResizable != null)
	    strResizab = p_strResizable;
	setVal(p_hshData, p_fRet, p_fOnLoad, p_fOnUnload);
	var objWindow = window.open(p_strUrl, strTarget, 'toolbar=no, location=no, directories=no, status=yes, menubar=no, scrollbars=0, resizable=' + strResizab + ', copyhistory=no, width=' + p_intWidth + ', height=' + p_intHeight + ',top=' + p_intTop + ',left=' + p_intLeft);
	return objWindow;

}
//---------------------------------------------------------------------
/**
    Asinchroniskai(nelaukia rezultatu) daro requesta.
    @param p_strUrl serverio adresas
    @param p_strData siun?iami duomenys
    @param p_fAfterDataArrived funkcija kuri bus i?kviesta gavus atsakym? i? serverio
*/
var objXmlAsyncRequest = null;
var objAsyncFunction = null;
function call(p_strUrl, p_strData, p_fAfterDataArrived)
{
    objAsyncFunction = p_fAfterDataArrived
	var pageUrl = p_strUrl + "?call=" + p_strData;
	if (window.XMLHttpRequest)
	{
	    objXmlAsyncRequest = new XMLHttpRequest();
		objXmlAsyncRequest.onreadystatechange = fAsyncResult;
		objXmlAsyncRequest.open("POST", pageUrl, true);
		objXmlAsyncRequest.send(null);
	}
	else if (window.ActiveXObject)
	{
	    objXmlAsyncRequest = new ActiveXObject("Microsoft.XMLHTTP")
		if (objXmlAsyncRequest)
		{
			objXmlAsyncRequest.onreadystatechange = fAsyncResult;
			objXmlAsyncRequest.open("POST", pageUrl, true);
			objXmlAsyncRequest.send(null);
		}
	}
}
//++++-------------------------------------------
function fAsyncResult()
	{
	    try
	    {
	        if(objXmlAsyncRequest.readyState == 4)
            {
                if(objXmlAsyncRequest.status == 200)
                {
		            objAsyncFunction(objXmlAsyncRequest.responseText);
                }
                else
                {
                }
            }
        }
        catch(objException)
        {
            console('clsBCServer.js fAsyncResult');
            console(objException);
            if (g_objLoadingIndicator && g_objLoadingIndicator.g_fHide)
                g_objLoadingIndicator.g_fHide();
        }
	}
//---------------------------------------------------------------
/**
    Sinchroniskai (laukia rezultatu) daro requesta.
    @param p_strUrl serverio adresas
    @param data siunciami duomenys
    @param funkcija funkcija kuri bus iskviesta gavus atsakyma is serverio
    @returns serverio atsakymas
    @type string
*/
function call2(p_strUrl, p_strData)
{
    var objXmlCall;
	var pageUrl = p_strUrl + "?call=true";
    if (window.XMLHttpRequest)
	{
		objXmlCall = new XMLHttpRequest();
		objXmlCall.open("POST", pageUrl, false);
		objXmlCall.send(p_strData);
		return(objXmlCall.responseText);
	}
	else
	if (window.ActiveXObject)
	{
		objXmlCall = new ActiveXObject("Microsoft.XMLHTTP");
		objXmlCall.open("POST", pageUrl, false);
		objXmlCall.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
		objXmlCall.send( p_strData );
		return(objXmlCall.ResponseText);
	}
}

//---------------------------------------------------------------
function _config()
{
	addEvent(document, 'contextmenu', _contextMenu);
	addEvent(document, 'selectstart', _select);
}
function _contextMenu(){return(true);}	// Ijungia/atjungia desine peles knopke
function _select(){return(false);}		// Ijungia/atjungia selectinima
//---------------------------------------------------------------
addEvent(window, 'unload', g_fUninitShared);
function g_fUninitShared(e)
{
    removeEvent(document, 'contextmenu', _contextMenu);
	removeEvent(document, 'selectstart', _select);
    removeEvent(window, 'unload', g_fUninitShared);
}
//---------------------------------------------------------------
/**
    Metodas ant nurodyto elemento uzdeda nurodyta eventa.
    @param p_objElement  HTML elementas ant kurio uzdedamas eventas.
    @param p_strEventType  Evento pavadinimas be IE priesagos 'on'.
    @param p_fHandler  nuoroda i funkcija.
*/
function addEvent(p_objElement, p_strEventType, p_fHandler)
{

    if (p_objElement.addEventListener)
    {
        p_objElement.addEventListener(p_strEventType, p_fHandler, false);
        return( true );
    }
    else
    if (p_objElement.attachEvent)
    {
        var fRet = p_objElement.attachEvent("on" + p_strEventType, p_fHandler);
        return( fRet );
    }
    else
    {
        return( false );
    }
}
//---------------------------------------------------------------
/**
    Metodas nuo nurodyto elemento nuima nurodyta eventa.
    @param p_objElement  HTML elementas nuo kurio nuimamas eventas.
    @param p_strEventType  Evento pavadinimas be IE priesagos 'on'.
    @param p_fHandler  nuoroda i funkcija kuria nuimam nuo evento.
*/
function removeEvent(p_objElement, p_strEventType, p_fHandler)
{
    if (p_objElement == null)
    {
        return;
    }
    if (p_objElement.removeEventListener)
    {
        p_objElement.removeEventListener(p_strEventType, p_fHandler, false);
        return true;
    }
    else
    if (p_objElement.detachEvent)
    {
        var fRet = p_objElement.detachEvent('on' + p_strEventType, p_fHandler);
        return(fRet);
    }
    else
    {
        consoleA("Handler could not be removed");
    }
}
//---------------------------------------------------------------
function _false(e)
{
	if(e.preventDefault)e.preventDefault();
	e.cancelBubble = true;
	return(false);
}
//---------------------------------------------------------------
/**
    @param e Javascriptinis ivykis.
    @returns ivyki sukelusi elementa
    @type HTMLElement
*/
function getSrcElement(e)
{
	if(e.srcElement)
	{
		return(e.srcElement);
	}
	else if(e.target)
	{
		return(e.target);
	}
}

if (cIE)
{
    var g_obj_fGetNavigatingToElement = function (e)
    {
        return e.toElement;
    }
}
if (cFF)
{
    var g_obj_fGetNavigatingToElement = function (e)
    {
        return e.relatedTarget;
    }
}

if (cIE)
{
    var g_obj_fGetNavigatingFromElement = function (e)
    {
        return e.fromElement;
    }
}
if (cFF)
{
    var g_obj_fGetNavigatingFromElement = function (e)
    {
        return e.currentTarget;
    }
}


//---------------------------------------------------------------
/**
    Grazina objekto pirmo lygio vaiku masyva , galima nurodyti vaiku tipa,
    Tipai :<br>
    1 ELEMENT_NODE <br>
    2 ATTRIBUTE_NODE <br>
    3 TEXT_NODE <br>
    4 CDATA_SECTION_NODE <br>
    5 ENTITY_REFERENCE_NODE <br>
    6 ENTITY_NODE <br>
    7 PROCESSING_INSTRUCTION_NODE <br>
    8 COMMENT_NODE <br>
    9 DOCUMENT_NODE <br>
    10 DOCUMENT_TYPE_NODE <br>
    11 DOCUMENT_FRAGMENT_NODE <br>
    12 NOTATION_NODE
    @param p_objElement HTML elementas kurio vaikus filtruosime
    @param p_intType Vaiku tipas , pagal kuri bus filtruojama (default 1)
    @returns Nufiltruota vaiku masyva
    @type HTMLElement[]
*/
function getChildren(p_objElement, p_intType)
{
	var intType = 1;
	if(p_intType != null)intType = p_intType;
	var arr_objChildren = new Array();
	if(p_objElement != null && p_objElement.childNodes != null || true)
	{
	    var objNodes = p_objElement.childNodes;
	    for(var i = 0;i < objNodes.length;i++)
	    {
		    if(objNodes[i].nodeType == intType)
		    {
			    arr_objChildren.push(objNodes[i]);
		    }
	    }
	}
	return(arr_objChildren);
}
//---------------------------------------------------------------
function getToElement(e)
{
    if(e.toElement) return(e.toElement);
    if(e.relatedTarget) return(e.relatedTarget);
}
//---------------------------------------------------------------
function getKeyCode(e)
{
	if(e.keyCode)
	{
		return(e.keyCode);
	}
	else
	if(e.which)
	{
		return(e.which);
	}
	return(null);
}
//---------------------------------------------------------------
/**
    Jei reikia nurodyti funkcija ir null netinka arba seip reikia
    tuscios funkcijos
*/
function tusciaFunkcija(){}
//---------------------------------------------------------------
/**
    Vercia desimtaini skaiciu i sesioliktaini pvz '246'->'F6',
    galima kad grazintu su atitinkamu priekiu pvz 0x ar belekokiu koki paduosi
    dec - desimtainis skaicius (0-255)
    priekis - prie grazinamo 26-ainio pridedamas priekyje (tiesiog)
*/
function decToHex(dec,priekis)
{
    dec = parseInt(dec, 10);
    if (!isNaN(dec))
    {
        hexChars = "0123456789ABCDEF";
        if (dec > 255)
        {
            return(null);
        }
        var i = dec % 16;
        var j = (dec - i) / 16;
        result = '';
        if(priekis!=null)
        {
			result+=priekis;
        }
        result += hexChars.charAt(j) + hexChars.charAt(i);
        return(result);
    }
    else
    {
        return(null);
    }
}
//---------------------------------------------------------------
function asciiToUrl(eilute)
{
	if(eilute !=null)
	{
		var ss = /\&\#[0-9]{1,3}\;/g;
		var ra = eilute.match(ss);
		var ats=eilute;
		if(ra!=null)
		{
			for(r=0;r<ra.length;r++)
			{
				ats = ats.replace( ra[r], '%'+decToHex(ra[r].substr(2,ra[r].length-3)) );
			}
		}
		return(ats);
	}
	return(null);
}
//---------------------------------------------------------------
/* naudojami teksto kodavimui/atkodavimui perduodant per GET, jei perduodam i Domo dialoga, koduoti du kartus! */
function encode(p_strText)
{
	return(encodeURIComponent(p_strText));
}
function decode(p_strText)
{
	return(decodeURIComponent(p_strText));
}
//---------------------------------------------------------------
/**
    Panaikina tuscius tarpus eilutes galuose.
    @addon
*/
String.prototype.trim = function()
{
	var x = this;
	x = x.replace(/^\s*(.*)/, "$1");
	x = x.replace(/(.*?)\s*$/, "$1");
	return x;
}
//---------------------------------------------------------------
/**
    Panaikina tuscius tarpus eilutes pradzioje.
    @addon
*/
String.prototype.trimLeft = function()
{
 var x = this;
 x = x.replace(/^\s*(.*)/, "$1");
 return x;
}
//---------------------------------------------------------------
/**
    Panaikina tuscius tarpus eilutes gale.
    @addon
*/
String.prototype.trimRight = function()
{
 var x = this;
 x = x.replace(/(.*?)\s*$/, "$1");
 return x;
}
//---------------------------------------------------------------
/**
    Reversina eilute.
    @addon
*/
String.prototype.reverse = function()
{
    var strAts = "";
    for (var i = this.length; i > 0; --i)
    {
        strAts += this.charAt(i - 1);
    }
    return(strAts);
}
//---------------------------------------------------------------
/**
    Xml'ine eilute uzkrauna i xml dokumenta.
    @param p_strText xml'ine eilute.
    @returns Uzloadinta xml dokumenta arba null jei ivyko klaida loadinant
    @type HTMLdocument
*/
function getXml(p_strText)
{
    var objXmlDOM;
    var strTemp = "" + p_strText.replace(/&(?!(quot;|apos;|amp;|lt;|gt;))/g, '&amp;');
    if (window.ActiveXObject)
    {
        objXmlDOM = new ActiveXObject("MSXML2.DOMDocument");
        objXmlDOM.loadXML(strTemp);
        objXmlDOM.setProperty("SelectionLanguage", "XPath");
        if (objXmlDOM.parseError.errorCode != 0)
        {
            console("Error parsing xml: \n" + strTemp);
            return(null);
        }
    }
    else
    {
        objXmlDOM = (new DOMParser).parseFromString(strTemp, "text/xml");
        objXmlDOM.normalize(); // DA tam kad sujungtu suskaidytas dalis po 4096 simbolius
        if(objXmlDOM.documentElement && objXmlDOM.documentElement.nodeName == "parsererror")
        {
            console("Error parsing xml: \n" + strTemp);
            return(null);
        }
    }
    return(objXmlDOM);
}
//---------------------------------------------------------------
/**
    Is HMTLDocumento padaro stringa.
    @param HTMLdocument
    @return xml stringa
    @type string
*/
function g_str_fSerializeXml(p_objXmlDoc)
{
    if(p_objXmlDoc.xml)
    {
        return(p_objXmlDoc.xml);
    }
    else
    {
        var objSerializer = new XMLSerializer();
        var strAts = objSerializer.serializeToString(p_objXmlDoc);
        return(strAts);
    }
}
//---------------------------------------------------------------
function ekranoWH() // Grazina einamojo lango/dialogo ploti ir auksti masyvu
{
	var winW = null;
	var winH = null;
	if (navigator.appName=="Netscape")
	{
		winW = window.innerWidth;
		winH = window.innerHeight;
	}
	else
	if (navigator.appName.indexOf("Microsoft")!=-1)
	{
		winW = document.body.offsetWidth;
		winH = document.body.offsetHeight;
	}
	return([winW,winH]);
}
//----------------------------------------------------------
/* gra?ina lango auk?ti */
function g_fGetViewportHeight()
{
// 2006 12 28 RG window.innerHeight ant FF netinka nes yskaiciuoja horizontalu scroll http://developer.mozilla.org/en/docs/DOM:window#Properties
	//if(window.innerHeight != window.undefined) { return window.innerHeight;}
	if(document.compatMode == 'CSS1Compat') { return document.documentElement.clientHeight;}
	if(document.body) {return document.body.clientHeight; }
	return window.undefined;
}
//----------------------------------------------------------
/* gra?ina lango ploti , mozilai del scrollbaru ploti padidina 16px */
function g_fGetViewportWidth()
{
	var intW = window.undefined;
	if( window.innerWidth != window.undefined) intW = parseInt(window.innerWidth);
	if( document.compatMode == 'CSS1Compat') intW = parseInt(document.documentElement.clientWidth);
	if( document.body) intW = parseInt(document.body.clientWidth);
	if( detectB == 'moz') intW += 16;
	return intW;
}
//---------------------------------------------------------------
/* gra?ina einamojo lango centro koordinates ( iskaitant scrollinima )*/
function g_arr_fCentroKoordinates()
{
	var intWindowHeight = g_fGetViewportHeight();
	var intWindowWidth = g_fGetViewportWidth();
	var objBody = document.body;
	var intScrollTop = parseInt(objBody.scrollTop,10);
	var intScrollLeft = parseInt(objBody.scrollLeft,10);
	var intY = (intScrollTop + (intWindowHeight / 2));
	var intX = (intScrollLeft + (intWindowWidth / 2));
	return([intX, intY]);
}
//---------------------------------------------------------------
/* paduota objekta pozicionuoja einamo lango viduryje */
function g_fCentruoti(p_objLangas)
{
	var int_arrCoord = g_arr_fCentroKoordinates();
	p_objLangas.style.top =  (int_arrCoord[1] - parseInt(p_objLangas.offsetHeight) / 2) + "px";
	p_objLangas.style.left = (int_arrCoord[0] - parseInt(p_objLangas.offsetWidth) / 2) + "px";
}
//---------------------------------------------------------------
/**
    grazina ar duotas taskas yra ekrane
    RG 2006 11 16 updated
    RG 2006 12 29 updated
*/
function g_bln_fIsOnScreen(pX,pY,p_strBoundaryObjId)
{
	var objBody = document.body;
	var intScrollTop = 0;
	var intScrollLeft = 0;
 // IE6 +4.01
    if (document.documentElement)
    {
        if(document.documentElement.scrollTop)
        {
            intScrollTop = document.documentElement.scrollTop;
        }
        if(document.documentElement.scrollLeft)
        {
            intScrollLeft = document.documentElement.scrollLeft;
        }
    }
 // IE5 or DTD 3.2
   // else

    if (document.body)
    {
        if(document.body.scrollTop)
        {
            intScrollTop = document.body.scrollTop;
        }
        if(document.body.scrollLeft)
        {
            intScrollLeft = document.body.scrollLeft;
        }
    }

	var blnIsOnScreen = false;
	if(pX >= intScrollLeft && pX < (intScrollLeft + g_fGetViewportWidth()) )
	{
		if(pY >= intScrollTop && pY < (intScrollTop + g_fGetViewportHeight()) )
		{
			blnIsOnScreen = true;
		}
	}
	if(blnIsOnScreen == true)
	{
     // jei duotas elementas kuriame turi buti taskas
        if(p_strBoundaryObjId != null)
        {
            var objBoundaryObj = document.getElementById(p_strBoundaryObjId);
            if(objBoundaryObj == null) {consoleA('boundary obj doesnt exist');return false;}
            var arr_intBoundaryPos = objPosition(objBoundaryObj);
            var intX = arr_intBoundaryPos[2];
            var intY = arr_intBoundaryPos[3];
            var intWidth = arr_intBoundaryPos[0];
            var intHeight = arr_intBoundaryPos[1];
            if(pX > intX && pX < (intX + intWidth))
	        {
		        if(pY > intY && pY < (intY + intHeight) )
		        {
			        return (true);
		        }
	        }
	        return (false);
        }
        else
            return (true);
	}
	else
	    return (false);
}
//---------------------------------------------------------------
/*
    @id - galima paduoti objekto Id arba pati objekta
    @p_strType - objekto pozicijos skaiciavimo budas
	    jei 'simple' tiesiog gra?ina .left ir .top
	    jei nenurodytas tai skaiciuoja tiksliai puslapio at?vilgiu.
    Gra?ina objekto ploti, auk?ti, x koordinate, y koordinate.
*/
function objPosition(id, p_strType)
{
	var obj = null;
	try
	{
		if(typeof(id) != 'object')
		{
			obj = document.getElementById(id);
		}
		else
		{
			obj = id;
		}
		var l=0; var t=0; var w=0; var h=0;
		w = obj.offsetWidth;
		h = obj.offsetHeight;
	}
	catch(strError)
	{
		return;
	}
	if(p_strType == null || p_strType != 'simple')
	{
		if (obj.offsetParent)
		{
			for (posX = 0, posY = 0; obj.offsetParent; obj = obj.offsetParent)
			{
			    //o(obj.tagName + ' #' + obj.id + ' .' + obj.className);
				posX += obj.offsetLeft;
				posY += obj.offsetTop;
			}
			l = posX; t = posY;
		}
		else if(obj.x)
		{
			l = obj.x; t = obj.y;
		}
	}
	else
		if(p_strType == 'simple')
		{
			var tempLeft = obj.style.left;
			var tempTop = obj.style.top;
			l = parseInt(tempLeft);
			t = parseInt(tempTop);
		}
	return([w,h,l,t]);
}
//---------------------------------------------------------------

/* skirtas u?deti funkcijoms per atributus ( nes exploreryje neveikia kitaip ) */
function eventAdder(objAttrib,handler,addFunction)
{
	if ((!document.all)&&(document.getElementById))
	{
		try
		{
			objAttrib.setAttribute(handler,addFunction);
		}
		catch(ee)
		{
			consoleA('eventAdder: ' + ee + '\n' + objAttrib);
		}
	}
	if ((document.all)&&(document.getElementById))
	{
		objAttrib[handler] = new Function(addFunction);
	}
}
//---------------------------------------------------------------
/* Gra?ina peles koordinates puslapyje ( iskaitant ir pascrollinimus ) */
function getMouse(e)
{
	var xPos;
	var yPos;
	if (e.pageX || e.pageY)
	{
		xPos = e.pageX;
		yPos = e.pageY;
	}
	else if (e.clientX || e.clientY)
	{
		xPos = e.clientX + document.body.scrollLeft;
		yPos = e.clientY + document.body.scrollTop;
	}
	return([xPos,yPos]);
}
//---------------------------------------------------------------
/* Masyve iesko duotos reiksmes, jei randa grazina jos eiles numeri , jei ne -1*/
Array.prototype.inArray = function (value)
{
	for (var i = 0; i < this.length; i++)
	{
		if (this[i] == value)
		{
			return i;
		}
	}
	return -1;
};
//---------------------------------------------------------------
Array.prototype.contains = function(r)  {
  for(var x=0;x<this.length;x++)  {
    if(this[x]==r)  {
      return true;
    }}  return false;
}
//---------------------------------------------------------------
Array.prototype.intersection = function(arr2)
{
  var returnArray = new Array(); var y = 0;
  for(var x=0;x<this.length;x++)
  {
    if(arr2.contains(this[x]))
    {
      returnArray[y++] = this[x];
    }
  }
  return y==0?null:returnArray;
}
//---------------------------------------------------------------
//------------------BEGIN prototype sort @@@@@@@@@@@@@@@@@@@@@@@@
//---------------------------------------------------------------
Array.prototype.swap = function(a, b)
{
	var tmp=this[a];
	this[a]=this[b];
	this[b]=tmp;
}
//---------------------------------------------------------------
if(cFF)
{
    Array.prototype.sort = function(func)
    {
        return msort(this, 0, this.length, func);
    }
}
//---------------------------------------------------------------
function insert(array, begin, end, v, func)
{
	while((begin + 1 < end) && (func(array[begin+1], v) < 0))
	{
		array.swap(begin, begin+1);
		++begin;
	}
	array[begin] = v;
}
//---------------------------------------------------------------
function merge(array, begin, begin_right, end, func)
{
	for(;begin < begin_right; ++begin)
	{
		if(func(array[begin], array[begin_right]) > 0)
		{
			var v = array[begin];
			array[begin] = array[begin_right];
			insert(array, begin_right, end, v, func);
		}
	}
}
//---------------------------------------------------------------
function msort(array, begin, end, func)
{
	var size = end - begin;
	if(size < 2) return;

	var begin_right = begin + Math.floor(size/2);

	msort(array, begin, begin_right, func);
	msort(array, begin_right, end, func);
	merge(array, begin, begin_right, end, func);
	return array;
}
//---------------------------------------------------------------
//------------------END prototype sort @@@@@@@@@@@@@@@@@@@@@@@@@@
//---------------------------------------------------------------
/*
	Gra?ina teksta i? clipbordo.
*/
function g_str_fGetClipboardText()
{
	var strText = 'cEMPTY';
	if(window.clipboardData)
	{
		var strText = window.clipboardData.getData('Text');
	}
	else if(window.netscape)
	{
		netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
		var clip = Components.classes['@mozilla.org/widget/clipboard;1'].createInstance(Components.interfaces.nsIClipboard);
		if (!clip)
		    return strText;
		var trans = Components.classes['@mozilla.org/widget/transferable;1'].createInstance(Components.interfaces.nsITransferable);
		if (!trans)
		    return strText;
		trans.addDataFlavor('text/unicode');
		//trans.addDataFlavor('text/plain');
		clip.getData(trans, clip.kGlobalClipboard);
		var str = new Object();
		var strLength = new Object();
		try
		{
		    trans.getTransferData('text/unicode', str, strLength);
		    if (str) str = str.value.QueryInterface(Components.interfaces.nsISupportsString);
		    if (str) strText = str.data.substring(0, strLength.value / 2);
		}
		catch(ex)
		{
		    //strText = 'cEMPTY';
		}
	}
	return(strText);
}

//    /**
//    Kopijuoja i clipborda texta
//    @param  p_strText
//    */
    function g_fCopyToClipboard(p_text)
    {
        if (cIE)
        {
            try{ // da uzdejau, kad timptelejus ant grido nemestu klaidos
            if(window.clipboardData || clipboardData)
            window.clipboardData.setData("Text", p_text);
            }
            catch(ex){}
            return;
        }
        else
        {
            netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
            var gClipboardHelper = Components.classes["@mozilla.org/widget/clipboardhelper;1"].
                                    getService(Components.interfaces.nsIClipboardHelper);
            gClipboardHelper.copyString(p_text);
            return;
        }
    }
    /**
    analogiska tik sudetingesne kopinimo funkcija
    */
    function bln_fCopyToClipboard(p_strText)
    {
        if (cIE)
        {
            if(window.clipboardData || clipboardData)
                window.clipboardData.setData("Text", p_strText);
        }
        else
        {
            netscape.security.PrivilegeManager.enablePrivilege('UniversalXPConnect');
            var copytext = p_strText;
            var str   = Components.classes["@mozilla.org/supports-string;1"].
                        createInstance(Components.interfaces.nsISupportsString);
            if (!str)
                return false;
            str.data  = copytext;
            var trans = Components.classes["@mozilla.org/widget/transferable;1"].
                        createInstance(Components.interfaces.nsITransferable);
            if (!trans)
                return false;

            trans.addDataFlavor("text/unicode");
            trans.setTransferData("text/unicode", str, copytext.length * 2);
            var clipid = Components.interfaces.nsIClipboard;
            var clip   = Components.classes["@mozilla.org/widget/clipboard;1"].getService(clipid);
            if (!clip)
                return false;
            clip.setData(trans, null, clipid.kGlobalClipboard);
        }
        return true;
    }
//---------------------------------------------------------------
function bcCacheSystem()
{
	var xmlCache = new Object();
	var objThis = this;
	//---------------------------------------------------------------

	//---------------------------------------------------------------
	function g_objFindParent()
	{
	    try
	    {
	        if(  window.parent != window && window.parent.cacheSystem != null)
	        {
	            return( window.parent.cacheSystem);
	        }
	        else
	        if(window.opener != null && window.opener.cacheSystem != null)
	        {
	           return( window.opener.cacheSystem );
	        }
	        else
	        if(window.dialogArguments && window.dialogArguments['window'] != null && window.dialogArguments['window'].cacheSystem)
	        {
	             return( window.dialogArguments['window'].cacheSystem );
	        }
	        else
	        {
	             return(null);
	        }
	    }
	    catch(objExcep)
	    {
	        return(null);
	    }
	}
	//---------------------------------------------------------------
	this.g_fInsertXml = function(p_strFilename, p_objXml)
	{
	    var objParent = g_objFindParent();
	    if(objParent != null)
	    {
	        objParent.g_fInsertXml(p_strFilename, p_objXml);
		}
		else
		{
		    xmlCache[p_strFilename] = p_objXml;
		}
	}
	//---------------------------------------------------------------
	this.g_obj_fGetXml = function(p_strFilename)
	{
	    try
	    {
	        var objParent = g_objFindParent();
	        if(objParent != null)
	        {
	            return( objParent.g_obj_fGetXml(p_strFilename) );
	        }
	        else
	        {
	            return(xmlCache[p_strFilename]);
	        }
	    }
	    catch(Exception)
	    {
	        consoleA('is cacho...[klaida isimant is cacheSystem]');
	        return(null);
	    }
	}
	//---------------------------------------------------------------
}
var cacheSystem = new bcCacheSystem();
//---------------------------------------------------------------
/**
	Pagal duota formata bando nuskaityti datos eilute ir uzloadinti i Date objekta bei ji grazinti.
	2007.03.14 ivestas pataisymas, kad jei paduodamas metu skaiciukas is dvieju skaiciu
	(tiksliau .trim() duoda eilute iki dvieju skaiciu), tai parsina tokiu budu - jei metai yra didesni
	uz sios dienos metus + 20, tai data yra praejusio amziaus, jei ne, tai data yra sio amziaus.
	@param p_strDate datos eilute.
	@param p_strFormat  formatas, pvz MM/dd/yyyy
	@returns suformuota datos objekta
	@type Date
*/
function g_obj_fgetDate(p_strDate, p_strFormat)
{
	if(p_strDate == null)
	    return null;

	var strTemp = '';

	var intPradzia = p_strFormat.indexOf('d')
	var intPabaiga = p_strFormat.lastIndexOf('d') + 1;
	var strEil = p_strDate.substring(intPradzia, intPabaiga).trim();
	strEil = strEil.replace(/^(0*)/,'').replace(/[\D]/g,'0');

	strTemp += strEil + '.';
	var intDienos = parseInt(strEil);
	intPradzia = p_strFormat.indexOf('M')
	intPabaiga = p_strFormat.lastIndexOf('M') + 1;
	strEil = p_strDate.substring(intPradzia, intPabaiga).trim();
	strEil =  strEil.replace(/^(0*)/,'').replace(/[\D]/g,'0');
	strTemp += strEil + '.';
	var intMenesiai = parseInt(strEil);
	intPradzia = p_strFormat.indexOf('y');
	intPabaiga = p_strFormat.lastIndexOf('y') + 1;
	strEil = p_strDate.substring(intPradzia, intPabaiga);
    var strTempString = strEil;
    var index = strEil.search(/[0,1,2,3,4,5,6,7,8,9]/g);
    // Versija po 2007.03.14
    var strTrimed = strEil.trim();
    if (strTrimed.length <= 2)
    {
        var objTodaysDate = new Date();
        var intFullYears = objTodaysDate.getFullYear();
        var intYears = intFullYears % 100;
        var intMetai = parseInt(strEil);
        if (intMetai > intYears + 20)
        {
            intMetai = intFullYears - intYears + intMetai - 100;
        }
        else
        {
            intMetai = intFullYears - intYears + intMetai;
        }
    }
    else
    {
        strEil = strEil.replace(/^[\D]/,'2').replace(/^(0*)/,'').replace(/[\D]/g,'0');
	    var intMetai = parseInt(strEil);
	}
    strTemp += strEil + '.';

//    Versija pries 2007.03.14
//	strEil = strEil.replace(/^[\D]/,'2').replace(/^(0*)/,'').replace(/[\D]/g,'0');
//	strTemp += strEil + '.';
//	var intMetai = parseInt(strEil);


//RG 08 23
	if(index == -1)
	    intMetai = '2000'; // istaisiau i 2000, buvo aadf   KM 2007.03.13
//end  RG 08 23
	intPradzia = p_strFormat.indexOf('H');
	intPabaiga = p_strFormat.lastIndexOf('H') + 1;
	strEil = p_strDate.substring(intPradzia, intPabaiga);
	strEil = strEil.replace(/^(0)/,'');
	strTemp += strEil + '.';
	var intValandos = parseInt(strEil);

	intPradzia = p_strFormat.indexOf('m');
	intPabaiga = p_strFormat.lastIndexOf('m') + 1;
	strEil = p_strDate.substring(intPradzia, intPabaiga);
	strEil = strEil.replace(/^(0)/,'');
	strTemp += strEil + '.';
	var intMinutes = parseInt(strEil);

	intPradzia = p_strFormat.indexOf('s');
	intPabaiga = p_strFormat.lastIndexOf('s') + 1;
	strEil = p_strDate.substring(intPradzia, intPabaiga);
	strEil = strEil.replace(/^(0)/,'');
	strTemp += strEil + '.';
	var intSekundes = parseInt(strEil);
	if(isNaN(intDienos) == false || isNaN(intMenesiai) == false ||  isNaN(intMetai) == false  || isNaN(intValandos) == false || isNaN(intMinutes) == false || isNaN(intSekundes) == false)
	{
	    if( isNaN(intDienos) ) intDienos = '01';
	    if( isNaN(intMenesiai) ) intMenesiai = '01';
	    if( isNaN(intMetai) ) intMetai = '2000';
	    if( isNaN(intValandos) ) intValandos = '00';
	    if( isNaN(intMinutes) ) intMinutes = '00';
	    if( isNaN(intSekundes) ) intSekundes = '00';

    	var objData = new Date( intMenesiai + '/' + intDienos + '/' + intMetai + ' ' + intValandos + ':' + intMinutes + ':' + intSekundes);
	    return(objData);
	}
	else
	    return null;
}

/**
	Tas pats kaip g_obj_fgetDate, bet pavadinime Get is didziosios. KM.
	@param p_strDate datos eilute.
	@param p_strFormat  formatas, pvz MM/dd/yyyy
	@returns suformuota datos objekta
	@type Date
*/
function g_obj_fGetDate(p_strDate, p_strFormat)
{
    return g_obj_fgetDate(p_strDate, p_strFormat);
}
//---------------------------------------------------------------
/**
    Metodas globalias koordinates vercia i lokalias atitinkamas platformos atzvilgiu.
    Koordinates skaiciuojamos nuo dokumento arba nuo pirmo absoliutinio/reliatyvaus tevo, taip pat:
    IE - absoliutinis tevas gali buti ir overflow turintis divas.
    FF - reikalinga koordinaciu korekcija iskaiciuojant visus scrollTop/scrollLeft objektu
    esanciu iki pirmo absoliutinio/reliatyvaus tevo.
    @param p_strPlatformId - platformos id arba objektas, kurios atzvilgiu bus skaiciuojamos koordinates.
    @param p_intGlobalX globali X koordinate.
    @param p_intGlobalY globali Y koordinate.
    @param p_intStartX nurodoma pradine X koordinate(nebutina) (default - 0)
    @param p_intStartY nurodoma pradine Y koordinate(nebutina) (default - 0)
    @param p_strItemId elementas kuriam sias koordinates priskirti ( nebutinas ).
    @returns Grazina koordinaciu masyva [x, y]
    @type int[]
*/
function g_arr_int_fGetCoords(p_strPlatformId, p_intGlobalX, p_intGlobalY, p_intStartX, p_intStartY, p_strItemId)
{
    return (g_arr_int_fGetCoords2(p_strPlatformId, p_intGlobalX, p_intGlobalY, p_intStartX, p_intStartY, p_strItemId));
    var intLocalX = 0;
    var intLocalY = 0;
    if( typeof(p_strPlatformId) != 'object')
        var objPlatform = document.getElementById(p_strPlatformId);
    else
        var objPlatform = p_strPlatformId;
    var objParent = null;
    var blnOverflow = false;
    var objTempPlatform = objPlatform;
    while(objTempPlatform != null && objTempPlatform != document)
    {
        var blnDivOverflow = (objTempPlatform.tagName == 'DIV' && objTempPlatform.style.overflow != '' && objTempPlatform.style.overflow != 'none' || ( cFF && (objTempPlatform.scrollTop != 0 || objTempPlatform.scrollLeft != 0) ) );
        if(objTempPlatform.style.position == 'absolute' ||  objTempPlatform.style.position == 'relative' || blnDivOverflow)
        {
            blnOverflow = blnDivOverflow;
            objParent = objTempPlatform;
            break;
        }
        objTempPlatform = objTempPlatform.parentNode;
        if(objTempPlatform == document)
        {
            objParent = null;
            break;
        }
    }
    if(objParent != null)
    {
        var arr_intGlobalPos = objPosition(objParent);
        if(objParent.style.position == 'absolute' || objParent.style.position == 'relative' || (cIE && blnOverflow))
        {
            intLocalX = p_intGlobalX - arr_intGlobalPos[2];
            intLocalY = p_intGlobalY - arr_intGlobalPos[3];
        }
        else if(cFF && blnOverflow)
        {
            var objTempPlatform = objPlatform;
            var intCorrectionY = 0;
            var intCorrectionX = 0;
            while(objTempPlatform != null && objTempPlatform != document)
            {
                if(objTempPlatform.scrollTop)
                    intCorrectionY += objTempPlatform.scrollTop;
                if(objTempPlatform.scrollLeft)
                    intCorrectionX += objTempPlatform.scrollLeft;
                if(objTempPlatform.style.position == 'absolute' ||  objTempPlatform.style.position == 'relative')
                {
                    objParent = objTempPlatform;
                    break;
                }
                objTempPlatform = objTempPlatform.parentNode;
            }
            var arr_intGlobalPos = objPosition(objParent);
            if(objParent.style.position == 'absolute' || objParent.style.position == 'relative')
            {
                intLocalX = p_intGlobalX - arr_intGlobalPos[2] - intCorrectionX;
                intLocalY = p_intGlobalY - arr_intGlobalPos[3] - intCorrectionY;
            }
            else
            {
                intLocalX = p_intGlobalX - intCorrectionX;
                intLocalY = p_intGlobalY - intCorrectionY;
            }
        }
        else
        {
            intLocalX = p_intGlobalX;
            intLocalY = p_intGlobalY;
        }
    }
    else
    {
        intLocalX = p_intGlobalX;
        intLocalY = p_intGlobalY;
    }

    if(p_strItemId != null)
    {
        var objItem = document.getElementById(p_strItemId);
        objItem.style.left = intLocalX;
        objItem.style.top = intLocalY;
    }
    return( [intLocalX, intLocalY] );
}
//---------------------------------------------------------------
    function g_arr_int_fGetCoords2(p_strPlatformId, p_intGlobalX, p_intGlobalY, p_intStartX, p_intStartY, p_strItemId)
    {
        var intLocalX = 0;
        var intLocalY = 0;
        if( typeof(p_strPlatformId) != 'object')
            var objPlatform = document.getElementById(p_strPlatformId);
        else
            var objPlatform = p_strPlatformId;
        var objParent = null;
        var blnOverflow = false;
        var objTempPlatform = objPlatform;
        while(objTempPlatform != null && objTempPlatform != document)
        {
            var blnDivOverflow = (objTempPlatform.tagName == 'DIV' && objTempPlatform.style.overflow != '' && objTempPlatform.style.overflow != 'none' || ( cFF && (objTempPlatform.scrollTop != 0 || objTempPlatform.scrollLeft != 0) ) );
            if(objTempPlatform.style.position == 'absolute' ||  objTempPlatform.style.position == 'relative' || blnDivOverflow)
            {
                blnOverflow = blnDivOverflow;
                objParent = objTempPlatform;
                break;
            }
            objTempPlatform = objTempPlatform.parentNode;
            if(objTempPlatform == document)
            {
                objParent = null;
                break;
            }
        }
        if (objParent != null)
        {

            var arr_intGlobalPos = g_arr_int_fPosition(objParent);
            if(objParent.style.position == 'absolute' || objParent.style.position == 'relative')
            {
                intLocalX = p_intGlobalX - arr_intGlobalPos[0];
                intLocalY = p_intGlobalY - arr_intGlobalPos[1];
            }
            else
            {
                intLocalX = p_intGlobalX;
                intLocalY = p_intGlobalY;
            }
        }
        else
        {
            intLocalX = p_intGlobalX;
            intLocalY = p_intGlobalY;
        }

        if(p_strItemId != null)
        {
            var objItem = document.getElementById(p_strItemId);
            objItem.style.left = intLocalX;
            objItem.style.top = intLocalY;
        }
        return( [intLocalX, intLocalY] );
    }
//---------------------------------------------------------------

 function clsBase64()
     {
        var hshSymbols = new Object();
        hshSymbols['A'] = 0;
        hshSymbols['B'] = 1;
        hshSymbols['C'] = 2;
        hshSymbols['D'] = 3;
        hshSymbols['E'] = 4;
        hshSymbols['F'] = 5;
        hshSymbols['G'] = 6;
        hshSymbols['H'] = 7;
        hshSymbols['I'] = 8;
        hshSymbols['J'] = 9;
        hshSymbols['K'] = 10;
        hshSymbols['L'] = 11;
        hshSymbols['M'] = 12;
        hshSymbols['N'] = 13;
        hshSymbols['O'] = 14;
        hshSymbols['P'] = 15;
        hshSymbols['Q'] = 16;

        hshSymbols['R'] = 17;
        hshSymbols['S'] = 18;
        hshSymbols['T'] = 19;
        hshSymbols['U'] = 20;
        hshSymbols['V'] = 21;
        hshSymbols['W'] = 22;
        hshSymbols['X'] = 23;
        hshSymbols['Y'] = 24;
        hshSymbols['Z'] = 25;
        hshSymbols['a'] = 26;
        hshSymbols['b'] = 27;
        hshSymbols['c'] = 28;
        hshSymbols['d'] = 29;
        hshSymbols['e'] = 30;
        hshSymbols['f'] = 31;
        hshSymbols['g'] = 32;
        hshSymbols['h'] = 33;

        hshSymbols['i'] = 34;
        hshSymbols['j'] = 35;
        hshSymbols['k'] = 36;
        hshSymbols['l'] = 37;
        hshSymbols['m'] = 38;
        hshSymbols['n'] = 39;
        hshSymbols['o'] = 40;
        hshSymbols['p'] = 41;
        hshSymbols['q'] = 42;
        hshSymbols['r'] = 43;
        hshSymbols['s'] = 44;
        hshSymbols['t'] = 45;
        hshSymbols['u'] = 46;
        hshSymbols['v'] = 47;
        hshSymbols['w'] = 48;
        hshSymbols['x'] = 49;
        hshSymbols['y'] = 50;

        hshSymbols['z'] = 51;
        hshSymbols['0'] = 52;
        hshSymbols['1'] = 53;
        hshSymbols['2'] = 54;
        hshSymbols['3'] = 55;
        hshSymbols['4'] = 56;
        hshSymbols['5'] = 57;
        hshSymbols['6'] = 58;
        hshSymbols['7'] = 59;
        hshSymbols['8'] = 60;
        hshSymbols['9'] = 61;
        hshSymbols['+'] = 62;
        hshSymbols['/'] = 63;

        //---------------------------------------------------
        this.g_str_fConvertToNormal = function(p_strBase64String)
        {
            var strAts = '';
            for(var i = 0;i < p_strBase64String.length;i++)
            {
                var strChar = p_strBase64String.charAt(i);
                if(strChar != '=')
                {
                    var intCode = hshSymbols[strChar];
                    strAts += str_fIntegerTo6bit(intCode);
                }
            }
            var arr_intDec = arr_int_fBitsToBytes(strAts);
            for(var i = 0;i < arr_intDec.length;i++)
            {
                arr_intDec[i] = decToHex(arr_intDec[i], '');
            }
            var strAts = '0x';
            for(var i = 0;i < Math.min(8, arr_intDec.length);i++)
            {
                strAts += arr_intDec[i];
            }
            return(strAts);
        }
        //---------------------------------------------------
        function arr_int_fBitsToBytes(p_strBits)
        {
            var arr_intAts = new Array();
            var arr_intSvoriai = new Array(128, 64, 32, 16, 8, 4, 2, 1);
            while(true)
            {
                var strBaitas = p_strBits.slice(0, Math.min(8, p_strBits.length) );
                var intSuma = 0;
                for(var i = 0;i < strBaitas.length;i++)
                {
                    var intKiek = parseInt( strBaitas.charAt(i) );
                    intSuma += intKiek * arr_intSvoriai[i];
                }
                arr_intAts.push(intSuma);
                if(p_strBits.length > 8)
                {
                    p_strBits = p_strBits.substring(8, p_strBits.length);
                }
                else
                {
                    break;
                }
            }
            return(arr_intAts);
        }
        //---------------------------------------------------
        function str_fIntegerTo6bit(p_intInteger)
        {
            var strAts = '';
            var arr_intSvoriai = new Array(32, 16, 8, 4, 2, 1);
            for(var i = 0;i < arr_intSvoriai.length; i++)
            {
                if(p_intInteger >= arr_intSvoriai[i])
                {
                    strAts += '1';
                    p_intInteger -= arr_intSvoriai[i];
                }
                else
                {
                    strAts += '0';
                }
            }
            return(strAts);
        }
        //---------------------------------------------------
     }
//-----------------------------------------------------------------------------------
/**
    Atidaromas objekto redagavimo formos su medziu langas atitinkamame rezime.
    @param p_strFile failo tipas ( 'user', 'securityRole', 'viewRole', 'server', ...)
    @param p_strType  atidaromo lango tipas( 'edit', 'new', 'read' )
    @param p_arr_strValue raktiniu lauku reiksmiu masyvas ( pvz 'Jonas2000', 13)
    @param p_arr_strKeys raktiniu lauku masyvas (pvz [username],[id])
    @param p_strToolbarButtons irankiu juostos mygtukai ('save_saveClose_help')
    @param p_hshData pradiniu duomenu hashas, jo key turi sutapt su db key
    @param p_objWindow paduodamas window kuriame bus uzkraunama forma
    @param p_fRet funkcija kuri bus kvieciama uzdarant forma (jei ne null, bus atidaroma NE-Modaliniame lange)
    @param p_strSizeType atidaromo lango dydzio tipas( pagal nutylejima 'normal' )
*/
function g_hsh_fOpenForm( p_strFile, p_strType, p_arr_strValue, p_arr_strKeys,  p_strToolbarButtons, p_hshData, p_objWindow, p_fRet, p_strSizeType )
{
    // DA ideta, nes negalima siu formu atidaryt new rezime
    if ( (((p_strFile == 'viewRole') || (p_strFile == 'securityRole')) && (p_strType == 'new')) || p_strFile == 'vConst' )
    {
        return null;
    }

    var hshParameters = new Object();
    hshParameters['strFileType'] =  p_strFile;
    hshParameters['strType'] = p_strType;
    hshParameters['arr_strKeyValues'] = p_arr_strValue;
    if ( p_strToolbarButtons != null )
        hshParameters['strToolbarButtons'] = p_strToolbarButtons;
    else
        hshParameters['strToolbarButtons'] = 'save_saveClose_help';
    if ( p_arr_strKeys != null )
        hshParameters['arr_strKeyFields'] = p_arr_strKeys;

    hshParameters['fOnSave'] = 'fAfterSave';

    var strPage = g_str_fOpenDialogWithTree( hshParameters );
    var hshData = new Object();
    var hshPar = new Object();
    hshPar['window'] = window;
    hshPar['data'] = p_hshData;

    if ( p_strSizeType == null ) p_strSizeType = 'normal';
    var hshSizes;
    if ( g_objDialogWithTreeSizes.g_hshSizes[p_strSizeType] != null )
    {
        hshSizes = g_objDialogWithTreeSizes.g_hshSizes[p_strSizeType];
    }
    else
    {
        hshSizes = g_objDialogWithTreeSizes.g_hshSizes['normal'];
    }

    if(p_fRet == null)
        hshData = openDialog(strPage, hshSizes['intMozDialogWidth'], hshSizes['intMozDialogHeight'], hshPar, 'yes' )
    else
        openWindow(strPage, hshSizes['intMozWindowWidth'], hshSizes['intMozWindowHeight'], 100, 100, null, 'yes', hshPar, p_fRet);
    return( hshData );
}
//-----------------------------------------------------------------------------------
// DA opens dialog with tree with some default parameters
/**
    Atidaromas objekto redagavimo formos su medziu langas atitinkamame rezime paieskos rezultatams vaizduoti.
    @param p_strTable nagrinejamos lenteles vardas
    @param p_arr_strKey raktiniu lauku masyvas (pvz [username],[id])
    @param p_arr_strValue raktiniu lauku reiksmiu masyvas ( pvz 'Jonas2000', 13)
    @param p_strPersonData nagrinejamo asmens duomenys
    @param p_objWindow paduodamas window kuriame bus uzkraunama forma
    @param p_strSizeType atidaromo lango dydzio tipas( pagal nutylejima 'normal' )
*/
function g_hsh_fOpenWADialogWithTree( p_strTable, p_arr_strKey, p_arr_strValue, p_strPersonData, p_objWindow, p_strSizeType )
{
    // atrenka pagal pirma raktini lauka. Jei reiktu daugiau, tektu modifikuoti faile frmWAResultDialog.aspx.cs
    // ir cia parametra 'key' ir jo sudedamas bei paimamas reiksmes strKey
    var strKey = p_arr_strKey[0];
    var arr_strKey = new Array();
    for ( var i = 0; i < p_arr_strKey.length; i++ )
    {
        arr_strKey.push(p_arr_strKey[i]);
    }
    arr_strKey.push('table');
    arr_strKey.push('key');

    var arr_strValue = new Array();
    for ( var i = 0; i < p_arr_strValue.length; i++ )
    {
        arr_strValue.push(p_arr_strValue[i]);
    }

    arr_strValue.push(p_strTable);
    arr_strValue.push(strKey);

    var hshParameters = new Object();
    hshParameters['strType'] = 'read';
    hshParameters['strStatus'] = 'read';
    hshParameters['arr_strKeyValues'] = arr_strValue;
    hshParameters['strToolbarButtons'] = null;

    if ( p_strTable != 'wbk' )
    {
        hshParameters['strFile'] = 'xmlWATree';
    }
    else
    {
        hshParameters['strFile'] = 'xmlWAWBKTree';
        hshParameters['blnDb'] = false;
        hshParameters['strConn'] = 'WA_DATA';
    }
    hshParameters['arr_strKeyFields'] = arr_strKey;
    hshParameters['strLabelWord1'] = 'person_details';
    hshParameters['strTranslate'] = '1_1_0';
    if ( p_strPersonData != null )
    {
        hshParameters['strLabelWord2'] = p_strPersonData;
    }

    var strPage = g_str_fOpenDialogWithTree( hshParameters );
    var hshData = new Object();

    if (  p_objWindow != null )
    {
          p_objWindow.location.href = strPage;
    }
    else
    {
         if ( p_strSizeType == null ) p_strSizeType = 'normal';
         var hshSizes;
         if ( g_objDialogWithTreeSizes.g_hshSizes[p_strSizeType] != null )
         {
             hshSizes = g_objDialogWithTreeSizes.g_hshSizes[p_strSizeType];
         }
         else
         {
             hshSizes = g_objDialogWithTreeSizes.g_hshSizes['normal'];
         }

         var hshPar = new Object();
         hshPar['window'] = window;
         hshData = openDialog(strPage, hshSizes['intMozDialogWidth'], hshSizes['intMozDialogHeight'], hshPar, 'no' );

        /*if ( cIE )
        {
           var hshPar = new Object();
           hshPar['window'] = window;
           hshData = openDialog( strPage, hshSizes['intIEDialogWidth'], hshSizes['intIEDialogHeight'], hshPar, 'no' );
        }
        else
        {
           var hshPar = new Object();
           hshPar['window'] = window;
           hshData = openDialog(strPage, hshSizes['intMozDialogWidth'], hshSizes['intMozDialogHeight'], hshPar, 'no' );
        }*/
    }
    return hshData;
}
//-----------------------------------------------------------------
/**
    Metodas sukonstruoja atitinkama URL pagal nurodytus parametrus.
    @param p_hshParameters parametru hashas:<br>
    <pre>
     p_hshParameters['strFile'] - tree file
     p_hshParameters['strType'] - ( 'edit', 'new' )
     p_hshParameters['arr_strKeyFields'] - key fields
     p_hshParameters['arr_strKeyValues'] - key values
     p_hshParameters['strToolbarButtons'] - 'save_saveClose'
     p_hshParameters['strPage'] - page to open first
     p_hshParameters['strStatus'] - status value
     p_hshParameters['strLabelWord1'] - label value first word ( ex. 'User_surname, name') ( first word - 'User', second word - 'surname, name')
     p_hshParameters['strLabelWord2'] - label value second word
     p_hshParameters['strTranslate'] - 1-translate, 0 - not ( status, label first word(ex. user), label second word (ex. name, surname), ex.'1_1_0'
     p_hshParameters['fOnSave'] - function that will be used if changes were saved correctly
 </pre>
    @returns sukonstruota atitinkama URL
    @type string
*/
function g_str_fOpenDialogWithTree( p_hshParameters )
{
    strValue = cABS_VIRTUAL_PATH + 'frmDialogWithTree.aspx';
    if ( p_hshParameters != null )
    {
        strValue += '?';
        if ( p_hshParameters['strPage'] != null )
            strValue += 'page=' + p_hshParameters['strPage'];

        if ( p_hshParameters['strFileType'] != null  )
            strValue += '&fileType=' + p_hshParameters['strFileType'];


        if ( p_hshParameters['strToolbarButtons'] != null  )
            strValue += '&toolbar=' + p_hshParameters['strToolbarButtons'];
        else
            strValue += '&toolbar=' + 'save_saveClose_help';

        if ( p_hshParameters['fOnSave'] != null  )
            strValue += '&java=' + p_hshParameters['fOnSave'];

        if ( p_hshParameters['strStatus'] != null  )
            strValue += '&status=' + p_hshParameters['strStatus'];

        if ( p_hshParameters['strLabelWord1'] != null  )
        {
            strValue += '&path=' + p_hshParameters['strLabelWord1'];
            if ( p_hshParameters['strLabelWord2'] != null  )
                strValue += '&path2=' + encode(p_hshParameters['strLabelWord2']);
        }

        if ( p_hshParameters['strTranslate'] != null  )
            strValue += '&lang=' + p_hshParameters['strTranslate'];

        if ( p_hshParameters['strFile'] != null  )
            strValue += '&file=' + p_hshParameters['strFile'];

        if ( p_hshParameters['strType'] != null  )
            strValue += '&type=' + p_hshParameters['strType'];

        if ( p_hshParameters['blnDb'] != null  )
            strValue += '&inDb=' + p_hshParameters['blnDb'];

        if ( p_hshParameters['strConn'] != null  )
            strValue += '&conn=' + p_hshParameters['strConn'];

        if ( (p_hshParameters['arr_strKeyFields'] != null ) && (p_hshParameters['arr_strKeyValues'] != null)  )
        {
            if ( (p_hshParameters['arr_strKeyFields'].length == p_hshParameters['arr_strKeyValues'].length) && (p_hshParameters['arr_strKeyFields'].length > 0) )
            {
                var strFields = '';
                for ( var i = 0; i < p_hshParameters['arr_strKeyFields'].length; i++ )
                {
                    if ( i > 0 )
                        strFields += '&';
                    strFields += p_hshParameters['arr_strKeyFields'][i] + '=' + encode(p_hshParameters['arr_strKeyValues'][i]);
                }
                strValue += '&fields=' + encode(strFields);
            }
        }
    }
    return( strValue );
}
//-----------------------------------------------------------------
/**
    Atidaro printToolsa ataskaitos spausdinimo rezime.
    @param p_strPrintPath printToolso url
    @param p_strDirectory spausdinimo sablono direktorija
    @param p_strFileName spausdinimo sablono failo vardas
    @param p_strParameters SQL sakinio WHERE dalis
    @param p_strConnectionString prisijungimas prie duomenu bazes
    @param p_strLang kalba, kuria uzkrauti printToolsa
*/
function g_fOpenPrintTool( p_strPrintPath, p_strDirectory, p_strFileName, p_strParameters, p_strConnectionString, p_strLang )
{
    if ( (p_strPrintPath != null) && (p_strFileName != null) )
    {
        var strPath = p_strPrintPath + 'print.aspx?fileName=' + encode(p_strFileName) + '&dir=' + p_strDirectory;
        //var strPath = cABS_VIRTUAL_PATH + 'print.aspx?fileName=' + encode(p_strFileName) + '&dir=' + p_strDirectory;
        if (p_strConnectionString != null)
            strPath += '&connection=' + encode(p_strConnectionString);
        if ((p_strParameters != null) && (p_strParameters != ''))
            strPath += '&parameter=' + encode(p_strParameters);
        if (p_strLang != null)
            strPath += '&lang=' + encode(p_strLang);
        var intWidth = window.screen.availWidth - 50;
        var intHeight = window.screen.availHeight - 100; //console(strPath);
        openWindow(strPath, window.screen.availWidth - 10, window.screen.availHeight - 50, null, null, 'printWindow', 'yes');
    }
}
//-----------------------------------------------------------------
/**
    Atidaro printToolsa sablono redagavimo rezime.
    @param p_strPrintPath printToolso url
    @param p_strDirectory spausdinimo sablono failo direktorija
    @param p_strFileName spausdinimo sablono failo vardas
    @param p_strLang sistemos naudojama kalba
*/
function g_fOpenPrintToolEdit( p_strPrintPath, p_strDirectory, p_strFileName, p_strLang)
{
    if ( ( p_strPrintPath != null ) && ( p_strFileName != null ) )
    {
        var strPath = p_strPrintPath + 'Default.aspx?fileName=' + encode(p_strFileName) + '&dir=' + p_strDirectory;
        if (p_strLang != null)
        {
            strPath += '&lang=' + encode(p_strLang);
        }
        var intWidth = window.screen.availWidth - 50;
        var intHeight = window.screen.availHeight - 100;
        openWindow(strPath, window.screen.availWidth - 10, window.screen.availHeight - 50, null, null, 'printWindow', 'yes');
    }
}

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

//  KM 2006-07-18
//  Funkcija, panaikinanti stiliaus taisykle i? visu u?loadintu css dokumentu
//  @p_strSelector - stiliaus selectorius.
//  Stiliaus selectoriai gali buti su ',' (kableliu), pvz.: 'TR.rowSelected TD, .gridHeaderOver DIV',
//  bet skirtingi, browseriai ji interpretuoja skirtingai:
//  FF - nuima stiliu, pagal tiksliai sutampanti selectoriu, t.y. jei bus stiliai
//      'TR.rowSelected TD, .gridHeaderOver DIV' ir 'TR.rowSelected TD', ir bus pasirinkta nuimti
//      'TR.rowSelected TD, .gridHeaderOver DIV' stiliu, tai jis pirma stiliu nuims, o antra paliks.
//      Jei bus u?duota nuimti stiliu 'TR.rowSelected TD', tai antrasis bus nuimtas, o pirmasis paliktas.
//  IE - stilius i?skaido pagal ',' ?enkla, todel, jei nurodoma nuimti 'TR.rowSelected TD, .gridHeaderOver DIV',
//      tai funkcija skaidys selectoriu i du ir atskirai nuims. Tokiu atveju bus nuimti abu stiliai.
function g_fRemoveStyle(p_strSelector)
{
    p_strSelector = p_strSelector.toLowerCase();
    if (cIE)
    {
        var arr_strSelectorTokens = p_strSelector.split(',');
        if (arr_strSelectorTokens.length > 1)                   //jei buvo rastas kablelis
        {
            for (var k = 0; k < arr_strSelectorTokens.length; k++)
            {
                g_fRemoveStyle(arr_strSelectorTokens[k]);       //tada ?od?iai apdorojami atskirai
            }
            return; // I?einam, nes stiliai bus prie? tai i?valyti
        }
    }

    var sheetList = document.styleSheets;
    var ruleList;
    var i, j;
    //  Pereinam per stiliu failus atvirk?cia tvarka, nei buvo importuoti
    for (i = sheetList.length-1; i >= 0; i--)
    {
        if (cIE)
            ruleList = sheetList[i].rules;
        if (cFF)
            ruleList = sheetList[i].cssRules;

        for (j=0; j<ruleList.length; j++)           // Pereinam per visas taisykles
        {
            if (((cFF && ruleList[j].type == CSSRule.STYLE_RULE) || (cIE)) &&
               ruleList[j].selectorText.toLowerCase() == p_strSelector) // jei stiliaus selectoriai sutampa
            {
                //consoleA('I?metam stiliu');
                if (sheetList[i].removeRule)            // IE
                    sheetList[i].removeRule(j);
                else if (sheetList[i].deleteRule)       // FF
                    sheetList[i].deleteRule(j);
                j--;
            }
        }
    }
}
//--------------------------------------------------------------------------------------
//  KM 2006-07-19
//  Funkcija, pridedanti stiliaus taisykle prie pirmo u?loadinto stiliaus failo
//  (Taciau i faila nei?sisaugo)
//  @p_strSelector - stiliaus selectorius.
//  @p_strStyle - CSS stilius.
function g_fAddStyle(p_strSelector, p_strStyle)
{
    var sheetList = document.styleSheets;
    var ruleList;
    var index;
    var sheetIndex = sheetList.length - 1;
    // Jei faile nebuvo nei vieno css failo, tai negalima prideti stiliaus
    if (sheetList.length == 0)
        return;

    if (cIE)
        ruleList = sheetList[sheetIndex].rules;
    if (cFF)
        ruleList = sheetList[sheetIndex].cssRules;

    index = ruleList.length;
    if (index < 0)
        index = 0;

    if (cFF)
    {
        sheetList[sheetIndex].insertRule(p_strSelector + '{' + p_strStyle + '}', index);
    }
    if (cIE)
    {
        sheetList[sheetIndex].addRule(p_strSelector, p_strStyle, index);
    }
}

//--------------------------------------------------------------------
/**
    Is xml objekto isgauna hashu masyva. Laukus atsirenka pati.
*/
function g_arr_hsh_fHashArrayFromXml(p_objXml)
{
    var arrChld = getChildren(p_objXml);
    arrChld = getChildren(arrChld[0]);

	var arr_hshResultArray = new Array();
    for (var j = 0; j < arrChld.length; j++)    // Per eilutes
    {
	    arrChld2 = getChildren(arrChld[j]);
	    var objRow = new Object();
	    for (var k = 0; k < arrChld2.length; k++)   // Per stulpelius
	    {
	        if(arrChld2[k].firstChild != null)
		        objRow[arrChld2[k].tagName] = arrChld2[k].firstChild.nodeValue;
		    else
		        objRow[arrChld2[k].tagName] = '';
		}
		arr_hshResultArray.push(objRow);
    }
    return arr_hshResultArray;
}
//--------------------------------------------------------------------------------------
//  KM 2006-07-19
//  Vietoj po nurodyto simbolio ar eilutes prideda zodzio kelimo taga
function g_str_fAddWordWraping(p_strWord, p_strCharacter)
{
    var objRegExp = new RegExp(p_strCharacter, 'g');
    return p_strWord.replace(objRegExp, p_strCharacter+'<wbr>');
}
//--------------------------------------------------------------------------------------
var g_strQuery = '';
var g_strDbString = null;
var g_fPrintingHandlerFunction = null;
/**
    Bendra funkcija skirta spausdinimui is duomenu bazes uzklausos
    @param p_strQuery  uzklausos parametrai
    @param p_objParams  objektas, kuris gali tur4ti uzsetintus siuos kintamuosius:<br>
    <pre>
        'preset' - saugomas preset id ir name junginys per '_'.
        'presetId' - saugomas preset id.
        'viewId' - saugomas view id.
        Galima neuzsetinti nei vieno, tada nebus galima redaguoti vaizdo sablonu.
    </pre>
    @param p_arr_hshBcPrintPresets  leidziamu pasirinkti sablonu masyvas
    @param p_strTitle - Print dialogo pavadinimas. Neverciamas
    @param p_intWhich - kuria duomenu baze naudoti, jei null arba 1, tai naudojama konfiguracijos db,
      kai 2, tai naudojama ginklu db.
*/
function g_fManagePrinting(p_strQuery, p_objParams, p_arr_hshBcPrintPresets, p_strTitle, p_strConnString, p_fFunction)
{
    g_strDBSelector = p_strConnString;
    g_strQuery = p_strQuery;
    g_fPrintingHandlerFunction = p_fFunction;
    g_objPrintDialog.g_fOpen(null, null, p_objParams, p_arr_hshBcPrintPresets , g_fCompletePrintingSelection, p_strTitle);
}


//--------------------------------------------------------------------------------------
/**
    Funkcija, kvieciama pasirinkus sablona ir patvirtinus spausdinima.
    @param p_hshAts duomenys reikalingi perduoti i printToolsa
*/
function g_fCompletePrintingSelection(p_hshAts)
{
    if (typeof (g_fPrintingHandlerFunction) == 'function')
        g_fPrintingHandlerFunction(p_hshAts);
    if (p_hshAts == null)
        return;
    var arr_strDalys = cCONN_STRINGS.split('*');
    var hshConnStrings = new Object();
    for(var i = 0;i < arr_strDalys.length;i++)
    {
        var arr_strDalysTemp = arr_strDalys[i].split('^');
        hshConnStrings['[' + arr_strDalysTemp[0] + ']'] = arr_strDalysTemp[1];
    }
    var strConnString = '';
    switch(g_strDBSelector)
    {
        case '[confCmcDbString]': strConnString = cCMC_CONN_STRING; break;
        case '[confWaffenDbString]': strConnString = cWAFFEN_CONN_STRING; break;
        case '[confLbfDbString]': strConnString = cLBF_CONN_STRING; break;
        default : strConnString = cCMC_CONN_STRING; break;
    }
    if(hshConnStrings[g_strDBSelector] != null)
        strConnString = hshConnStrings[g_strDBSelector];
    if(p_hshAts != null)
        g_fOpenPrintTool( cPRINT_TOOL_PATH, cREPORT_SAVE_DIR, p_hshAts['PPFilename'], g_strQuery, strConnString, cLANG);
}
//--------------------------------------------------------------------------------------
/**
    Funkcija, nuimanti tolesni ivykio vykdyma.
    @param e {Event} ivykis, kuri reikia stabdyti.
    @param p_blnAllowPropagation {bool} Ar leisti ivykiui toliau plisti.
    @param p_blnAllowDefault {bool} Ar leisti ivykdyti standartine narsykles funkcija.
    @author KM
    @version 2 2006-10-17
*/
if (cFF)    // FF
{
    function g_fStopEvent(e, p_blnAllowPropagation, p_blnAllowDefault)
    {
        if (!p_blnAllowPropagation) // Jei neleidziame toliau plisti
        {
            e.stopPropagation();
        }
        if (!p_blnAllowDefault)     // Jei neleidziame ivykdyti standartines narsykles funkcijos
        {
            e.preventDefault();
        }
    }
}
else        // IE ir kiti browseriai
{
    function g_fStopEvent(e, p_blnAllowPropagation, p_blnAllowDefault)
    {
        if (!p_blnAllowPropagation) // Jei neleidziame toliau plisti
        {
            e.cancelBubble = true;
        }
        if (!p_blnAllowDefault)     // Jei neleidziame ivykdyti standartines narsykles funkcijos
        {
            if (e.keyCode != 17 && e.keyCode != 16) // jei paspausta ne shift ir ne ctrl (ju kodu keisti negalima)
            {
             // RG 2006 11 02
                e.keyCode = 0 - e.keyCode;      // Tai pakeiciamas paspaudimo kodas
            }
            e.returnValue = false;
        }
    }
}
//function g_fStopEvent(e, p_blnAllowPropagation, p_blnAllowDefault)
//{
//    if (!p_blnAllowPropagation) // Jei neleidziame toliau plisti
//    {
//        if (e.stopPropagation)  // FF
//            e.stopPropagation();
//        else                    // IE
//            e.cancelBubble = true;
//    }
//    if (!p_blnAllowDefault)     // Jei neleidziame ivykdyti standartines narsykles funkcijos
//    {
//        if (e.preventDefault)   // FF
//            e.preventDefault();
//        else                    // IE
//        {
//            if (e.keyCode != 17 && e.keyCode != 16) // jei paspausta ne shift ir ne ctrl (ju kodu keisti negalima)
//            {
//             // RG 2006 11 02
//                e.keyCode = 0 - e.keyCode;      // Tai pakeiciamas paspaudimo kodas
//            }
//            e.returnValue = false;
//        }
//    }
//}
//--------------------------------------------------------------------------------------
/**
    KM 2006-07-31 Uzkoduoja dvimati stringu masyva siuntimui i URL.
    Skyrikliai paimami is konstantu cDELIM1 ir cDELIM2.
*/
function g_str_fEncodeArray(p_arr_arr_strInput)
{
    var strReturn = '';
    for (var i = 0; i < p_arr_arr_strInput.length; i++)
    {
        for (var j = 0; j < p_arr_arr_strInput[i].length; j++)
        {
            strReturn += encode(p_arr_arr_strInput[i][j]);
            if (j != p_arr_arr_strInput[i].length - 1)
            {
                strReturn += encode(cDELIM2);
            }
        }
        if (i != p_arr_arr_strInput.length - 1)
        {
            strReturn += encode(cDELIM1);
        }
    }
    return strReturn;
}
//--------------------------------------------------------------------------------------
/**
    Pagal paduota hash objekta suformuoja URL parametru eilute - '?[param1]=[val1]&[param2]=[val2]&...'
    @param p_hshInput duomen? hashas
    @returns suformuot? duomen? eilut?, skirt? perduoti per GET
    @type string
*/
function g_str_fBuildURLParameterString(p_hshInput)
{
    var strParameters = '';
    for(strKey in p_hshInput)
    {
        if (strParameters == '')
            strParameters += '?';
        else
            strParameters += '&';
        strParameters += strKey + '=' + encode(p_hshInput[strKey]);
    }
    return strParameters;
}
//--------------------------------------------------------------------------------------
function g_hsh_fDecodeURLParameterString(p_strParameterString)
{
    var hshAts = new Object();
    var arr_strPairs = p_strParameterString.split('?')[1].split('&');
    for(var i = 0;i < arr_strPairs.length;i++)
    {
        var arr_strItems = arr_strPairs[i].split('=');
        hshAts[arr_strItems[0]] = decode(arr_strItems[1]);
    }
    return(hshAts);
}
//--------------------------------------------------------------------------------------
/**
    Atidaro pagalbos sistema ir uzkrauna nurodyta pagalbos faila.
    @param p_strLang kalbos trumpinys kuria reikia uzkrauti helpa
    @param p_strFilename pagalbos failo vardas
*/
function g_fOpenHelp(p_strLang, p_strFilename)
{
   openWindow(cHELP_TOOL_PATH + 'help.aspx?lang=' + p_strLang +'&path=' + cHELP_DIR + '&file=' + p_strFilename, 400, 600, 100, 100, 'helpCmcMain', 'yes');
}
//--------------------------------------------------------------------------------------
/**
    Paduota kelia isskaido i direktorija ir failo varda.
    @param p_strPath kelias iki failo
    @param p_strDelimiter skirtukas pagal kuri skaidyti
    @returns Grazinamas formatas [direktorija, failoVardas]
    @type string[]
*/
function g_str_fSplitPath(p_strPath, p_strDelimiter)
{
    var arr_strTokens = p_strPath.split(p_strDelimiter);
	var strFileName = arr_strTokens[arr_strTokens.length - 1];
	var strPath = p_strPath.substring(0, p_strPath.length - strFileName.length);
    return [strPath, strFileName];
}
//--------------------------------------------------------------------------------------
/**
    Kopijuoja paduota objekta isskiriant nauja atminti
    @author Kestutis Malinauskas
    @param p_objInput Objektas, kuri reikia kopijuoti
    @returns Nukopijuota objekta
    @type object
*/
function g_obj_fClone(p_objInput)//, p_blnTest)
{
	if(typeof(p_objInput) != 'object')
	{
	    if (p_objInput && p_objInput.constructor == RegExp)
	    {
	        return new RegExp(p_objInput);
	    }
	    return p_objInput;
	}
	if(p_objInput == null) return p_objInput;
	var strFTypeOf = ftypeof(p_objInput);
	if (strFTypeOf == 'domelement')
	{
	    return p_objInput.cloneNode(true);
	}

    var objReturn;
    var fConstructor = p_objInput.constructor;
    if( fConstructor != null )
	{
		switch( fConstructor )
		{
			case Array:
			    objReturn = new Array();
				break;
			case Date:
			    return new Date(+p_objInput);
			case Object:
				objReturn = new Object();
				break;
			default:
				if (typeof(p_objInput.g_obj_fClone) == 'function')
				{
				    return p_objInput.g_obj_fClone();
				}
				else
				{
				    var sConstructor = fConstructor.toString();
				    var aMatch = sConstructor.match( /\s*function (.*)\(/ );
				    if( aMatch != null )
				    {
					    objReturn = new fConstructor();
				    }
				    else
				    {
				        objReturn = new Object();
				    }
				}

		}
	}
	//	if (p_objInput.length != null)
//	    objReturn = new Array();
//	else
//	    objReturn = new Object();
	for(var i in p_objInput)
    {
        objReturn[i] = g_obj_fClone(p_objInput[i]);
    }
//	if (!p_blnTest)
//	{
//
//	}
//	else
//	{
//        console('Clone apacia');
//	    for(var i in p_objInput)
//	    {
//    	    //if (typeof p_objInput[i] != 'function' && ftypeof(p_objInput[i]) != null && ftypeof(p_objInput[i]) != 'null')
//
////            console('i - ' + i);
////            console(p_objInput[i]);
//
//            try
//            {
//                objReturn[i] = g_obj_fClone(p_objInput[i]);
//            }
//            catch(exc)
//            {
//                console('Buvo klaida');
//                console('Catch vidus');
//                console(typeof i);
//                console(i);
//                console(ftypeof(p_objInput[i]));
//                console(typeof(p_objInput[i]));
//                console(p_objInput[i]);
//                console('--');
//                if (p_objInput[i] == null)
//                    console('p_objInput[i] yra null');
//                if (objReturn == null || typeof objReturn == 'undefined')
//                    console('objReturn yra null');
//            }
//        }
//	}
	return objReturn;
}
//--------------------------------------------------------------------------------------
/**
    Objektu, kurie turi < operatoriu palyginimas. Rikiuojant skaiciu masyvus reiketu ja nurodyti
    sort funkcijos parametre. Jeigu reikia lyginti pagal tam tikra lauka arba pagal kelis, tai reiktu
    pasirasyti panasia funkcija.
    @author Kestutis Malinauskas
    @param p_objA Palyginamas objektas A.
    @param p_objB Palyginamas objektas B.
    @returns Jei A < B, tai grazins neigiama skaiciu(-2), jei A = B - grazins 0, jei A > B - grazins teigiama skaiciu (2)
    @type int
*/
function g_int_fComparator(p_objA, p_objB)
{
    return (p_objB < p_objA) - (p_objA < p_objB);
}
//--------------------------------------------------------------------------------------
/**
    Skirtas dinaminiam vertimui.
*/
function g_fDynaTranslate(p_objElement)
{
    var objData = new Object();
    objData['project'] = 'CMC';
    objData['file'] = cLANG_PATH;
    objData['tag'] = p_objElement.innerHTML;
    var hshRet = openDialog(cLANG_TOOL_PATH + 'forms/frmTagEdit.aspx', 400, 500, objData, 'no');
    if(hshRet != null)
    {
        if(p_objElement != null && p_objElement.innerHTML)
        {
            p_objElement.innerHTML = hshRet[cLANG];
        }
    }
}
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
/**
    Funkcija, kuri vercia int reiksme i stringa pridedant 'px'. Jei reiksme yra eilute, su px,
    tai nieko nepakeicia.
    @param p_intValue{string}{number} Reiksme, kuria reikia paversti.
    @returns Eilute su pridetu px.
*/
function g_str_fIntToPx(p_intValue)
{
    return parseInt(p_intValue) + 'px';
}

var g_objConsole = new clsConsole();

/**
    Klase skirta string eiluciu rasymui i konsoles langeli.
    Reikia labai tobulinti, bet konsole yra labai gera visokiu focus ivykiu sekimui,
    kai negalima prarasti focuso is elemento.
    @author Kestutis Malinauskas
    @version 1 2006.09.27
    @constructor
*/
function clsConsole()
{
    /**
        @private
        @type int
    */
    var cHeight = 400;
    var cWidth = 200;
    var strHeight = cHeight;
    var strWidth = cWidth;
    var strOldHeight;
    var strOldWidth;

    var blnInlineMounted = false;
    var blnWindowMounted = false;
    var objThis = this;
    var objWindow = null;
    var objWindowDiv = null;
    var intMaxSimbolCount = 20000;
    var objParentElement = null;
    var intDepth = 8;
    var blnShowFunctions = false;
    var blnDragResizeAdded = false;
    var blnMinimized = false;
    var blnCanOpen = true;



    //-----------------------------------------------
    /**

    */
    this.g_fMount = function(p_objParentElement)
    {
        if (!blnCanOpen) return;
        if (blnInlineMounted) return;
        if (p_objParentElement == null)
        {
            p_objParentElement = document.body;
        }
        objParentElement = p_objParentElement;
        var objTable = document.createElement('TABLE');
        objTable.id = 'console_table';
        objTable.style.border = '1px solid navy';
        objTable.style.position = 'absolute';
        objTable.style.zIndex = '2000';
        var intLeft = g_fGetViewportWidth() - strWidth - 10;
        var intLeft = intLeft > 0 ? intLeft : 0;
        objTable.style.left = intLeft + 'px';
        objTable.style.top = '10px';

        objTable.cellSpacing = 0;
        objTable.cellPadding = 0;
        p_objParentElement.appendChild(objTable);

        var objRow = objTable.insertRow(0);
        var objCell = objRow.insertCell(0);
        objCell.style.backgroundColor = 'Navy';
        objCell.innerHTML = '<span style="padding:2px;">Console</span>';
        objCell.style.color = 'white';
        objCell.style.height = '20px';
        objCell.style.verticalAlign = 'middle';
        //objCell.style.padding = '2px';
        objCell.id = 'console_header';
        objCell.style.width = '120px';

        objCell = objRow.insertCell(1);
        objCell.style.backgroundColor = 'Navy';
        objCell.style.height = '20px';
        objCell.style.width = '80px';
        objCell.style.verticalAlign = 'middle';
        objCell.style.textAlign = 'right';
        //objCell.style.padding = '2px';

        var objTitleImage = document.createElement('IMG');
		objTitleImage.id = 'consoleClipImg';
		//objTitleImage.src = cIMAGE_PATH + '14_clipboard.gif';
		objTitleImage.style.margin = '1px';
		objTitleImage.title = 'Copy content to clipboard';
		objCell.appendChild(objTitleImage);
		addEvent(objTitleImage, 'click', fCopy);

		objTitleImage = document.createElement('IMG');
		objTitleImage.id = 'consoleMiniImg';
		//objTitleImage.src = cIMAGE_PATH + '14_minimize.gif';
		objTitleImage.style.margin = '1px';
		objTitleImage.title = 'Minimize';
		objCell.appendChild(objTitleImage);
		addEvent(objTitleImage, 'click', fMinimize);

		objTitleImage = document.createElement('IMG');
		objTitleImage.id = 'consoleMaxiImg';
		//objTitleImage.src = cIMAGE_PATH + '14_maximize.gif';
		objTitleImage.style.margin = '1px';
		//objTitleImage.style.display = 'none';
		objTitleImage.title = 'Maximize';
		objCell.appendChild(objTitleImage);
		addEvent(objTitleImage, 'click', fMaximize);

		objTitleImage = document.createElement('IMG');
		objTitleImage.id = 'consoleCloseImg';
		//objTitleImage.src = cIMAGE_PATH + '14_close2.gif';
		objTitleImage.style.margin = '1px';
		objTitleImage.title = 'Close console';
		objCell.appendChild(objTitleImage);
		addEvent(objTitleImage, 'click', fClose);

		objTitleImage = document.createElement('IMG');
		objTitleImage.id = 'consoleClosePermImg';
		//objTitleImage.src = cIMAGE_PATH + '14_close_red.gif';
		objTitleImage.style.margin = '1px';
		objTitleImage.title = 'Close console permanently';
		objCell.appendChild(objTitleImage);
		addEvent(objTitleImage, 'click', fClosePerm);
		fSetButtonState(blnMinimized);

        objRow = objTable.insertRow(1);
        objCell = objRow.insertCell(0);
        objCell.colSpan = 2;
        objCell.style.backgroundColor = 'Navy';
        var objDiv = document.createElement('DIV');
        objDiv.id = 'console_div';
        objDiv.style.height = strHeight + 'px';
        objDiv.style.width = strWidth + 'px';
        objDiv.style.overflow = 'auto';
        objDiv.style.backgroundColor = 'white';
        objDiv.style.padding = '2px';
        objCell.appendChild(objDiv);
        blnInlineMounted = true;
        if (objEditor2 != null && typeof(objEditor2) != 'undefined' && objEditor2.g_fAddDrag)
		{
			objEditor2.g_fAddDrag('console_header', 'console_table');
			objEditor2.g_fAddResize('console_div', 200, 0, fOnResize);
			blnDragResizeAdded = true;
		}
    }


    this.g_fSetSize = function(p_intLeft, p_intTop, p_intWidth, p_intHeight)
    {
        var objDiv = document.getElementById('console_table');
        if (p_intLeft != null && !isNaN(p_intLeft))
        {
            objDiv.style.left = p_intLeft + 'px';
        }
        if (p_intTop != null && !isNaN(p_intTop))
        {
            objDiv.style.top = p_intTop + 'px';
        }
        objDiv = document.getElementById('console_div');
        if (p_intWidth != null && !isNaN(p_intWidth))
        {
            strWidth = p_intWidth;
            objDiv.style.width = strWidth + 'px';
        }
        if (p_intHeight != null && !isNaN(p_intHeight))
        {
            strHeight = p_intHeight;
            objDiv.style.height = strHeight + 'px';
        }
    }

    this.g_fSetShowFunctions = function(p_blnValue)
    {
        blnShowFunctions = p_blnValue;
    }

    this.g_bln_fGetShowFunctions = function()
    {
        return blnShowFunctions;
    }

    function fSetButtonState(p_blnMinimized)
    {
        if (p_blnMinimized)
        {
            document.getElementById('consoleMaxiImg').style.display = '';
            document.getElementById('consoleMiniImg').style.display = 'none';
        }
        else
        {
            document.getElementById('consoleMaxiImg').style.display = 'none';
            document.getElementById('consoleMiniImg').style.display = '';
        }
    }

    function fCopy()
    {
        var objDiv = document.getElementById('console_div');
        if (!objDiv)
            return;
//        var strText = g_str_fInnerText(objDiv);
//        g_fCopyToClipboard(strText);
        var arr_objChildren = objDiv.childNodes;
        var strText = '';
        for (var i = 0, intLength = arr_objChildren.length; i < intLength; i++)
        {
            var objItem = arr_objChildren[i];
            if (objItem.nodeType == '1') // jei elementai
            {
                if (objItem.nodeName.toLowerCase() == 'br')
                {
                    strText += '\n';
                }
                else
                {
//                  g_str_fInnerXML(objItem));
                    strText += g_str_fInnerText(objItem);
                }
            }
            else
            {
                strText += objItem.nodeValue;
            }
        }
        strText = strText.replace(/(\r\n|\n)/g, '\r\n'); // cia del to, kad windowsai vieno \n nelaiko naujos eilutes zenklu
        g_fCopyToClipboard(strText);
    }

    function fMinimize()
    {
        strOldHeight = strHeight;
        strOldWidth = strWidth;
        if (cIE)
        {
            document.getElementById('console_div').style.display = 'none';
//            fResize(200, 1);
//            document.getElementById('console_div').style.backgroundColor = 'Navy';
//            document.getElementById('console_div').style.overflow = 'hidden';
        }
        if (cFF)
            fResize(200, 0);
        document.getElementById('console_div').style.padding = '0px';
        blnMinimized = true;
        if (cIE)
        {
            document.getElementById('console_div').style.height = '1px';
        }
        fSetButtonState(blnMinimized);

//        if (cFF)
//            fResize(200, 20);
    }

    function fMaximize()
    {
        blnMinimized = false;
        fResize(strOldWidth, strOldHeight);
        document.getElementById('console_div').style.padding = '2px';
        fSetButtonState(blnMinimized);
        if (cIE)
        {
            document.getElementById('console_div').style.display = '';
//            document.getElementById('console_div').style.backgroundColor = 'White';
//            document.getElementById('console_div').style.overflow = 'auto';
        }
    }

    function fClose()
    {
        objThis.g_fUnmount(true);
    }

    this.g_fClose = function()
    {
        fClose();
    }

    function fClosePerm()
    {
        objThis.g_fUnmount(true);
        blnCanOpen = false;
    }

    this.g_fClosePerm = function()
    {
        fClosePerm();
    }

    this.g_fOpenWindow = function()
    {
        if (blnWindowMounted) return;
        // Ant FF sita vieta neveikia gerai
        objWindow = window.open();
        objWindowDiv = objWindow.document.createElement('DIV');
        objWindow.document.body.appendChild(objWindowDiv);
        blnWindowMounted = true;
    }

    this.g_fUninit = function()
    {
        objThis.g_fUnmount();
        if (objEditor2 != null && typeof(objEditor2)!= 'undefined' && objEditor2.g_fUninnit &&  blnDragResizeAdded)
        {
            objEditor2.g_fUninnit();
        }
    }

    function fOnResize(p_strX, p_strY)
    {
        if (p_strX != null && !isNaN(p_strX))
        {
            strWidth = p_strX;
        }
        if (p_strY != null && !isNaN(p_strY))
        {
            strHeight = p_strY;
        }
    }

    function fResize(p_strX, p_strY, p_strLeft, p_strTop)
    {
        var objDiv = document.getElementById('console_div');
        if (p_strX != null && !isNaN(p_strX))
        {
            strWidth = p_strX;
            objDiv.style.width = strWidth + 'px';
        }
        if (p_strY != null && !isNaN(p_strY))
        {
            strHeight = p_strY;
            objDiv.style.height = strHeight + 'px';
        }
    }

    this.g_fUnmount = function(p_blnLeaveWindow, p_blnLeaveInline)
    {
        if (blnWindowMounted && !p_blnLeaveWindow)
        {
            objWindow.close();
            blnWindowMounted = false;
        }
        if (blnInlineMounted && !p_blnLeaveInline)
        {
            var objTable = document.getElementById('console_table');
            if (objTable)
            {
                var objTitleImage = document.getElementById('consoleMiniImg');
                removeEvent(objTitleImage, 'click', fClose);
                objTitleImage = document.getElementById('consoleCloseImg');
                removeEvent(objTitleImage, 'click', fClose);
                objTitleImage = document.getElementById('consoleClosePermImg');
                removeEvent(objTitleImage, 'click', fClose);
                objTitleImage = document.getElementById('consoleMaxiImg');
                removeEvent(objTitleImage, 'click', fClose);
                var parNode = objTable.parentNode;
                if (parNode)
                {
                    parNode.removeChild(objTable);
                }
            }
            blnInlineMounted = false;
        }
    }

    this.g_fPrintLine = function(p_objItem, p_blnWindow)
    {
        var strAlert = str_fConstruct(p_objItem, 1, '');
        if (typeof(strAlert) != typeof(p_objItem) || strAlert != p_objItem) // KM 07.06.26 ant IE mesdavo klaida, kai p_objItem budavo XML nodas
        {
            strAlert = '<pre>' + strAlert + '</pre>';
        }
        if (p_blnWindow)
        {
            if (blnWindowMounted)
            {
                if (objWindow && objWindow.document)
                {
                    fInsertText(objWindowDiv, strAlert);
                    objWindow.document.body.scrollTop = objWindow.document.body.scrollHeight;
                }
                else
                {
                    blnWindowMounted = false;
                    this.g_fOpenWindow();
                    this.g_fPrintLine(strAlert, true);
                }
            }
        }
        else
        {
            if (blnInlineMounted)
            {
                var objDiv = document.getElementById('console_div');
                if (objDiv)
                {
                    fInsertText(objDiv, strAlert);
                    objDiv.scrollTop = objDiv.scrollHeight;
                }
                else
                {
                    blnInlineMounted = false;
                    this.g_fMount(objParentElement);
                    this.g_fPrintLine(strAlert, false);
                }
            }
        }
    }

    this.g_fAlertLine = function(p_objItem)
    {
        var strAlert = str_fConstruct(p_objItem, 1, '');
        alert(strAlert);
    }

    function fInsertText(p_objNode, p_strText)
    {
        // Kol tekstas netelpa i konsole, tai is jos po viena vaika meta laukan
        while (p_objNode.innerHTML.length > intMaxSimbolCount)
        {
            p_objNode.removeChild(p_objNode.firstChild);
        }
        p_objNode.innerHTML += p_strText + '<br/>';
//                var intLength = objWindowDiv.innerHTML.length;
//                if (intLength > intMaxSimbolCount)
//                {
//                    objWindowDiv.innerHTML = objWindowDiv.innerHTML.substring(intLength - intMaxSimbolCount);
//                }
    }

    this.g_fClear = function()
    {
        if (blnWindowMounted)
        {
            if (objWindow)
            {
                objWindow.document.body.innerHTML = '';
            }
        }
        else
        {
            var objDiv = document.getElementById('console_div');
            if (objDiv)
            {
                objDiv.innerHTML = '';
            }
        }
    }

    this.g_bln_fIsMounted = function(blnWindow)
    {
        if (blnWindow)
            return blnWindowMounted;
        else
            return blnInlineMounted;
    }

    this.g_str_fConstruct = function (p_objItem)
    {
       return str_fConstruct(p_objItem, 1, '') ;
    }

    //-----------------------------------------------
    /**
        Rekursine funkcija naudojama spaudinti elemento vaikus.
        @param p_objItem - tevinis elementas kurio vaikus nagrin?jame.
        @param p_intLevel - siuo metu esantis nagrinejimo lygis.
        @param p_strPad - paddingo eilute siam lygiui.
        @returns Sukonstruota HTML eilute, vaizduojancia objekto struktura.
        @type string
    */
    function str_fConstruct(p_objItem, p_intLevel, p_strPad)
    {
        var strNewPad = p_strPad + '    ';
        if(p_intLevel == intDepth)
            return('');
        var strAts = '';
        var strType = ftypeof(p_objItem);
        //strAts += strType + '\n';
        switch(strType)
        {
            case 'jsobject': for(strKey in p_objItem)
                        {
                            var strChildType = ftypeof(p_objItem[strKey]);
                            if( strKey == ('g_objParent') && strChildType == 'jsobject')
                            {
                                strAts += '\n' + p_strPad + '[\'' + strKey + '\']: ' + '[...]';
                            }
                            else
                            if(strChildType != 'function' || blnShowFunctions)
                            {
                                //strAts += '\n' + strChildType;
                                strAts += '\n' + p_strPad + '[\'' + strKey + '\']:  ' + str_fConstruct(p_objItem[strKey], p_intLevel + 1, strNewPad);
                            }
                        }
                        break;

            case 'array':
                        strAts += 'Array:';
//                        for(var intKey in p_objItem)
//                        {
//                            if (g_bln_fIsInt(intKey) && typeof (p_objItem[intKey]) != 'undefined')
//                                strAts += '\n' + p_strPad + '[' + intKey + ']: ' + str_fConstruct(p_objItem[intKey], p_intLevel + 1, strNewPad);
//                        }
                        for(var i = 0, intLength = p_objItem.length; i < intLength; i++)
                        {
                            if (typeof (p_objItem[i]) != 'undefined')
                                strAts += '\n' + p_strPad + '[' + i + ']: ' + str_fConstruct(p_objItem[i], p_intLevel + 1, strNewPad);
                        }
                        break;
            case 'domelement': strAts += 'DOM Element:' + str_fConstructDom(p_objItem, p_intLevel, p_strPad);

                      break;
            case 'event': strAts += 'DOM Event:' + str_fConstructEvent(p_objItem, p_intLevel, p_strPad);

                      break;
            case 'function': if (blnShowFunctions) strAts += 'function(){...}';
                      break;
            default :
                if (p_objItem)
                {
                    if (p_objItem.replace) //Jei cia buvo stringas
                    {
                        strAts += p_objItem.replace(/>/g, '&gt;').replace(/</g, '&lt;');
                    }
                    else
                    {
                        strAts += p_objItem.toString();
                    }
                }
                else
                {
                    strAts += p_objItem;
                }
                break;
        }
        return(strAts);
    }

    function str_fConstructEvent(p_objItem, p_intLevel, p_strPad)
    {
        var strNewPad = p_strPad + '    ';
        var strResult = '';
        p_strPad = strNewPad;
        strResult += '\n' + p_strPad + 'type: ' + p_objItem.type;
        strResult += '\n' + p_strPad + 'clientX: ' + p_objItem.clientX;
        strResult += '\n' + p_strPad + 'clientY: ' + p_objItem.clientY;
        strResult += '\n' + p_strPad + 'screenX: ' + p_objItem.screenX;
        strResult += '\n' + p_strPad + 'screenY: ' + p_objItem.screenY;
        strResult += '\n' + p_strPad + 'offsetX: ' + p_objItem.offsetX;
        strResult += '\n' + p_strPad + 'offsetY: ' + p_objItem.offsetY;
        strResult += '\n' + p_strPad + 'layerX: ' + p_objItem.layerX;
        strResult += '\n' + p_strPad + 'layerY: ' + p_objItem.layerY;
        strResult += '\n' + p_strPad + 'pageX: ' + p_objItem.pageX;
        strResult += '\n' + p_strPad + 'pageY: ' + p_objItem.pageY;
        strResult += '\n' + p_strPad + 'x: ' + p_objItem.x;
        strResult += '\n' + p_strPad + 'y: ' + p_objItem.y;
        strResult += '\n' + p_strPad + 'button: ' + p_objItem.button;
        strResult += '\n' + p_strPad + 'keyCode: ' + p_objItem.keyCode;
        strResult += '\n' + p_strPad + 'charCode: ' + p_objItem.charCode;
        strResult += '\n' + p_strPad + 'which: ' + p_objItem.which;
        strResult += '\n' + p_strPad + 'altKey: ' + p_objItem.altKey;
        strResult += '\n' + p_strPad + 'ctrlKey: ' + p_objItem.ctrlKey;
        strResult += '\n' + p_strPad + 'shiftKey: ' + p_objItem.shiftKey;
        strResult += '\n' + p_strPad + 'metaKey: ' + p_objItem.metaKey;
        strResult += '\n' + p_strPad + 'cancelBubble: ' + p_objItem.cancelBubble;
        strResult += '\n' + p_strPad + 'bubbles: ' + p_objItem.bubbles;
        strResult += '\n' + p_strPad + 'cancelable: ' + p_objItem.cancelable;
        strResult += '\n' + p_strPad + 'eventPhase: ' + p_objItem.eventPhase;
        strResult += '\n' + p_strPad + 'returnValue: ' + p_objItem.returnValue;
        strResult += '\n' + p_strPad + 'reason: ' + p_objItem.reason;
        strResult += '\n' + p_strPad + 'timestamp: ' + p_objItem.timestamp;
        strResult += '\n' + p_strPad + 'srcElement: ' + str_fConstruct(p_objItem.srcElement, p_intLevel + 1, strNewPad);
        strResult += '\n' + p_strPad + 'currentTarget: ' + str_fConstruct(p_objItem.currentTarget, p_intLevel + 1, strNewPad);
        strResult += '\n' + p_strPad + 'relatedTarget: ' + str_fConstruct(p_objItem.relatedTarget, p_intLevel + 1, strNewPad);
        strResult += '\n' + p_strPad + 'srcFilter: ' + str_fConstruct(p_objItem.srcFilter, p_intLevel + 1, strNewPad);
        strResult += '\n' + p_strPad + 'fromElement: ' + str_fConstruct(p_objItem.fromElement, p_intLevel + 1, strNewPad);
        strResult += '\n' + p_strPad + 'toElement: ' + str_fConstruct(p_objItem.toElement, p_intLevel + 1, strNewPad);
        strResult += '\n' + p_strPad + 'target: ' + str_fConstruct(p_objItem.target, p_intLevel + 1, strNewPad);
        return strResult;
    }

    function str_fConstructDom(p_objItem, p_intLevel, p_strPad)
    {
        var strNewPad = p_strPad + '    ';
        var strResult = '';
        p_strPad = strNewPad;
        strResult += '\n' + p_strPad + 'id: ' + p_objItem.id;
        strResult += '\n' + p_strPad + 'className: ' + p_objItem.className;
        strResult += '\n' + p_strPad + 'nodeName: ' + p_objItem.nodeName;
        strResult += '\n' + p_strPad + 'nodeType: ' + p_objItem.nodeType;
        strResult += '\n' + p_strPad + 'nodeValue: ' + p_objItem.nodeValue;
        strResult += '\n' + p_strPad + 'tabIndex: ' + p_objItem.tabIndex;
        strResult += '\n' + p_strPad + 'tagName: ' + p_objItem.tagName;
        strResult += '\n' + p_strPad + 'title: ' + p_objItem.title;
        strResult += '\n' + p_strPad + 'readOnly: ' + p_objItem.readOnly;
        strResult += '\n' + p_strPad + 'disabled: ' + p_objItem.disabled;
        strResult += '\n' + p_strPad + 'type: ' + p_objItem.type;
        strResult += '\n' + p_strPad + 'clientWidth: ' + p_objItem.clientWidth;
        strResult += '\n' + p_strPad + 'clientHeight: ' + p_objItem.clientHeight;
        strResult += '\n' + p_strPad + 'offsetLeft: ' + p_objItem.offsetLeft;
        strResult += '\n' + p_strPad + 'offsetTop: ' + p_objItem.offsetTop;
        strResult += '\n' + p_strPad + 'offsetWidth: ' + p_objItem.offsetWidth;
        strResult += '\n' + p_strPad + 'offsetHeight: ' + p_objItem.offsetHeight;
        strResult += '\n' + p_strPad + 'scrollLeft: ' + p_objItem.scrollLeft;
        strResult += '\n' + p_strPad + 'scrollTop: ' + p_objItem.scrollTop;
        strResult += '\n' + p_strPad + 'scrollWidth: ' + p_objItem.scrollWidth;
        strResult += '\n' + p_strPad + 'scrollHeight: ' + p_objItem.scrollHeight;
        strResult += '\n' + p_strPad + 'style: ' + str_fConstruct(p_objItem.style, p_intLevel + 1, strNewPad);
        strResult += '\n' + p_strPad + 'dir: ' + p_objItem.dir;
        strResult += '\n' + p_strPad + 'lang: ' + p_objItem.lang;
        return strResult;
    }


    //-----------------------------------------------
    /**
        Sulipdo atitinkamo lygio atitraukimo nuo kaires eilute.
        @param p_intLevel Atitraukimo lygis.
        @returns Grazina paddingo eilute.
        @type string
    */
    function str_fGetPad(p_intLevel)
    {
        var strPad = '';
        for(var i = 0;i < p_intLevel;i++)
            strPad += '    ';
        return(strPad);
    }

    this.g_fSetLevel = function(p_intLevel)
    {
        if (p_intLevel != null)
        {
            intDepth = p_intLevel;
        }
    }


    addEvent(window, 'unload', this.g_fUninit);
}

/**
    Funkcija rasymui i konsole. Ji automatiskai prideda ir parodo konsoles langa, bei atspausdina i ji paduota
    eilute.
    @param p_strInput {string} Tekstas, kuri reikia atspausdinti.
*/
function console(p_strInput, p_intLevel)
{
    if (!g_blnShowConsole) return;
    if (!document.body)
        return consoleA(p_strInput, p_intLevel);
    if (window.parent != window && parent.console != null)
    {
        parent.console(p_strInput, p_intLevel);
        return;
    }
    if (!g_objConsole.g_bln_fIsMounted())
    {
        g_objConsole.g_fMount();
    }
    g_objConsole.g_fSetLevel(p_intLevel);
    g_objConsole.g_fPrintLine(p_strInput, false);
}

/**
    console funkcijos sinonimas
    @author KM
    @version 1 2006-10-12
*/
function o(p_strInput, p_intLevel)
{
    console(p_strInput, p_intLevel)
}

function consoleF(p_strInput, p_intLevel)
{
    if (!g_blnShowConsole) return;
    if (window.parent != window && parent.consoleF != null)
    {
        parent.consoleF(p_strInput, p_intLevel);
        return;
    }
    if (!g_objConsole.g_bln_fIsMounted())
    {
        g_objConsole.g_fMount();
    }
    g_objConsole.g_fSetLevel(p_intLevel);
    var blnSetting = g_objConsole.g_bln_fGetShowFunctions();
    g_objConsole.g_fSetShowFunctions(true);
    g_objConsole.g_fPrintLine(p_strInput, false);
    g_objConsole.g_fSetShowFunctions(blnSetting);
}

function consoleW(p_strInput, p_intLevel)
{
    if (!g_blnShowConsole) return;
    if (window.parent != window && parent.consoleW != null)
    {
        parent.consoleW(p_strInput, p_intLevel);
        return;
    }
    if (!g_objConsole.g_bln_fIsMounted(true))
    {
        g_objConsole.g_fOpenWindow();
    }
    g_objConsole.g_fSetLevel(p_intLevel);
    g_objConsole.g_fPrintLine(p_strInput, true);
}

function consoleA(p_strInput, p_intLevel)
{
    if (!g_blnShowConsole) return;
    if (window.parent != window && parent.consoleA != null)
    {
        parent.consoleA(p_strInput, p_intLevel);
        return;
    }
    g_objConsole.g_fSetLevel(p_intLevel);
    g_objConsole.g_fAlertLine(p_strInput, true);
}

function oa(p_strInput)
{
    consoleA(p_strInput);
}

function a(p_strInput)
{
    consoleA(p_strInput);
}


function consoleClear()
{
    if (!g_blnShowConsole) return;
    if (window.parent != window && parent.consoleClear != null)
    {
        parent.consoleClear();
        return;
    }
    if (g_objConsole.g_bln_fIsMounted() || g_objConsole.g_bln_fIsMounted(true))
        g_objConsole.g_fClear();
}


function consoleSize(p_intLeft, p_intTop, p_intWidth, p_intHeight)
{
    if (!g_blnShowConsole) return;
    if (window.parent != window && parent.consoleSize != null)
    {
        parent.consoleSize(p_intLeft, p_intTop, p_intWidth, p_intHeight);
        return;
    }
    g_objConsole.g_fSetSize(p_intLeft, p_intTop, p_intWidth, p_intHeight);
}

function consoleClose()
{
    if (!g_blnShowConsole) return;
    if (window.parent != window && parent.consoleClose != null)
    {
        parent.consoleClose();
        return;
    }
    g_objConsole.g_fClosePerm();
}

function consoleClosePerm()
{
    if (!g_blnShowConsole) return;
    if (window.parent != window && parent.consoleClosePerm != null)
    {
        parent.consoleClosePerm();
        return;
    }
    g_objConsole.g_fClosePerm();
}


/** globalus clsEventManaging klases objektas */
var g_objEventManager = new clsEventManaging();
//======================================================================================
// clsEventManaging
//======================================================================================
/**
    globaliu eventu managemento klase
    @version 1.0 2006.10.02
    @author Rytis Gasparavicius
    @class clsEventManaging
    @constructor
*/
function clsEventManaging()
{
    /** esamo documento eventu managerio id */
    this.g_strId = null;
    /** tevinio documento eventu managerio id */
    this.g_strParentId = '';
    /** vaikiniu documentu eventu manageriu id */
    this.g_arr_strChildId = new Array();
    /** nurodo ar jau uzdetas duotas eventas */
    this.g_bln_hshEventAdded = new Object();
    /** mouse eventu left koordinate */
    this.g_intX = null;
    /** mouse eventu top koordinate */
    this.g_intY = null;

    /** rodykle i save*/
    var objThis = this;
    /** pagal eventus uzhashuotos ir pagal funkciju id uzhashuotos funkcijos*/
    var hsh_hsh_Function = new Object();
    /** pagal eventus uzhashintu funkciju id */
    var hsh_arr_strFunctionId = new Object();
    /** nurodo ar hashintas eventas nukillintas */
    var hsh_blnEventKilled = new Object();
    /** saugo killinamu funkciju id masyva pagal duota eventa*/
    var hsh_arr_strKilledFunctionId = new Object();


// PRIVATE METHODS

////////////////////////////////////////////////////////////////////////////////////////////////////
// REGISTERING
////////////////////////////////////////////////////////////////////////////////////////////////////
    //------------------------------------------------------------------------------------
    /**
        metodas 'str_fRegisterChild' metodo pagalba sugeneruoja id esamam documentui uzregistruoti
        @type str
    */
    this.str_fGetId = function()
    {
        var strId = null;
        if(window.parent != window && window.parent.g_objEventManager != null)
        {
            strId = window.parent.g_objEventManager.str_fRegisterChild();
            return strId;
        }
        else
            return 'parentDoc';
    }
    //------------------------------------------------------------------------------------
    /**
        registers child document & returns id for child document, that was registered
    */
    this.str_fRegisterChild = function()
    {
        var intChildLength = this.g_arr_strChildId.length;
        var strId = this.g_strId + '_' + intChildLength;
            this.g_arr_strChildId[intChildLength] = strId;
        return strId;
    }
    //------------------------------------------------------------------------------------
    /**
       metodas grazina child frame'o indexa
    */
    this.g_intGetChildIndex = function(p_strChildId)
    {
        if(cIE == true)
        {
            if(document.frames != null)
            {
                for(var i = 0; i < document.frames.length;i++)
                {
                    if(document.frames[i].g_objEventManager != null)
                        if(document.frames[i].g_objEventManager.g_strId == p_strChildId)
                        {
                            return i;
                            break;
                        }
                }
            }
        }
        else if(cFF == true)
        {
            if(window.frames != null)
            {
                for(var i = 0; i < window.frames.length;i++)
                {
                    if(window.frames[i].g_objEventManager != null)
                        if(window.frames[i].g_objEventManager.g_strId == p_strChildId)
                        {
                            return i;
                            break;
                        }
                }
            }
        }
    }
    //------------------------------------------------------------------------------------
    /**
        setting xy by child obj
    */
    this.fSetXYByChild = function(p_strChildId)
    {
        var objFrame = null;
        var objChildEventManager = null;
        if(cIE == true)
        {
            if(document.frames != null)
            {
                for(var i = 0; i < document.frames.length;i++)
                {
                    if(document.frames[i].g_objEventManager != null)
                        if(document.frames[i].g_objEventManager.g_strId == p_strChildId)
                        {
                            objFrame = document.frames[i];
                            objChildEventManager = document.frames[i].g_objEventManager;
                            break;
                        }
                }
            }
        }
        else if(cFF == true)
        {
            if(window.frames != null)
            {
                for(var i = 0; i < window.frames.length;i++)
                {
                    if(window.frames[i].g_objEventManager != null)
                        if(window.frames[i].g_objEventManager.g_strId == p_strChildId)
                        {
                            objFrame = window.frames[i];
                             objChildEventManager = window.frames[i].g_objEventManager;
                            break;
                        }
                }
            }
        }
        var arrArg = objPosition(objFrame.frameElement);
        this.g_intX = arrArg[2] + objChildEventManager.g_intX;
        this.g_intY = arrArg[3] + objChildEventManager.g_intY;
    }
    //------------------------------------------------------------------------------------
    /** alerting parent about   @p_strEvent    event
       @param p_strChildId - objektas, kuris ishviete sy metoda
       @param p_strDocumentURL -
    */
    this.fCallParent = function(p_strChildId, p_strEvent,p_objEvent,p_strDocumentURL, p_arrNavigation)
    {
        var objParent = objThis.g_obj_fGetParent();

        if(objParent != null)
        {
            var intChildIndex = objParent.g_intGetChildIndex(p_strChildId);
            var arr_intCloneNav = g_obj_fClone(p_arrNavigation);
            arr_intCloneNav.splice(0, 0, intChildIndex);
            objParent.fSetXYByChild(p_strChildId);
            objParent.fHandleEvent(p_strEvent,p_objEvent,p_strDocumentURL,arr_intCloneNav);
            objParent.fCallChildren(p_strEvent,p_strChildId,p_objEvent,p_strDocumentURL,arr_intCloneNav);
            objParent.fCallParent(objParent.g_strId, p_strEvent,p_objEvent,p_strDocumentURL,arr_intCloneNav);
        }
    }
    //------------------------------------------------------------------------------------
    /**
         setting xy for child obj by current obj(parent)
    */
    this.fSetXYByParent = function(p_strIgnoredId)
    {
        var arr_objChild = objThis.g_arr_obj_fGetChild();
        if(arr_objChild != null)
        {
            for(var i = 0; i < arr_objChild.length; i++)
            {
               if(arr_objChild[i].g_strId != p_strIgnoredId)
               {

                    // getting objFrame && objChildEventManager by  objChildEventManager.g_strId
                    var objFrame = null;
                    var objChildEventManager = null;
                    if(cIE == true)
                    {
                        if(document.frames != null)
                        {
                            for(var y = 0; y < document.frames.length;y++)
                            {
                                if(document.frames[y].g_objEventManager != null)
                                    if(document.frames[y].g_objEventManager.g_strId == arr_objChild[i].g_strId)
                                    {
                                        objFrame = document.frames[y];
                                        objChildEventManager = document.frames[y].g_objEventManager;
                                        break;
                                    }
                            }
                        }
                    }
                    else if(cFF == true)
                    {
                        if(window.frames != null)
                        {
                            for(var y = 0; y < window.frames.length;y++)
                            {
                                if(window.frames[y].g_objEventManager != null)
                                    if(window.frames[y].g_objEventManager.g_strId == arr_objChild[i].g_strId)
                                    {
                                        objFrame = window.frames[y];
                                         objChildEventManager = window.frames[y].g_objEventManager;
                                        break;
                                    }
                            }
                        }
                    }
                    var arrArg = objPosition(objFrame.frameElement);

                    arr_objChild[i].g_intX = objThis.g_intX - arrArg[2];
                    arr_objChild[i].g_intY = objThis.g_intY - arrArg[3];
               }
            }
        }
    }
    //------------------------------------------------------------------------------------
    /**
        suaktyvina 'child' documentu eventus
    */
    this.fCallChildren = function(p_strEvent, p_strIgnoredId, p_objEvent,p_strDocumentURL, p_arr_intNavigation)
    {
        var arr_objChild = objThis.g_arr_obj_fGetChild();
        if(arr_objChild.length > 0)
        {
            var arr_intCloneNav = g_obj_fClone(p_arr_intNavigation);
            arr_intCloneNav.splice(0, 0, -1);
            objThis.fSetXYByParent(p_strIgnoredId);
            for(var i = 0; i < arr_objChild.length; i++)
            {
               if(arr_objChild[i].g_strId != p_strIgnoredId)
               {

                   arr_objChild[i].fHandleEvent(p_strEvent, p_objEvent, p_strDocumentURL, arr_intCloneNav);
                   arr_objChild[i].fCallChildren(p_strEvent, null, p_objEvent, p_strDocumentURL, arr_intCloneNav);
               }
            }
        }
    }
////////////////////////////////////////////////////////////////////////////////////////////////////
// ADDING EVENTS
////////////////////////////////////////////////////////////////////////////////////////////////////
    //------------------------------------------------------------------------------------
    /**
        uzdeda eventa ant documento
    */
    this.fAddEventOnDoc = function(p_strEvent)
    {
         addEvent(document,p_strEvent, fOnEvent);
         g_fRegisterObject(p_strEvent);
    }
    //------------------------------------------------------------------------------------
    /**
        uzdeda eventa ant tevinio documento
    */
    this.fAddEventOnParent = function(p_strChildId, p_strEvent)
    {
        var objParent = objThis.g_obj_fGetParent();
        if(objParent != null)
        {
            objParent.g_bln_hshEventAdded[p_strEvent] = true;
            objParent.fAddEventOnDoc(p_strEvent);
            objParent.fAddEventOnChildren(p_strEvent,p_strChildId);
            objParent.fAddEventOnParent(objParent.g_strId, p_strEvent);
        }
    }
    //------------------------------------------------------------------------------------
    /**
        uzdeda eventa ant vaikiniu documentu
    */
    this.fAddEventOnChildren = function(p_strEvent,p_strIgnoredId)
    {
        var arr_objChild = objThis.g_arr_obj_fGetChild();
        if(arr_objChild != null)
        {
            for(var i = 0; i < arr_objChild.length; i++)
            {
               if(arr_objChild[i].g_strId != p_strIgnoredId)
               {
                   arr_objChild[i].g_bln_hshEventAdded[p_strEvent] = true;
                   arr_objChild[i].fAddEventOnDoc(p_strEvent);
                   arr_objChild[i].fAddEventOnChildren(p_strEvent,null);
               }
            }
        }
    }
////////////////////////////////////////////////////////////////////////////////////////////////////
// NAVIGATION
////////////////////////////////////////////////////////////////////////////////////////////////////
    //------------------------------------------------------------------------------------
    /**
        grazina tevinio documento g_objEventManager objekta
        @type obj
    */
    this.g_obj_fGetParent = function()
    {
      var a = window;
      var aparent = window.parent;
        if(window.parent != window)
        {
            return window.parent.g_objEventManager;
        }
        else
        {
            return null;
        }
    }
    //------------------------------------------------------------------------------------
    /**
        grazina vaikiniu documentu g_objEventManager objektus
        @type obj
    */
    this.g_arr_obj_fGetChild = function()
    {
        var arr_objChild = new Array();
        if(cIE == true)
        {
            if(document.frames != null)
            {
                for(var i = 0; i < document.frames.length;i++)
                {
                    if(document.frames[i].g_objEventManager != null)
                        arr_objChild.push(document.frames[i].g_objEventManager);
                }
            }
        }
        else if(cFF == true)
        {
            if(window.frames != null)
            {
                for(var i = 0; i < window.frames.length;i++)
                {
                    if(window.frames[i].g_objEventManager != null)
                        arr_objChild.push(window.frames[i].g_objEventManager);
                }
            }
        }
        return arr_objChild;
    }
////////////////////////////////////////////////////////////////////////////////////////////////////
// EVENTS & EVENT HANDLERS
////////////////////////////////////////////////////////////////////////////////////////////////////
    //-------------------------------------------------------------------------------------
    /**
        eventHandler of eventManager event
        @param p_strEvent evento tipas
        @param e HTML eventas
        @param p_strDocumentURL documento URL
    */
    this.fHandleEvent = function( p_strEvent, e, p_strDocumentURL, p_arr_intNavigation)
    {
        if(hsh_hsh_Function[p_strEvent] != null)
        {
            var intTemp = hsh_arr_strFunctionId[p_strEvent].length - 1;
            for(var i = intTemp; i > -1; i--)
            {
                var hshArg = new Object();
                    hshArg['strFunctionId'] = hsh_arr_strFunctionId[p_strEvent][i];
                    hshArg['intX'] = objThis.g_intX;
                    hshArg['intY'] = objThis.g_intY;
                    hshArg['arr_intNavigation'] = p_arr_intNavigation;
                    hshArg['event'] = e;
                if(document.URL == p_strDocumentURL)
                    hshArg['blnEventOnCurrDoc'] = true;
                else
                    hshArg['blnEventOnCurrDoc'] = false;
             // tikrinama ar eventas nenukillintas
                if(hsh_blnEventKilled[p_strEvent] == false)
                {
                 // kvieciamas handleris
                    if(hsh_hsh_Function[p_strEvent][hsh_arr_strFunctionId[p_strEvent][i]] != null)
                    {
                       // if(p_strEvent == 'click')
                        hsh_hsh_Function[p_strEvent][hsh_arr_strFunctionId[p_strEvent][i]](e,hshArg);
                    }
                }
             // jei eventas killinamas
                else
                {
                 // jei nebuvo killinamos visos funkcijos, o tik duotas killinamu funkciju sarasas
                    if(hsh_arr_strKilledFunctionId[p_strEvent] != null)
                    {
                        var blnFunctionFound = false;
                        for(var y = 0; y < hsh_arr_strKilledFunctionId[p_strEvent].length; y++)
                        {
                            if(hsh_arr_strKilledFunctionId[p_strEvent][y] == hsh_arr_strFunctionId[p_strEvent][i])
                            {
                                blnFunctionFound = true;
                                break;
                            }
                        }
                     // esama funkcija nerasta killinamu funkciju sarase
                        if(blnFunctionFound == false)
                        {
                         // kvieciamas handleris
                            if(hsh_hsh_Function[p_strEvent][hsh_arr_strFunctionId[p_strEvent][i]] != null)
                            {
                               hsh_hsh_Function[p_strEvent][hsh_arr_strFunctionId[p_strEvent][i]](e,hshArg);
                            }
                        }
                    }
                 // jei buvo killinamos visos funkcijos
                    else
                    {

                    }
                }
            }
            hsh_arr_strKilledFunctionId[p_strEvent] = null;
            hsh_blnEventKilled[p_strEvent] = false;
        }
    }
    //-------------------------------------------------------------------------------------
    /**
        eventHandler of HTML event
    */
    function fOnEvent(e)
    {
          objThis.g_intX = e.clientX;
          objThis.g_intY = e.clientY;
          var objDocument = null;
          var objTemp = getSrcElement(e);
          while(objTemp != null && objTemp != document)
          {
              objTemp = objTemp.parentNode;
          }
          if(objTemp != null)
          {
              objDocument = objTemp;          // sito documento URL eis per visus frame'us

              var arr_intNavigation = new Array();
              objThis.fHandleEvent(e.type, e, objDocument.URL,arr_intNavigation);
              objThis.fCallParent(objThis.g_strId, e.type, e, objDocument.URL,arr_intNavigation);
              objThis.fCallChildren(e.type, null, e, objDocument.URL,arr_intNavigation);
          }
    }
    //------------------------------------------------------------------------------------






// PUBLIC METHODS

////////////////////////////////////////////////////////////////////////////////////////////////////
// ADDING & REMOVING EVENTS
////////////////////////////////////////////////////////////////////////////////////////////////////
    /**
        metodas uzdeda globalu 'p_strEvent' eventa ant documento. uzmountinama funkcija 'p_str_fFunction', kurios id = p_strId
        @param p_strId - skirtas objektu aptazinimui(funkcijos id)
        @param p_strId - skirtas objektu aptazinimui(funkcijos id)
        @param p_strId - skirtas objektu aptazinimui(funkcijos id)
    */
    this.g_fAddEvent = function(p_strId, p_strEvent, p_str_fFunction)
    {
        g_fRegisterObject(p_strEvent);
   // jei nebuvo sukurtas hashas pagal duota eventa
        if(hsh_hsh_Function[p_strEvent] == null)
        {
            hsh_hsh_Function[p_strEvent] = new Object();
            hsh_arr_strFunctionId[p_strEvent] = new Array();
        }
   // nustatoma kad duotas eventas nenukillintas
        hsh_blnEventKilled[p_strEvent] = false;

        hsh_hsh_Function[p_strEvent][p_strId] = p_str_fFunction;
        hsh_arr_strFunctionId[p_strEvent].push(p_strId);
        var objParent = this.g_obj_fGetParent();
        if(this.g_bln_hshEventAdded[p_strEvent] != true)  // tai reikia visiems uzdeti
        {
            this.g_bln_hshEventAdded[p_strEvent] = true;
            this.fAddEventOnParent(objThis.g_strId, p_strEvent);
            this.fAddEventOnChildren(p_strEvent,null);
            addEvent(document, p_strEvent, fOnEvent);
        }
    }
      //-------------------------------------------------------------------------------------
    // p_strId - nuo kurio objekto remove'inti eventa
    this.g_fRemoveEvent = function(p_strId, p_strEvent)
    {
        if(hsh_hsh_Function[p_strEvent] != null)
        {
            hsh_hsh_Function[p_strEvent][p_strId] = null;
            for(var i = 0; i < hsh_arr_strFunctionId[p_strEvent].length; i++)
            {
                if(hsh_arr_strFunctionId[p_strEvent][i] == p_strId)
                {
                    hsh_arr_strFunctionId[p_strEvent].splice(i,1);
                    return;
                }
            }
        }
    }
    //-------------------------------------------------------------------------------------
    /**
        killina eventa
        @param p_strEvent killinamas eventas
        @param p_arr_strId killinamas funkciju id masyvas (jei == null, tai killinamos visos funkcijos)
    */
    this.g_fKillEvent = function(p_strEvent, p_arr_strId)
    {
        hsh_blnEventKilled[p_strEvent] = true;
        if(p_arr_strId != null)
        {
         // jei nebuvo priskirta nei vienos killinamos funkcijos
            if(hsh_arr_strKilledFunctionId[p_strEvent] == null)
            {
                hsh_arr_strKilledFunctionId[p_strEvent] = p_arr_strId;
            }
         // jei buvo priskirta killinamu funkciju
            else
            {
                hsh_arr_strKilledFunctionId[p_strEvent] = hsh_arr_strKilledFunctionId[p_strEvent].concat(p_arr_strId);
            }
        }
    }
    //-------------------------------------------------------------------------------------
    /**
        fire'ina eventa
        @param p_strEvent fire'inamas eventas
    */
    this.g_fFireEvent = function(p_strEvent, e)
    {
         objThis.g_intX = e.clientX;
         objThis.g_intY = e.clientY;
         var objDocument = null;
         var objTemp = getSrcElement(e);
         while(objTemp != null && objTemp != document)
         {
             objTemp = objTemp.parentNode;
         }
         if(objTemp != null)
         {
             objDocument = objTemp;          // sito documento URL eis per visus frame'us
             var arr_intNavigation = new Array();
             objThis.fHandleEvent(p_strEvent, e, objDocument.URL,arr_intNavigation);
             objThis.fCallParent(objThis.g_strId, p_strEvent, e, objDocument.URL,arr_intNavigation);
             objThis.fCallChildren(p_strEvent, null, e, objDocument.URL,arr_intNavigation);
         }
    }
    //-------------------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////////////////////////
// HTML EVENT DESTRUCTOR
////////////////////////////////////////////////////////////////////////////////////////////////////
    var g_arr_strRegister = new Array(); // Visu laiku u?detu eventu sara?as
    /*
        RS 2006.06.21
        @p_strId - Stringas kuri norime isiminti.
        Metodas isimena tik skirtingus jam paduotus stringus. Veliau jie bus panaudoti nuimant
        visus eventus nuo document.
    */
    function g_fRegisterObject(p_strId)
    {
        for(var i = 0;i < g_arr_strRegister.length;i++)
        {
            if(g_arr_strRegister == p_strId)
                return;
        }
        g_arr_strRegister.push(p_strId);
    }
    //-------------------------------------------------------------------------------------
    /*
        RS 2006.06.21
        I?valo visus kada nors u?detus eventus, per globalu eventu u?dejika
        (originaliai u?detus ?itame ar kituose documentuose).
    */
    addEvent(window, 'unload', fDestructor);
    function fDestructor(e)
    {
        for(var i = 0; i < g_arr_strRegister.length; i++)
        {
            removeEvent(document, g_arr_strRegister[i], fOnEvent);
        }
        removeEvent(window, 'unload', fDestructor);
    }
    //-------------------------------------------------------------------------------------
// end  PUBLIC METHODS



  if(window.parent != window  && window.parent.g_objEventManager != null)
        this.g_strParentId = window.parent.g_objEventManager.g_strId;
    this.g_strId = this.str_fGetId();
//checking if parent has added events
    var objParent = this.g_obj_fGetParent();
    if(objParent != null)
    {
        for(var i in objParent.g_bln_hshEventAdded)
        {
            if(objParent.g_bln_hshEventAdded[i] == true)  // if parent has added event then child adds event as well
            {
                this.g_bln_hshEventAdded[i] = true;
                this.fAddEventOnDoc(i);
            }
        }
    }

}
//======================================================================================
// end clsEventManaging
//======================================================================================

















// JScript File

/**
    @requires g_objConfiguration
*/
function clsLightMenu(p_hshArg, p_hshEvents, p_arr_intPositions, p_blnRelativeToMouse, p_intMaxNodes)
{
    var objThis = this;
	var hshTempArg = p_hshArg;
	var hshArg = p_hshArg;
	// p_hshArg['strId'];
	// p_hshArg['strParentId']
	// hshArg['NodeWidth'],
	// hshArg['NodeHeight']
	var hshEvents = p_hshEvents;
	// hshEvents['MenuClick']
    // hshEvents['BuildMenu']
    // hshEvents['HideMenu']
    // hshEvents['ShowMenu']
    var arr_intPositions = p_arr_intPositions;
    var blnRelativeToMouse = p_blnRelativeToMouse;
    var arr_intMousePosition;
    var objCallerElement;
    var blnIsIn = false;
    var blnMoves = false;
    var blnWasClosed = false;
    var arr_objNodes = null;
    var hsh_intTypeCounts = null;
    var strLastSelectedId = null;
    var strPrefix = 'lightMenu_';
    var intMaxNodes = p_intMaxNodes;

    /**
	    Gaunamas elementas pagal galine Id dali. Pradine Id dalis yra paimama is dialogo Id.
	    @param p_strRelativeId Reliatyvus objekto Id.
	    @returns Rasta HTML objekta su nurodytu reliatyviu id.
	    @type HTML object
	*/
	this.g_obj_fGetLocalElement = function(p_strRelativeId)
    {
        return document.getElementById(this.g_str_fCreateId(p_strRelativeId));
    }

    /**
	    Funkcija skirta kurti elementu Id. Ji apjungia dialogo id ir elemento reliatyvu id.
        Dialogai turi tureti globalu kintamaji - id.
	    @param p_strElementId Reliatyvus objekto Id.
	    @returns Pilna objekto id.
	    @type HTML object
	*/
    this.g_str_fCreateId = function(p_strElementId)
    {
        return strFilterId + '_' + p_strElementId;
    }

    this.g_fInit = function()
    {
        arr_objNodes = new Array();
        hsh_intTypeCounts = new Object();
        fConstructMenu(hshTempArg);
    }

    this.g_fUninit = function()
    {
        var objMainDiv = document.getElementById(hshArg['strId']);
        if (objMainDiv)
        {
            removeEvent(objMainDiv, 'mouseover', fOver);
            removeEvent(objMainDiv, 'mouseout', fOut);
            removeEvent(objMainDiv, 'mousemove', fMove);
            g_objEventManager.g_fRemoveEvent(hshArg['strId'], 'click');
            var objParent = document.getElementById(p_hshArg['strParentId']);
	        removeEvent(objParent,'contextmenu',_false);
	        if(cIE == true)
			    removeEvent(objMainDiv,'selectstart',_false);
			removeEvent(objMainDiv,'contextmenu',_false);
        }
    }

    function fOver(e)
    {
        blnIsIn = true;
    }

    function fOut(e)
    {
        blnIsIn = false;
        if (strLastSelectedId)
        {
            var objRow = document.getElementById(strPrefix + strLastSelectedId);
            if (objRow) fSetStyle(objRow, false);
        }
        strLastSelectedId = null;
    }

    function fMove(e)
    {
        blnMoves = true;
        var objElement = getSrcElement(e);
        var strRowId = objElement.getAttribute('strRowId');
        if (!strRowId) return;
        if (strLastSelectedId == strRowId) return;
        if (strLastSelectedId)
        {
            var objRow = document.getElementById(strPrefix + strLastSelectedId);
            if (objRow) fSetStyle(objRow, false);
        }
        strLastSelectedId = strRowId;
        var objRow = document.getElementById(strPrefix + strRowId);
        if (objRow) fSetStyle(objRow, true);
    }

    this.g_fOpen = function(p_objCallerEvent)
    {
        fOpenMenu(p_objCallerEvent);
    }

    this.g_arr_fGetState = function(p_blnNeedToMove)
    {
        var blnCanBeClosed = false;
        if (p_blnNeedToMove)
        {
            blnCanBeClosed = !blnIsIn || !blnMoves;
            blnMoves = false;
            return blnResult;
        }
        else
        {
            blnMoves = false;
            blnCanBeClosed = !blnIsIn;
        }
        return [blnWasClosed,  blnCanBeClosed, blnIsIn];
    }

    this.g_fClose = function()
    {
        objThis.g_fHide();
    }



    //////////////////////////////////////////////////////////////////////////////////////////
    ///////////////////////////        Pagalbines funkcijos         //////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////////

    function fConstructMenu(p_hshArg)
	{
		hshArg = new Object();
		if (typeof(g_objConfiguration) != 'undefined')
		{
		    hshArg = g_obj_fClone(g_objConfiguration.g_hshContextMenuCmc);
		}
	    for (var key in p_hshArg)
	    {
	        hshArg[key] = p_hshArg[key];
	    }

        var objParent = document.getElementById(p_hshArg['strParentId']);
	    addEvent(objParent,'contextmenu',_false);
        objParent.setAttribute('strTagName', 'strTd_HMenu');
	    objParent.setAttribute('strTopMenuId', p_hshArg['strParentId']);
	    g_fCreateContent(hshArg);
    }


	function fMenuClick(p_hshEvent)
	{
	    blnIsIn = false;
	    blnWasClosed = true;
	    var strNode = p_hshEvent['strNode'];
	    var objEvent = p_hshEvent['event'];
	    if (typeof(hshEvents['MenuClick']) == 'function')
	    {
	        hshEvents['MenuClick'](strNode);
	    }
	}

	function fOpenMenu(p_hshEvent)
	{
	    blnWasClosed = false;
	    arr_intMousePosition = p_hshEvent['event']['mousePosition'];
	    objCallerElement = p_hshEvent['element'];
	    objThis.g_fHide();
	    objThis.g_fDeleteAll();
	    if (typeof(hshEvents['BuildMenu']) == 'function')
	    {
	        hshEvents['BuildMenu'](p_hshEvent, objThis);
	    }
	    if (arr_objNodes == null || arr_objNodes.length == 0)
	    {
	        objThis.g_fHide();
	    }
	    else
	    {
	        fShowMenu(arr_intPositions, hshArg['NodeWidth'], hshArg['NodeHeight'], objCallerElement, arr_intMousePosition);
	    }
	}

    function fShowMenu(p_arr_intPosition, p_intNodeWidth, p_intNodeHeight, p_objParentObj, p_arr_intMousePosition)
    {
        var hshTemp = new Object();
        var arr;
        var textNodeCount = objThis.g_int_fGetCountOfType('text');
        var breakerNodeCount = objThis.g_int_fGetCountOfType('breaker');
        var intMenuHeight = textNodeCount * hshArg['NodeHeight'] + breakerNodeCount * 5;
        if (blnRelativeToMouse)
        {
            hshTemp = g_hsh_int_fGetCoordsByPosition(arr_intMousePosition[0], arr_intMousePosition[1],
                0, 0, p_intNodeWidth, intMenuHeight, p_arr_intPosition);
            arr = [hshTemp['intX'], hshTemp['intY']];
        }
        else
        {
            var objParentObj = p_objParentObj;
            var arrArg = objPosition(objParentObj);
            hshTemp = g_hsh_int_fGetCoordsByPosition(arrArg[2], arrArg[3],arrArg[0],arrArg[1],
                p_intNodeWidth, intMenuHeight, p_arr_intPosition);
            arr = g_arr_int_fGetCoords(p_objParentObj, hshTemp['intX'],hshTemp['intY']);
        }
        objThis.g_fShow(arr[0], arr[1]);
    }

    function fHideEventHandler()
    {
        if (typeof(hshEvents['HideMenu']) == 'function')
        {
            hshEvents['HideMenu']();
        }
    }
    function fShowEventHandler()
    {
        if (typeof(hshEvents['ShowMenu']) == 'function')
        {
            hshEvents['ShowMenu']();
        }
    }

    //////////////////////////////////////////////////////////////////////////////////////////
    ///////////////////////////   Specifines meniu funkcijos        //////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////////

    function g_fCreateContent(hshArg)
    {
        var objParentDiv = document.getElementById(hshArg['strParentId']);
        if (objParentDiv)
        {
            var objMainDiv = document.getElementById(hshArg['strId']);
            if (!objMainDiv)
            {
                objMainDiv = document.createElement('DIV');
                objMainDiv.style.position = 'absolute';
			    objMainDiv.id = hshArg['strId'];
			    objMainDiv.style.zIndex = hshArg['zindex'];
			    objMainDiv.style.display = 'none';
			    objMainDiv.style.visibility = 'hidden';
			    objMainDiv.style.cursor = 'default';
			    objMainDiv.style.border = hshArg['strMenuBorderStyle'];
			    if (hshArg['intNodeWidth'] != null)
			        objMainDiv.style.width = hshArg['intNodeWidth'];

			    objParentDiv.appendChild(objMainDiv);

			    g_objEventManager.g_fAddEvent(hshArg['strId'], 'click', fClick);
			    addEvent(objMainDiv, 'mouseover', fOver);
                addEvent(objMainDiv, 'mouseout', fOut);
                addEvent(objMainDiv, 'mousemove', fMove);

			    if(cIE == true)
			        addEvent(objMainDiv,'selectstart',_false);
			    if(cFF == true)
			        objMainDiv.style.MozUserSelect = 'none';
			    addEvent(objMainDiv,'contextmenu',_false);

			    var objTable = document.createElement('table');
			    objTable.style.borderCollapse = 'collapse';
			    objTable.cellSpacing = '0';
			    objTable.cellPadding = '0';
			    objTable.id = hshArg['strId'] + '_table';
			    objMainDiv.appendChild(objTable);
            }
        }
    }

    this.g_fShow = function(p_intX, p_intY)
    {
        var objMainDiv = document.getElementById(hshArg['strId']);
	    if (objMainDiv)
	    {
	        objMainDiv.style.display = '';
			objMainDiv.style.visibility = 'visible';
			objMainDiv.style.position = 'absolute';
			objMainDiv.style.left = p_intX;
			objMainDiv.style.top = p_intY;
			if (intMaxNodes != null && intMaxNodes > 0 && arr_objNodes.length > intMaxNodes)
		    {
		        objMainDiv.style.height = intMaxNodes * hshArg['intNodeHeight'];
		        objMainDiv.style.overflow = 'auto';
		    }
		    else
		    {
		        objMainDiv.style.height = '';
		    }
			fShowEventHandler();
        }
    }

    this.g_fHide = function()
    {
        var objMainDiv = document.getElementById(hshArg['strId']);
	    if (objMainDiv)
	    {
	        objMainDiv.style.display = 'none';
			objMainDiv.style.visibility = 'hidden';
			fHideEventHandler();
        }
    }

    this.g_fInsert = function(p_strParent, p_strItem, p_strText, p_strType)
    {
        var objMainTable = document.getElementById(hshArg['strId'] + '_table');
	    if (objMainTable)
	    {
	        var objTr = objMainTable.insertRow(objMainTable.rows.length);
	        objTr.setAttribute('strRowId', p_strItem);
	        objTr.setAttribute('strMenuId', hshArg['strId']);
	        objTr.id  = strPrefix + p_strItem;
	        objTr.style.height = hshArg['intNodeHeight'];
		    objTr.style.width = hshArg['intNodeWidth'];

		    var objTd = objTr.insertCell(0);
		    objTd.setAttribute('strTagType', 'Item');
		    objTd.setAttribute('strMenuId', hshArg['strId']);
		    objTd.setAttribute('strRowId', p_strItem);
		    objTd.style.width = '20px';

		    objTd = objTr.insertCell(1);
		    objTd.setAttribute('strTagType', 'Item');
		    objTd.setAttribute('strMenuId', hshArg['strId']);
		    objTd.setAttribute('strRowId', p_strItem);
		    objTd.style.paddingLeft = '5px';
		    objTd.style.paddingRight = '5px';

		    objTd.innerHTML = p_strText;

		    fSetStyle(objTr, false);

		    var objNewItem = new Object();
		    objNewItem['strParent'] = p_strParent;
		    objNewItem['strItem'] = p_strItem;
		    objNewItem['strText'] = p_strText;
		    objNewItem['strType'] = p_strType;
		    if (typeof(hsh_intTypeCounts[p_strType]) == 'undefined')
		    {
		        hsh_intTypeCounts[p_strType] = 0;
		    }
		    hsh_intTypeCounts[p_strType]++;
		    arr_objNodes.push(objNewItem);
        }
    }

    function fSetStyle(p_objRow, p_blnSelected)
    {
        var objFirstCell = p_objRow.cells[0];
        var objSecondCell = p_objRow.cells[1];
        if (p_blnSelected)
        {
            objFirstCell.style.backgroundColor = hshArg['strSelectLeftColor'];
            objSecondCell.style.backgroundColor = hshArg['strSelectRightColor'];
        }
        else
        {
            objFirstCell.style.backgroundColor = hshArg['strLeftColor'];
            objSecondCell.style.backgroundColor = hshArg['strRightColor'];
        }
    }

    this.g_fDeleteAll = function()
    {
        var objMainTable = document.getElementById(hshArg['strId'] + '_table');
	    if (objMainTable)
	    {
	        for (var i = objMainTable.rows.length - 1; i >= 0; i--)
	        {
	            objMainTable.deleteRow(i);
	        }
	        arr_objNodes = new Array();
		    hsh_intTypeCounts = new Object();
        }
    }

    this.g_int_fGetCountOfType = function(p_strType)
    {
        if (typeof(hsh_intTypeCounts[p_strType]) == 'undefined')
	    {
	        return 0;
	    }
	    return hsh_intTypeCounts[p_strType];
    }

    function fClick(e, p_hshArg)
	{
	    if(p_hshArg['blnEventOnCurrDoc'] == true)
	    {
	        var objElement = getSrcElement(e);
            var strRowId = objElement.getAttribute('strRowId');
            var strMenuId = objElement.getAttribute('strMenuId');
            if (!strRowId || strMenuId != hshArg['strId'])
            {
                objThis.g_fHide();
            }
            else
            {
                var hshEvent = new Object();
                hshEvent['strNode'] = strRowId;
                hshEvent['event'] = e;
                fMenuClick(hshEvent);
            }
	    }
	    else
	    {
	        objThis.g_fHide();
	    }
	}
}

//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////      Pozicionavimo funkcijos        //////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/**
	             - - -   - - - - - -
		        |	1  |    2 |    3 |
		        |      |      |      |
 given point  =====>>> . - - - 	- - -
		        |	 4 |    5 |    6 |
		        |      |      |      |
		         - - -   - - -  - - -
		        |    7 |    8 |    9 |
		        |      |      |      |
		         - - -   - - -  - - -
  5 - parent
     metodas tikrina kuri pozicija aplink teviny elementa tinka
     @param p_intX tasko x koordinate
     @param p_intY tasko y koordinate
     @param p_intParentWidth  tevinio lemento plotis
     @param p_intParentHeight tevinio lemento aukstis
     @param p_intWidth issokancio staciakampio plotis
     @param p_intHeight issokancio staciakampio aukstis
     @param p_arrPosition pozicija apie teviny elementa(1,2,3,4,5,6,7,8,88..)
     @param p_strBoundaryObjId ribojancio HTML elemento id (vietoj window)

  function finds a suitable position for the popup window

*/
function g_hsh_int_fGetCoordsByPosition(p_intX , p_intY, p_intParentWidth, p_intParentHeight, p_intWidth, p_intHeight, p_arrPosition,p_strBoundaryObjId)
{
    var hshArg = new Object();
        hshArg['fits'] = false;
    var intLeft = null;
    var intTop = null;

    var intCurrPos = null;
    var blnFoundPosition = false;
    for(var i = 0; i < p_arrPosition.length; i++)
    {
        intCurrPos = p_arrPosition[i];
        var hshATemp = g_hsh_fCheckPosition(p_intX , p_intY, p_intParentWidth, p_intParentHeight, p_intWidth, p_intHeight,intCurrPos,p_strBoundaryObjId);
        if(hshATemp['fits'] == true)
        {
           hshArg['fits'] = true;
           hshArg['intX'] = hshATemp['x'] ;
           hshArg['intY'] = hshATemp['y'] ;
           blnFoundPosition = true;
           break;
        }
    }

    if(blnFoundPosition == false)
    {
        switch(p_arrPosition[0])
        {
            case 1:
                hshArg['intX'] = p_intX - p_intWidth;
                hshArg['intY'] = p_intY - p_intHeight;
                break;
            case 2:
                hshArg['intX'] = p_intX;
                hshArg['intY'] = p_intY - p_intHeight;
                break;
            case 22:
                hshArg['intX'] = p_intX + p_intParentWidth - p_intWidth;
                hshArg['intY'] = p_intY - p_intHeight;
                break;
            case 3:
                hshArg['intX'] = p_intX + p_intParentWidth;
                hshArg['intY'] = p_intY - p_intHeight;
                break;
            case 4:
                hshArg['intX'] = p_intX - p_intWidth;
                hshArg['intY'] = p_intY;
                break;
             case 44:
                hshArg['intX'] = p_intX - p_intWidth;
                hshArg['intY'] = p_intY + p_intParentHeight - p_intHeight;
                break;
            case 5:
                hshArg['intX'] = p_intX;
                hshArg['intY'] = p_intY;
                break;
            case 6:
                hshArg['intX'] = p_intX + p_intParentWidth;
                hshArg['intY'] = p_intY;
                break;
            case 66:
                hshArg['intX'] = p_intX + p_intParentWidth;
                hshArg['intY'] = p_intY + p_intParentHeight - p_intHeight;
                break;
            case 7:
                hshArg['intX'] = p_intX - p_intWidth;
                hshArg['intY'] = p_intY + p_intParentHeight;
                break;
            case 8:
                hshArg['intX'] = p_intX;
                hshArg['intY'] = p_intY + p_intParentHeight;
                break;
            case 88:
                hshArg['intX'] = p_intX + p_intParentWidth - p_intWidth;
                hshArg['intY'] = p_intY + p_intParentHeight;
                break;
            case 9:
                hshArg['intX'] = p_intX + p_intParentWidth;
                hshArg['intY'] = p_intY + p_intParentHeight;
                break;
            default:
                break;
        }
    }
    return hshArg;
}
//-------------------------------------------------------------------------------------------------------------
/**
     metodas tikrina viena pozicija aplink teviny elementa
     @param p_intX tasko x koordinate
     @param p_intY tasko y koordinate
     @param p_intParentWidth  tevinio lemento plotis
     @param p_intParentHeight tevinio lemento aukstis
     @param p_intWidth issokancio staciakampio plotis
     @param p_intHeight issokancio staciakampio aukstis
     @param p_intPosition pozicija apie teviny elementa(1,2,3,4,5,6,7,8,88..)
     @param p_strBoundaryObjId ribojancio HTML elemento id (vietoj window)
*/
function g_hsh_fCheckPosition(p_intX , p_intY, p_intParentWidth, p_intParentHeight, p_intWidth, p_intHeight,p_intPosition,p_strBoundaryObjId)
{
    var hsh_intFitToScreen = null;
    switch(p_intPosition)
    {
        case 1:
            hsh_intFitToScreen = g_hsh_int_fFitToScreen(p_intX,p_intY,p_intWidth,p_intHeight,1,p_strBoundaryObjId);
            break;
        case 2:
            hsh_intFitToScreen = g_hsh_int_fFitToScreen(p_intX,p_intY,p_intWidth,p_intHeight,4,p_strBoundaryObjId);
            break;
        case 22:
            hsh_intFitToScreen = g_hsh_int_fFitToScreen(p_intX + p_intParentWidth - p_intWidth,p_intY,p_intWidth,p_intHeight,4,p_strBoundaryObjId);
            break;
        case 3:
            hsh_intFitToScreen = g_hsh_int_fFitToScreen(p_intX+p_intParentWidth,p_intY,p_intWidth,p_intHeight,4,p_strBoundaryObjId);
            break;
        case 4:
            hsh_intFitToScreen = g_hsh_int_fFitToScreen(p_intX,p_intY,p_intWidth,p_intHeight,2,p_strBoundaryObjId);
            break;
        case 44:
            hsh_intFitToScreen = g_hsh_int_fFitToScreen(p_intX,p_intY+p_intParentHeight-p_intHeight,p_intWidth,p_intHeight,2,p_strBoundaryObjId);
            break;
        case 5:
            hsh_intFitToScreen = g_hsh_int_fFitToScreen(p_intX,p_intY,p_intWidth,p_intHeight,3,p_strBoundaryObjId);
            break;
        case 6:
            hsh_intFitToScreen = g_hsh_int_fFitToScreen(p_intX+p_intParentWidth,p_intY,p_intWidth,p_intHeight,3,p_strBoundaryObjId);
            break;
        case 66:
            hsh_intFitToScreen = g_hsh_int_fFitToScreen(p_intX+p_intParentWidth,p_intY+p_intParentHeight-p_intHeight,p_intWidth,p_intHeight,3,p_strBoundaryObjId);
            break;
        case 7:
            hsh_intFitToScreen = g_hsh_int_fFitToScreen(p_intX,p_intY+p_intParentHeight,p_intWidth,p_intHeight,2,p_strBoundaryObjId);
            break;
        case 8:
            hsh_intFitToScreen = g_hsh_int_fFitToScreen(p_intX,p_intY+p_intParentHeight,p_intWidth,p_intHeight,3,p_strBoundaryObjId);
            break;
        case 88:
            hsh_intFitToScreen = g_hsh_int_fFitToScreen(p_intX + p_intParentWidth - p_intWidth,p_intY+p_intParentHeight,p_intWidth,p_intHeight,3,p_strBoundaryObjId);
            break;
        case 9:
            hsh_intFitToScreen = g_hsh_int_fFitToScreen(p_intX+p_intParentWidth,p_intY+p_intParentHeight,p_intWidth,p_intHeight,3,p_strBoundaryObjId);
            break;
        default:
            consoleA('no such position');
            break;
    }
    return hsh_intFitToScreen;
}
//--------------------------------------------------------------------------------------------------------
/**
    metodas tikrina ar duotas staciakampis duotame taske, duotoje pozicijoje telpa y window, arba y objekta jei nurodytas 'p_strBoundaryObjId'
    metodas naudoja pagrindini metoda 'g_bln_fIsOnScreen' kuris nustato ar duotas taskas yra ekrane.
    norint nustatyti ar staciakampis duotoje pozicijoje telpa ekrane, reikia tikrinti ar jo kampai yra ekrane arba ribojanciame elemente (p_strBoundaryObjId);

    @param p_intLeft tasko x koordinate
    @param p_intTop tasko y koordinate
    @param p_intWidth staciakampio plotis
    @param p_intHeight staciakampio aukstis
    @param p_intWantedPos norima pozicija (1,2,3,4)
    @param p_strBoundaryObjId ribojancio HTML elemento id (vietoj window)

*/
function g_hsh_int_fFitToScreen(p_intLeft,p_intTop,p_intWidth,p_intHeight,p_intWantedPos, p_strBoundaryObjId)
{
    /*	1	 _ _ _	4				 1  |  4
		    |	  |                 - - . - -
		    |_ _ _|			         2  |  3
	    2			3
	        points                  positions
    */
    var hsh_int1Fited = new Object();
    hsh_int1Fited['x'] = null;
    hsh_int1Fited['y'] = null;
    hsh_int1Fited['fits'] = false;
    var hsh_int1 = new Object();
    var hsh_int2 = new Object();
    var hsh_int3 = new Object();
    var hsh_int4 = new Object();
    hsh_int1['x'] = p_intLeft;
    hsh_int1['y'] = p_intTop;
    hsh_int2['x'] = p_intLeft;
    hsh_int2['y'] = p_intTop + p_intHeight;

    hsh_int4['x'] = p_intLeft + p_intWidth;
    hsh_int4['y'] = p_intTop;
    hsh_int3['x'] = hsh_int4['x'];
    hsh_int3['y'] = hsh_int2['y'];
    switch(p_intWantedPos)
    {
	    case 1:
	    // revrersing 43
		    hsh_int4['x'] = hsh_int4['x'] - 2 * p_intWidth;
		    hsh_int3['x'] =  hsh_int4['x'];
	    //	checking 41 reversed
		    var bln41ReversedFits = true;
		    if(g_bln_fIsOnScreen(hsh_int4['x'],hsh_int4['y'],p_strBoundaryObjId)== false) bln41ReversedFits = false;
		    if(g_bln_fIsOnScreen(hsh_int1['x'],hsh_int1['y'],p_strBoundaryObjId)== false) bln41ReversedFits = false;
		    if(bln41ReversedFits == true)
		    {
		    // reversing 32
			    hsh_int3['y'] = hsh_int3['y'] - 2*p_intHeight;
			    hsh_int2['y'] =  hsh_int3['y'];
		    //checking reversed 32
			    var bln32ReversedFits = true;
			    if(g_bln_fIsOnScreen(hsh_int3['x'],hsh_int3['y'],p_strBoundaryObjId)== false) bln32ReversedFits = false;
			    if(g_bln_fIsOnScreen(hsh_int2['x'],hsh_int2['y'],p_strBoundaryObjId)== false) bln32ReversedFits = false;
			    if(bln32ReversedFits == true)
			    {
				    hsh_int1Fited['x'] = hsh_int3['x'];
				    hsh_int1Fited['y'] = hsh_int3['y'];
				    hsh_int1Fited['fits'] = true;
			    }
		    }
		    break;
	    case 2:
		    var bln12Fits = true;
	    // checking 12
		    if(g_bln_fIsOnScreen(hsh_int1['x'],hsh_int1['y'],p_strBoundaryObjId)== false) bln12Fits = false;
		    if(g_bln_fIsOnScreen(hsh_int2['x'],hsh_int2['y'],p_strBoundaryObjId)== false) bln12Fits = false;
		    if(bln12Fits == true)
		    {
		    // revrersing 43
			    hsh_int4['x'] = hsh_int4['x'] - 2*p_intWidth;
			    hsh_int3['x'] =  hsh_int4['x'];
		    //	checking 43 reversed
			    var bln43ReversedFits = true;
			    if(g_bln_fIsOnScreen(hsh_int4['x'],hsh_int4['y'],p_strBoundaryObjId)== false) bln43ReversedFits = false;
			    if(g_bln_fIsOnScreen(hsh_int3['x'],hsh_int3['y'],p_strBoundaryObjId)== false) bln43ReversedFits = false;
			    if(bln43ReversedFits == true)
			    {
				    hsh_int1Fited['x'] = hsh_int4['x'];
				    hsh_int1Fited['y'] = hsh_int4['y'];
				    hsh_int1Fited['fits'] = true;
			    }
		    }
		    break;
	    case 3:
		    var bln14Fits = true;
		    // start checking 14
		    if(g_bln_fIsOnScreen(hsh_int1['x'],hsh_int1['y'],p_strBoundaryObjId)== false) bln14Fits = false;
		    if(g_bln_fIsOnScreen(hsh_int4['x'],hsh_int4['y'],p_strBoundaryObjId)== false) bln14Fits = false;
		    if(bln14Fits == true)
		    {
		    // checking 23
			    var bln23Fits = true;
			    if(g_bln_fIsOnScreen(hsh_int2['x'],hsh_int2['y'],p_strBoundaryObjId)== false) bln23Fits = false;
			    if(g_bln_fIsOnScreen(hsh_int3['x'],hsh_int3['y'],p_strBoundaryObjId)== false) bln23Fits = false;
			    if(bln23Fits == true)
			    {
				    hsh_int1Fited['x'] = hsh_int1['x'];
				    hsh_int1Fited['y'] = hsh_int1['y'];
				    hsh_int1Fited['fits'] = true;
			    }
		    }
		    break;
	    case 4:
		    var bln14Fits = true;
		    // checking 14
		    if(g_bln_fIsOnScreen(hsh_int1['x'],hsh_int1['y'],p_strBoundaryObjId)== false) bln14Fits = false;
		    if(g_bln_fIsOnScreen(hsh_int4['x'],hsh_int4['y'],p_strBoundaryObjId)== false) bln14Fits = false;
		    if(bln14Fits == true)
		    {
			    // reversing 23
			    hsh_int2['y'] = hsh_int2['y'] - 2*p_intHeight;
			    hsh_int3['y'] = hsh_int2['y'] ;
			    // checking reversed 23
			    var bln23ReversedFits = true;
			    if(g_bln_fIsOnScreen(hsh_int2['x'],hsh_int2['y'],p_strBoundaryObjId)== false) bln23ReversedFits = false;
			    if(g_bln_fIsOnScreen(hsh_int3['x'],hsh_int3['y'],p_strBoundaryObjId)== false) bln23ReversedFits = false;
			    if(bln23ReversedFits == true)
			    {
				    hsh_int1Fited['x'] = hsh_int2['x'];
				    hsh_int1Fited['y'] = hsh_int2['y'];
				    hsh_int1Fited['fits'] = true;
			    }
		    }
    }
    return hsh_int1Fited;
}








// JScript File

/**
    p_strId,
    p_arr_strElementsToHandle,
    p_intTimeout,
    p_fOpenFunction,
    p_fCanClose,
    p_fClose
*/
function clsNoClickEventShooter(p_strId,
                                p_arr_strElementsToHandle,
                                p_intTimeoutToShow,
                                p_intTransitionTimeout,
                                p_intTimeoutToHide,
                                p_blnNeedToMove,
                                p_fOpen,
                                p_fCanClose,
                                p_fClose)
{
    var cTimesToClose = 4;

    var strId = 'Shooter_' + p_strId;
    var arr_strElementsToHandle = p_arr_strElementsToHandle;
    var intTimeoutToShow = p_intTimeoutToShow;
    var intTransitionTimeout = p_intTransitionTimeout;
    var intTimeoutToHide = p_intTimeoutToHide / cTimesToClose;
    var blnNeedToMove = p_blnNeedToMove;
    var fOpenHandler = p_fOpen;
    var fCanCloseHandler = p_fCanClose;
    var fCloseHandler = p_fClose;

    var objCurrentElementToShow = null;
    var objCurrentlyShownElement = null;
    var objCurrentEvent = null;
    var intSeed = 0;
    var blnIsOpened = false;
    var blnWasClosed = false;
    var arr_intMousePosition;

    var intLeftToClose;
    var blnInited = false;
    var blnGo = false;
    var blnBlocked = false;
    var blnIsOnMenu = false;

    var objThis = this;

    this.g_fStart = function()
    {
        blnGo = true;
        if (!blnInited)
	    {
	        fInit();
	        blnInited = true;
	    }
    }

    this.g_fStop = function()
    {
        blnGo = false;
    }

    function fInit()
    {
        objTimeoutHelper.g_fTimeoutFunction = fOpenOnDelay;
        addEvent(document, 'mouseover', fOver);
	    addEvent(document, 'mouseout', fOut);
	    addEvent(document, 'mousedown', fMouseDown);
	    addEvent(document, 'mousemove', fMouseMove);
	    addEvent(window, 'unload', fUninit);
	}

	this.g_fUninit = function()
	{
	    fUninit();
	}

	function fUninit()
	{
	    removeEvent(document, 'mouseover', fOver);
	    removeEvent(document, 'mouseout', fOut);
	    removeEvent(document, 'mousedown', fMouseDown);
	    removeEvent(document, 'mousemove', fMouseMove);
	    removeEvent(window, 'unload', fUninit);
	}

	function fOver(e)
	{
	    if (!blnGo) return;
	    var objHTMLElement = getSrcElement(e);
        if (objHTMLElement != objCurrentElementToShow)
        {
            objCurrentElementToShow = objHTMLElement;
        }
        if (objCurrentElementToShow == objCurrentlyShownElement) return;
        var intTimeout = blnIsOpened ? intTransitionTimeout : intTimeoutToShow;
        var intNextSeed = int_fGetNextSeed();
        var strDescriptor = objHTMLElement.id ? objHTMLElement.id : objHTMLElement;
        objHTMLElement.setAttribute(strId, intNextSeed);
        setTimeout('objTimeoutHelper.g_fTimeoutFunction(\'' + intNextSeed + '\')', intTimeout);
	}

	function fOut(e)
	{
	    if (!blnGo) return;
	    var objHTMLElement = getSrcElement(e);
	    objHTMLElement.removeAttribute(strId);
	    var strDescriptor = objHTMLElement.id ? objHTMLElement.id : objHTMLElement;

	}

	function fMouseDown(e)
	{
	    if (!blnGo) return;
	    if (!blnIsOpened && !blnIsOnMenu)
	    {
	        var objHTMLElement = getSrcElement(e);
	        objCurrentElementToShow = objHTMLElement;
	        fShow(objCurrentElementToShow, true);
	    }
	}

	function fMouseMove(e)
	{
	    arr_intMousePosition = getMouse(e);
	}

	function fOpenOnDelay(p_intSeed)
	{
	    var strGotSeed = objCurrentElementToShow.getAttribute(strId);
        if (!strGotSeed) return;
        var arr_blnState = arr_fCallGetState(true);
        if ((strGotSeed == p_intSeed) && arr_blnState[0] && !arr_blnState[1])
        {
            fShow(objCurrentElementToShow);
        }
	}

	function fCloseOnDelay()
	{
	    var arr_blnState = arr_fCallGetState();
	    if (arr_blnState[1])
	    {
	        fClose();
	    }
	    else
	    if (arr_blnState[0])
	    {
	        intLeftToClose--;
	        if (intLeftToClose <= 0)
	        {
	            fClose();
	        }
	        else
	        {
	            setTimeout(fCloseOnDelay, p_intTimeoutToHide);
	        }
	    }
	    else
	    {
	        intLeftToClose = cTimesToClose;
	        setTimeout(fCloseOnDelay, p_intTimeoutToHide);
	    }
	}

	function fShow(p_objCurrentElementToShow, p_blnIgnoreRestrictions)
	{
	    if(!p_blnIgnoreRestrictions)
	    {
	        if (blnBlocked) return;
	        if (objCurrentlyShownElement == p_objCurrentElementToShow) return;
	    }
	    blnIsOpened = true;
	    objCurrentlyShownElement = p_objCurrentElementToShow;
	    var hshEvent = new Object();
	    hshEvent['event'] = new Object;
	    hshEvent['event']['mousePosition'] = arr_intMousePosition;
	    hshEvent['element'] = objCurrentlyShownElement;
	    if (typeof(fOpenHandler) == 'function')
        {
            fOpenHandler(hshEvent);
        }
        setTimeout(fCloseOnDelay, p_intTimeoutToHide);
        intLeftToClose = cTimesToClose;
	}

	function fClose()
	{
	    blnIsOpened = false;
        if (typeof(fCloseHandler) == 'function')
        {
            fCloseHandler();
        }
        if (objCurrentlyShownElement != objCurrentElementToShow)
        {
            objCurrentlyShownElement = null;
            fShow(objCurrentElementToShow);
        }
	}

	function arr_fCallGetState(p_blnIgnoreBlocked)
	{
	    if (typeof(fCanCloseHandler) != 'function')
	    {
	        blnBlocked = true;
	        return true;
	    }
	    var arr_blnState = fCanCloseHandler(blnNeedToMove);
	    if (!p_blnIgnoreBlocked && arr_blnState[0] && blnBlocked == false)
	    {
	        blnBlocked = true;
	        setTimeout(fUnblock, intTimeoutToShow);
	    }
	    blnIsOnMenu = arr_blnState[2];
	    return [arr_blnState[1], blnBlocked];
	}

	function fUnblock()
	{
	    blnBlocked = false;
	}


	function int_fGetNextSeed()
	{
	    intSeed++;
	    if (intSeed > 1000000)
            intSeed = 0;
        return intSeed;
	}
}

var g_objTranslator = new clsTranslator();

function clsTranslator()
{
    var strId = 'Translator1';
    var objEventShooter;
    var objMenu;
    var intMaxMenuNodes = 50;
    var objCurrentEvent = null;
    var blnShowFull = false;

    this.g_fInit = function()
    {
        var objDiv = document.createElement('DIV');
        objDiv.id = strId;
        document.body.appendChild(objDiv);

        var hshArg = new Object();
	    hshArg['strId'] = strId + '_Menu';
	    hshArg['strParentId'] = strId;
	    hshArg['intNodeWidth'] = null;//230;
	    hshArg['intNodeHeight'] = 20;
	    hshArg['zindex'] = 1000;
	    hshArg['strMenuBorderStyle'] = '1px outset menu';//'1px solid #f00ff0';
	    hshArg['strRightColor'] = 'white';
        hshArg['strLeftColor'] = 'gainsboro';
        hshArg['strSelectLeftColor'] = 'silver';
        hshArg['strSelectRightColor'] = 'silver';
        hshArg['strNodeMenuBorderStyle'] = '1px outset menu';
        hshArg['strBreakerPicture'] = 'breaker.gif';
        hshArg['strDisabledFontColor'] = 'gray';
	    var hshEvents = new Object();
	    hshEvents['MenuClick'] = fMenuClick;
	    hshEvents['BuildMenu'] = fBuildMenu;
	    hshEvents['HideMenu'] = fHideMenu;
	    hshEvents['ShowMenu'] = fShowMenu;
	    var arr_intPositions = [9, 8, 6, 7, 3, 4, 2, 1, 5];
	    objMenu = new clsLightMenu(hshArg, hshEvents, arr_intPositions, true, 5);
	    objMenu.g_fInit();
        objEventShooter = new clsNoClickEventShooter('EventShooter1', null, 500, 200, 1000, false,
	        objMenu.g_fOpen, objMenu.g_arr_fGetState, objMenu.g_fClose);
	    objEventShooter.g_fStart();

        addEvent(window, 'unload', fUninit);
	}

	function fUninit()
	{
	    if (objEventShooter) objEventShooter.g_fUninit();
	    if (objMenu) objMenu.g_fUninit();
	    objCurrentEvent = null;
	    removeEvent(window, 'unload', fUninit);
	}

    function fMenuClick(p_strNode)
    {
        g_fDynaTranslate(p_strNode);
    }

    /**
        Vertimo dialogo iskvietimo funkcija
    */
    function g_fDynaTranslate(p_strTag)
    {
        var objData = new Object();
        objData['project'] = 'CMCMain';
        objData['file'] = cLANG_PATH;
        objData['tag'] = p_strTag;
        // Kvieciamas vertimo dialogas
        var hshRet = openDialog(cLANG_TOOL_PATH + 'forms/frmTagEdit.aspx', 400, 500, objData, 'no');
        if(hshRet != null)
        {
//            if(p_objElement != null && p_objElement.innerHTML)
//            {
//                p_objElement.innerHTML = hshRet[cLANG];
//            }
        }
    }

    function fBuildMenu(p_objEvent, p_objMenu)
    {
        objCurrentEvent = p_objEvent;
        var hshResult = hshGetUntranslatedWords(p_objEvent['element']);
        for (var i = 0; i < hshResult['list'].length && (i < intMaxMenuNodes || blnShowFull); i++)
        {
            p_objMenu.g_fInsert('root', hshResult['list'][i], [hshResult['list'][i]], 'text');
        }
//        if (!hshResult['fullList'])
//        {
//            p_objMenu.g_fInsert('root', '[expand]', ['...'], 'text');
//        }
        blnShowFull = false;
    }

    function hshGetUntranslatedWords(p_objElement)
    {
        var hshResult = new Object();
        hshResult['fullList'] = true;
        hshResult['list'] = new Array();
        var hshStringHolder = new Object();
        var intGotWords = int_fGetUntranslatedWordsFromNode(hshStringHolder, p_objElement, 0);
        hshResult['fullList'] = blnShowFull ? true : intGotWords <= intMaxMenuNodes;
        for (var key in hshStringHolder)
        {
            hshResult['list'].push(key);
        }
        return hshResult;
    }

    function int_fGetUntranslatedWordsFromNode(p_hshStringHolder, p_objNode, p_intGotWords)
    {
        var intGotWords = p_intGotWords;
        if (!p_objNode) return intGotWords;
        var i;
        intGotWords = int_fGetUntranslatedWordsFromString(p_hshStringHolder, p_objNode.innerHTML, intGotWords);
        return intGotWords;
//        if (p_objNode.attributes)
//        {
//            for (i = 0; i < p_objNode.attributes.length; i++)
//            {
//                intGotWords = int_fGetUntranslatedWordsFromString(p_hshStringHolder, p_objNode.attributes[i].value, intGotWords);
//                if (!blnShowFull && intGotWords > intMaxMenuNodes) return intGotWords;
//            }
//        }
//
//        if (p_objNode.nodeType == 3)
//        {
//            intGotWords = int_fGetUntranslatedWordsFromString(p_hshStringHolder, p_objNode.nodeValue, intGotWords);
//            if (!blnShowFull && intGotWords > intMaxMenuNodes) return intGotWords;
//        }
//        else if (p_objNode.childNodes)
//        {
//            for (i = 0; i < p_objNode.childNodes.length; i++)
//            {
//                intGotWords = int_fGetUntranslatedWordsFromNode(p_hshStringHolder, p_objNode.childNodes[i], intGotWords);
//                if (!blnShowFull && intGotWords > intMaxMenuNodes) return intGotWords;
//            }
//        }

    }

    function int_fGetUntranslatedWordsFromString(p_hshStringHolder, p_strTestedString, p_intGotWords)
    {
        if (p_strTestedString == null) return p_intGotWords;
        var intGotWords = p_intGotWords;
        var arr = p_strTestedString.match(/\[([^\[\]]+)\]/g);
        //var arr = /\[([^\[\]]+)\]/g.exec(p_strTestedString);
        if (!arr) return intGotWords;
        var substr = '';
        for (var i = 0; i < arr.length; i++)
        {
            substr = arr[i].substring(1, arr[i].length - 1);
            if (!p_hshStringHolder[substr]) intGotWords++;
            p_hshStringHolder[substr] = intGotWords;
            if (!blnShowFull && intGotWords > intMaxMenuNodes) return intGotWords;
        }
        return intGotWords;
    }

    function fHideMenu()
    {
    }

    function fShowMenu()
    {
    }
}



/**
    igyvendina Sub klases paveldejima is Base klases. sia funkcija reikia vykdyti globaliai, zemiau
    klasiu aprasu.
    Vaikines klases konstruktoriuje taip pat reikia iskviesti tokia funkcija:
    clsSubClass.baseConstructor.call(this, pBaseClassConstructorArguments);
    @author KM
    @version 1 2006.10.02
*/
function g_fExtend(p_clsSubClass, p_clsBaseClass)
{
   function inheritance() {}
   inheritance.prototype = p_clsBaseClass.prototype;

   p_clsSubClass.prototype = new inheritance();
   p_clsSubClass.prototype.constructor = p_clsSubClass;
   p_clsSubClass.baseConstructor = p_clsBaseClass;
   p_clsSubClass.superClass = p_clsBaseClass.prototype;
}

/**
    Is objektu(hashu) masyvo suformuoja hasha pagal viena pasirinkta rakta. Hasho objektai yra masyvo
    numeriai.
    @author KM
    @version 1 2006.10.02
    @returns object[string] = index
*/
function g_hsh_fHashArrayByKey(p_arr_objInput, p_strKeyField)
{
    var hshReturn = new Object();
    if (p_arr_objInput == null) return hshReturn;
    for (var i = 0; i < p_arr_objInput.length; i++)
    {
        hshReturn[p_arr_objInput[i][p_strKeyField]] = i;
    }
    return hshReturn;
}

/**
    Funkcija, gaunanti detalesni objekto tipa nei typeof().
    http://www.webreference.com/dhtml/column68/
    JS object	    ftypeof() return value

    Boolean 	    boolean
    Function        function
    Number 	        number
    String 	        string
    [ no object ]   undefined

    Arguments	    arguments
    Array 	        array
    Date 	        date
    Error 	        error
    Math 	        math
    Null 	        null
    Object 	        jsobject
    RegExp 	        regexp
    [ custom ] 	    CustomConstructorFunctionName

*/
function ftypeof( vExpression )
{
	var sTypeOf = typeof vExpression;
	if( sTypeOf == "function" )
	{
		return 'function';
//		var sFunction = vExpression.toString();
//		if( ( /^\/.*\/$/ ).test( sFunction ) )
//		{
//			return "regexp";
//		}
//		else if( ( /^\[object.*\]$/i ).test( sFunction ) )
//		{
//			sTypeOf = "object"
//        }
	}
	if( sTypeOf != "object" )
	{
		return sTypeOf;
	}

	switch( vExpression )
	{
		case null:
			return "null";
		case window:
			return "window";
		case window.event:
			return "event";
	}

	if( window.event && ( event.type == vExpression.type ) )
	{
		return "event";
	}

	if(vExpression.eventPhase != null && vExpression.type != null)
	{
	    return 'event';
	}

	var fConstructor = vExpression.constructor;
    if( fConstructor != null )
	{
		switch( fConstructor )
		{
			case Array:
				sTypeOf = "array";
				break;
			case Date:
				return "date";
			case RegExp:
				return "regexp";
			case Object:
				sTypeOf = "jsobject";
				break;
			case ReferenceError:
				return "error";
			default:
				var sConstructor = fConstructor.toString();
				var aMatch = sConstructor.match( /\s*function (.*)\(/ );
				if( aMatch != null )
				{
					return 'jsobject';//+aMatch[ 1 ];
				}

		}
	}

	var nNodeType = vExpression.nodeType;
	if( nNodeType != null )
	{
		switch( nNodeType )
		{
			case 1:
				if( vExpression.item == null )
				{
					return "domelement";
				}
				break;
			case 3:
				return "textnode";
		}
	}

	if( vExpression.toString != null )
	{
		var sExpression = vExpression.toString();
		var aMatch = sExpression.match( /^\[object (.*)\]$/i );
		if( aMatch != null )
		{
			var sMatch = aMatch[ 1 ];
			switch( sMatch.toLowerCase() )
			{
				case "event":
					return "event";
				case "math":
					return "math";
				case "error":
					return "error";
				case "mimetypearray":
					return "mimetypecollection";
				case "pluginarray":
					return "plugincollection";
				case "windowcollection":
					return "window";
				case "nodelist":
				case "htmlcollection":
				case "elementarray":
					return "domcollection";
			}
		}
	}

	if( vExpression.moveToBookmark && vExpression.moveToElementText )
	{
		return "textrange";
	}
	else if( vExpression.callee != null )
	{
		return "arguments";
	}
	else if( vExpression.item != null )
	{
		return "domcollection";
	}

	return sTypeOf;
}

/**
    Padavus vaizdo Id grazina to vaizdo filtrus.
    @param p_strViewId {string} Norimo gauti vaizdo Id. Jei nenurodytas, tai isrenka visus.
    @param p_blnSelectForGrid {bool} Jei true, tai uzklausa vykdo su g_hsh_fSelectDataForGrid funkcija,
    priesingu atveju naudoja paprasta uzklausa.
    @param p_blnFavorites {bool} Nurodo papildoma apribojima ar selectinti tik favoritus - galimos reiksmes:
        null - selectinti visus;
        true - selectinti tik favoritus;
        false - selectinti tik ne favoritus;
    @author KM
    @version 1 2006-10-12
*/
function g_arr_obj_fGetFilters(p_strViewId, p_blnSelectForGrid, p_blnFavorites)
{
    var strWhereClause = '';
    if (p_strViewId != null)
    {
        strWhereClause = " WHERE [viewId] = " + p_strViewId + " ";
    }
    if (p_blnFavorites != null) // Prideda apribojimus pagal p_blnFavorites kintamaji
    {
        var intBitValue = p_blnFavorites? 1 : 0;
        var strCondition = '[isFavorite] = ' + intBitValue;
        if (strWhereClause == '')
        {
            strWhereClause = ' WHERE ' + strCondition;
        }
        else
        {
            strWhereClause += ' AND ' + strCondition;
        }
    }
    var strConn = '[confCmcDbString]';
	var strSelect = 'SELECT *, \'\' as bcTypes FROM [tblSearchMain]' + strWhereClause;
	if (p_blnSelectForGrid)
	    return g_hsh_fSelectDataForGrid( strConn, strSelect, null );
	else
	    return g_arr_hsh_fSimpleSelect(strSelect, true, strConn);
}

var objTimeoutHelper = new Object();


/**
    @class
    Sukuria metodo iskvietimo objekta
    @param p_objContext - Objektas, kuriam priklauso kvieciamas metodas. Jei null, tai laikoma, kad tai yra window objektas
    @param p_objFunction - Funkcija, kuria reikia kviesti, tai arba jos pavadinimas, arba funkcijos objektas
    @param p_intDelay - Kiek laukti pries kvieciant metoda
    @param arguments[3 ...] - Funkcijos argumentai, kurie bus perduoti i funkcija kvietimo metu
    @author KM
    @version 1 2006.10.14
*/
function clsFunctionCaller(p_objFunction, p_objContext, p_intDelay)
{
    var arr_objTempArray = arguments;
    if (arguments.length == 1)  // Jei viskas nurodyta viename masyve
    {
        arr_objTempArray = arguments[0];
        p_objFunction = arr_objTempArray[0];
        p_intDelay = arr_objTempArray[2];
        p_objContext = arr_objTempArray[1];
    }

    this.g_intId = 'AsyncCaller' + (g_objAsyncCaller.g_intCounter++);
    this.g_intDelay = p_intDelay;
    this.objFunction = p_objFunction;
    this.g_strTimerId = 0;
    this.objContext = p_objContext;
    this.arr_objArguments = [];
    for (var i = 3; i < arr_objTempArray.length; i++)  // Surenka likusius argumentus
    {
        this.arr_objArguments.push(arr_objTempArray[i]);
    }
    this.blnHasBeenCalled = false;
    this.fCallBack = null;
    this.g_objReturn = null;
    this.g_fResult = null;

    /**
        Iskviecia funkcija sinchroniskai
    */
    this.g_fExecute = function()
    {
        delete g_objAsyncCaller.g_hshPendingCalls[this.g_intId];
        if (this.objContext == null)    // Jei funkcijos kontekstas yra null, tai laikoma, kad tai window objektas
            this.objContext = window;

        if (typeof(this.objFunction) == 'string') // Jei funkcija pateikta kaip eilute, tai susirandam ta funkcija
            this.objFunction = this.objContext[this.objFunction];

        if (typeof(this.objFunction) == 'function')     // Jei funkcija rasta, tai ja iskvieciam
            this.g_fResult = this.objFunction.apply(this.objContext, this.arr_objArguments);

        this.blnHasBeenCalled = true;
        Listener.fire(this, 'onEnd', [this.g_fResult]);
    }

    /**
        Nurodo funkcija, kuri bus iskviesta po to, kai bus ivykdyta pagrindine funkcija.
    */
    this.g_fAddExecutionEndListener = function(p_fFunction, p_objContext)
    {
        Listener.add(this, 'onEnd', p_fFunction, p_objContext, false);
    }

    /**
        Atsaukia funkcijos vykdyma
    */
    this.g_fCancel = function()
    {
        clearTimeout(this.g_strTimerId);
        g_objAsyncCaller.g_hshPendingCalls[this.g_intId] == null;
    }

    /**
        Parodo ar funkcija jau buvo kviesta
    */
    this.g_bln_fHasBeenCalled = function()
    {
        return this.blnHasBeenCalled;
    }

    /**
        Paleidzia funkcijos iskvietimo taimeri is naujo. Jei taimeris jau eina, tai paleidzia is naujo.
    */
    this.g_fStartCounter = function()
    {
        if (arguments.length > 0)
            this.arr_objArguments = arguments;
        if (!g_objAsyncCaller.g_hshPendingCalls[this.g_intId])
            g_objAsyncCaller.g_hshPendingCalls[this.g_intId] = this;
        else
        {
            clearTimeout(this.g_strTimerId);
        }
        g_objAsyncCaller.g_hshPendingCalls[this.g_intId].g_strTimerId =
            setTimeout('g_objAsyncCaller.g_hshPendingCalls["' + this.g_intId + '"].g_fExecute()', this.g_intDelay);
    }

    g_objAsyncCaller.g_hshPendingCalls[this.g_intId] = this;
}


//----------------------------------------------------------------------------------------------
/**
    Globalus asinchroninio iskvietimo objektas.
    @author KM
    @version 1 2006.10.14

    Panaudojimo pavyzdys.

    function TestClass(p_intA)
    {
        this.A = p_intA;
        this.Funkcija2 = function(p_arg, arg1)
        {
        }
    }

    function Funkcija1(p_arg)
    {
        console('Paprasta funkcija');
        console('p_arg: ' + p_arg);
    }

    function AsyncTest()
    {
        var objCaller = new clsFunctionCaller(Funkcija1, null, 700, 1);
        g_objAsyncCaller.g_fAsyncCall(objCaller);

        var objCaller = new clsFunctionCaller('Funkcija1', null, 500, 2);
        g_objAsyncCaller.g_fAsyncCall(objCaller);

        var test = new TestClass('pirmas');

        var objCaller = new clsFunctionCaller('Funkcija2', test, 1000, 3);
        objCaller.g_fSetCallback(Funkcija1);
        g_objAsyncCaller.g_fAsyncCall(objCaller);

        var objCaller = new clsFunctionCaller(test.Funkcija2, test, 200, 4, 6);
        g_fAsyncCall(objCaller);
        objCaller.g_fCancel();

        var objCaller = new clsFunctionCaller(test.Funkcija2, test, 200);
        objCaller.g_fStartCounter('arg1', 'arg2', 'arg3');

        g_fAsyncCallImediate(test.Funkcija2, null, 0, 5);

    }
*/
g_objAsyncCaller = {};
g_objAsyncCaller.g_intCounter = 0;
g_objAsyncCaller.g_hshPendingCalls = {};

/**
    Nustato iskviesti clsFunctionCaller objekto metoda g_fExecute po tam tikro laiko g_intDelay.
    @param p_objFunctionCaller {clsFunctionCaller} Funkcijos iskvietimo objektas.
*/
function g_fAsyncCall(p_objFunctionCaller)
{
    // Jei egzistuoja toks objektas
    if (g_objAsyncCaller.g_hshPendingCalls[p_objFunctionCaller.g_intId])
    {
        if (g_objAsyncCaller.g_hshPendingCalls[p_objFunctionCaller.g_intId].g_strTimerId != 0)
            clearTimeout(this.g_strTimerId);
        g_objAsyncCaller.g_hshPendingCalls[p_objFunctionCaller.g_intId].g_strTimerId =
            setTimeout('g_objAsyncCaller.g_hshPendingCalls["' + p_objFunctionCaller.g_intId + '"].g_fExecute()',
                p_objFunctionCaller.g_intDelay);
    }
}
g_objAsyncCaller.g_fAsyncCall = g_fAsyncCall;

/**
    Sukuria ir is karto iskviecia funkcija asinchroniskai.
    Argumentai tokie patys, kaip clsFunctionCaller konstruktoriaus.
    @returns Sukurtaji funkcijos kvietimo objekta.
    @type clsFunctionCaller objektas
*/
function g_obj_fAsyncCallImediate()
{
    var arr_objArguments = [];
    for (var i = 0, intLength = arguments.length; i < intLength; i++)  // Surenka argumentus
    {
        arr_objArguments.push(arguments[i]);
    }
    var objCaller = new clsFunctionCaller(arr_objArguments);//new clsFunctionCaller(arr_objArguments);//new clsFunctionCaller.apply(window, arguments);
    g_objAsyncCaller.g_fAsyncCall(objCaller);
    return objCaller;
}
g_objAsyncCaller.g_fAsyncCallImediate = g_obj_fAsyncCallImediate;
//----------------------------------------------------------------------------------------------

/**
    Is hashu masyvo elementu isrenka tik tam tikra lauka ir ji iraso i nauja masyva.
    @param p_arr_hshInput {hash[]} Hashu masyvas.
    @param p_strKey {string} Issirinktas laukas.
    @returns Eiluciu masyva.
    @type string[]
*/
function g_arr_str_fGetListing(p_arr_hshInput, p_strKey)
{
    if (p_strKey == null)
        return g_obj_fClone(p_arr_hshInput);
    if (p_arr_hshInput == null)
        return p_arr_hshInput;
    var arr_strResult = new Array();
    var intLength = p_arr_hshInput.length;
    for (var i = 0; i < intLength; i++)
    {
        arr_strResult.push(p_arr_hshInput[i][p_strKey]);
    }
    return arr_strResult;
}
//-----------------------------------------------------------------------------------------
var g_objDialogWithTreeSizes = new clsDialogWithTreeSizes();
/**
    DA laikina klase, skirta paimti langu dydziams
*/
function clsDialogWithTreeSizes()
{
    this.g_hshSizes = new Object();

    var hshTemp = new Object();
   /* hshTemp['intIEDialogWidth'] = 860;
    hshTemp['intIEDialogHeight'] = 550;
    hshTemp['intIEWindowWidth'] = 850;
    hshTemp['intIEWindowHeight'] = 520;*/
    hshTemp['intMozDialogWidth'] = 855;//860
    hshTemp['intMozDialogHeight'] = 523;
    hshTemp['intMozWindowWidth'] = 855;//860
    hshTemp['intMozWindowHeight'] = 526;
    hshTemp['intTabWidth'] = 675;
    hshTemp['intTabHeight'] = 385;
    this.g_hshSizes['normal'] = hshTemp;

}
//-----------------------------------------------------------------------------------------
addEvent(document, 'help', g_fStopEvent);

/**
    Sujungia du hashus. Pirma parametra laiko defaultiniu, o ant jo virsaus uzraso antraji hasha.
    Kopijuojant daro kopijas taip, kad nepakeistu paduotu objektu.
    @param p_hshDefaults - hashas, ant kurio virsaus uzrasoma.
    @param p_hshSpecificSettings - hashas, kuri uzraso ant virsaus.
    @author KM
    @version 1 2006-11-30
*/
function g_hsh_fMergeHashes(p_hshDefaults, p_hshSpecificSettings)
{
    var hshCopy = g_obj_fClone(p_hshDefaults);
    if (hshCopy == null)    // Jei defaultu nera, tai tiesiog perkopijuojam antra hasha
        return g_obj_fClone(p_hshSpecificSettings);
    for(var i in p_hshSpecificSettings)
		hshCopy[i] = g_obj_fClone(p_hshSpecificSettings[i]);
	return hshCopy;
}


function g_str_fEscapeForXml(p_strValue)
{
    return p_strValue.replace(/</g, '&lt;').replace(/>/g, '&gt;');
}

/**
    Patikrina ar paduota reiksme yra integer tipo ar ne.
*/
function g_bln_fIsInt(p_objValue)
{
    var intValue = parseInt(p_objValue);
    if (isNaN(intValue)) return false;
    return p_objValue == intValue && p_objValue.toString() == intValue.toString();
}


/**
    Ideja tokia - padaryti universalu buda is XML eilutes gauti hash struktura. Transformacija atliekama
    taip - nuskaitomas tago pavadinimas ir pagal ji uzhashuojama tevo hashe. Jei elementas turi tekstine reiksme,
    tai ji issaugoma elemente, kurio raktas yra '_val'. Jei xml elementas turi kelis vaikus su tuo paciu
    pavadinimu, tai sie vaikai dedami i masyva.
    @author KM
*/
function g_hsh_fGetHashFromXml(p_strXml)
{
    var hshResult = new Object();
    var objDoc = getXml(p_strXml);
    var mainNode = getChildren(objDoc)[0];
    fParseXML(hshResult, mainNode);
    return hshResult;
}

/**
    Rekursine funkcija, pereinanti XML medzio struktura.
*/
function fParseXML(p_hshParent, p_objNode)
{
    if (p_objNode.nodeType == 1)
    {
        var tagName = p_objNode.tagName;
        var hshPart = new Object();
        if (p_hshParent[tagName] == null)
        {
            p_hshParent[tagName] = hshPart;
        }
        else
        if (ftypeof(p_hshParent[tagName]) == 'array')
        {
            p_hshParent[tagName].push(hshPart);
        }
        else
        {
            var objTemp = p_hshParent[tagName];
            p_hshParent[tagName] = new Array();
            p_hshParent[tagName].push(objTemp);
            p_hshParent[tagName].push(hshPart);
        }

        if (p_objNode.attributes)
        {
            for (i = 0; i < p_objNode.attributes.length; i++)
            {
                hshPart[p_objNode.attributes[i].nodeName] = p_objNode.attributes[i].nodeValue;
            }
        }
        for (var i = 0; i < p_objNode.childNodes.length; i++)
        {
            fParseXML(hshPart, p_objNode.childNodes[i]);
        }
    }
    else if (p_objNode.nodeType == 3)
    {
        if (p_hshParent['_val'] == null) p_hshParent['_val'] = '';
        p_hshParent['_val'] += p_objNode.nodeValue;
    }
}
/**
    Objekta uzkoduoja xml stringu.
*/
function g_str_fGetXmlFromObject(p_objObject, p_strKey, p_intLevel)
{
    if (p_intLevel <= 0)
        return '';
    if (p_strKey == null || p_strKey == '')
    {
        p_strKey = 'root';
    }
    var strReturn = '<' + g_str_fClearXmlEntities('' + p_strKey) + '>';
    if(typeof(p_objObject) == 'object' && p_objObject != null)
    {
        if (p_objObject.constructor == Array)
        {
            for(var intKey in p_objObject)
            {
                if (g_bln_fIsInt(intKey) && typeof (p_objObject[intKey]) != 'undefined')
                {
                    strReturn += g_str_fGetXmlFromObject(p_objObject[intKey], intKey, p_intLevel - 1);
                }
            }
        }
        else
        if (p_objObject.constructor == Object || p_objObject.constructor.toString().match(/\s*function (.*)\(/))
        {
            for(strKey in p_objObject)
            {
                strReturn += g_str_fGetXmlFromObject(p_objObject[strKey], strKey, p_intLevel - 1);
            }
        }
        else
            strReturn += g_str_fEscapeXmlEntities('' + p_objObject);
    }
    else
    {
        if (p_objObject != null)
            strReturn += g_str_fEscapeXmlEntities('' + p_objObject);
    }
    strReturn += '</' + g_str_fClearXmlEntities('' + p_strKey) + '>';
    return strReturn;
}
function g_str_fEscapeXmlEntities(p_strXmlString)
{
    return p_strXmlString.replace('/&/g', '&amp;').replace('/\'/g', '&apos;').replace('/\'/g', '&quot;').replace('/>/g', '&gt;').replace('/</g', '&lt;');
}
function g_str_fClearXmlEntities(p_strXmlString)
{
    var objRegexp = new RegExp('[\'\"&><]','gi');
    return p_strXmlString.replace(objRegexp, '');
}

/**
    Nustato ar buvo paspaustas kairysis peles mygtukas
    @param p_objEvent Event objektas
    @type bool
*/
function g_bln_fIsLeftClick(p_objEvent)
{
    return cIE && p_objEvent.button == 1 || cFF && p_objEvent.button == 0;
}

/**
    Nustato ar buvo paspaustas desinysis peles mygtukas
    @param p_objEvent Event objektas
    @type bool
*/
function g_bln_fIsRightClick(p_objEvent)
{
    return p_objEvent.button == 2;
}

/**
    Nustato ar buvo paspaustas vidurinysis peles mygtukas
    @param p_objEvent Event objektas
    @type bool
*/
function g_bln_fIsMiddleClick(p_objEvent)
{
    return cIE && p_objEvent.button == 4 || cFF && p_objEvent.button == 1;
}

/**
    Skirta universaliam veiksmu iskvietimui klavisais.
    @author Rimantas Sipkus
    @version 1.0 2007.01.09
    @constructor
*/
function clsKeyManager(p_strId, p_objPlatform)
{
    this.g_strId = p_strId;
    var objThis = this;
    if(p_objPlatform == null) p_objPlatform = document;
    var objPlatform = p_objPlatform;
    var arr_hshKeyMap = new Array();
    var arr_hshFKeyMap = new Array();
    var blnEnabled = true;
    //-----------------------------------------------
    this.g_fSetEnabled = function(p_blnEnabled)
    {
        blnEnabled = p_blnEnabled;
    }
    //-----------------------------------------------
    /**
        @p_fHandler - funkcija kuris bus vykdoma pagavus registruota klavisa
        @p_intKey - raide ARBA
                    simbolio kodas ARBA
                    Klaviso hashas (is jau sudarytu), pvz g_objDefaultKeysMap.cNEW, tuomet nereikia paduoti nieko daugiau
        @p_blnCtrl - ar reikalingas nuspaustas Ctrl
        @p_blnShift - ar reikalingas nuspaustas Shift
        @p_blnAlt - ar reikalingas nuspaustas Alt
        @p_strTag - operacijos tagas (reikalingas tam kad butu galima identifikuoti operacijas CASE'e)
        @p_blnStopDefault - ar iskvietus handleri stabdyti ivyki
    */
    this.g_fRegister = function(p_fHandler, p_intKey, p_blnCtrl, p_blnShift, p_blnAlt, p_strTag, p_blnStopDefault)
    {
        //var blnIsFKey = false;
        var hshKey = new Object();
        if(typeof(p_intKey) == 'object')
        {
            hshKey = p_intKey;
            if(typeof(hshKey['key']) == 'string')
            {
                hshKey['key'] = (hshKey['key']).charCodeAt(0);
            }
            //blnIsFKey = bln_fIsFKey(hshKey['key']);
            hshKey['handler'] = p_fHandler;
        }
        else
        {
            if(typeof(p_intKey) == 'string')
                hshKey['key'] = p_intKey.charCodeAt(0);
            if(typeof(p_intKey) == 'number')
            {
                hshKey['key'] = p_intKey;
            }
            //blnIsFKey = bln_fIsFKey(hshKey['key']);
            hshKey['ctrl'] = p_blnCtrl;
            hshKey['shift'] = p_blnShift;
            hshKey['alt'] = p_blnAlt;
            hshKey['handler'] = p_fHandler;
            hshKey['tag'] = p_strTag;
            hshKey['stopDefault'] = p_blnStopDefault;
        }
        //if(blnIsFKey || cIE || cFF)
            arr_hshFKeyMap.push(hshKey);
        //else
            //arr_hshKeyMap.push(hshKey);
    }
    //-----------------------------------------------
    function bln_fIsFKey(p_intCode)
    {
        for(intKey in g_objFKeys)
        {
            if(g_objFKeys[intKey] == p_intCode)
                return(true);
        }
        return(false);
    }
    //-----------------------------------------------
    var strUniqueId = 'GKM_' + Math.random() + '_' + new Date();
    function fInit()
    {
        g_objEventManager.g_fAddEvent(strUniqueId, 'keydown', fKeyDown);
        //g_objEventManager.g_fAddEvent(strUniqueId, 'keypress', fKeyPressed);
    }
    //-----------------------------------------------
    addEvent(window, 'unload', fUninit);
    function fUninit()
    {
        g_objEventManager.g_fRemoveEvent(strUniqueId, 'keydown');
        //g_objEventManager.g_fRemoveEvent(strUniqueId, 'keypress');
    }
    //-----------------------------------------------
    function fKeyDown(e, p_hshEvent)
    {
        //&& p_hshEvent['arr_intNavigation'] != null && p_hshEvent['arr_intNavigation'][0] != -1
        if(blnEnabled )
        {
            var intKey = getKeyCode(e);
            for(var i = 0;i < arr_hshFKeyMap.length;i++)
            {
                if(arr_hshFKeyMap[i]['key'] == intKey && arr_hshFKeyMap[i]['ctrl'] == e.ctrlKey && arr_hshFKeyMap[i]['shift'] == e.shiftKey && arr_hshFKeyMap[i]['alt'] == e.altKey)
                {
                    var hshEvent = new Object();
                    hshEvent['key'] = arr_hshFKeyMap[i]['key'];
                    hshEvent['ctrl'] = arr_hshFKeyMap[i]['ctrl'];
                    hshEvent['shift'] = arr_hshFKeyMap[i]['shift'];
                    hshEvent['tag'] = arr_hshFKeyMap[i]['tag'];
                    hshEvent['stopDefault'] = arr_hshFKeyMap[i]['stopDefault'];
                    hshEvent['event'] = e;
                    hshEvent['object'] = objThis;
                    if(hshEvent['stopDefault'])
                        g_fStopEvent(e);
                    // KMarc 2007-05-09
                    g_obj_fAsyncCallImediate(arr_hshFKeyMap[i]['handler'], null, 0, hshEvent);
                }
            }
        }
    }
    //-----------------------------------------------
    /*function fKeyPressed(e)
    {
        if(blnEnabled)
        {
            var intKey = getKeyCode(e);
            for(var i = 0;i < arr_hshKeyMap.length;i++)
            {
                if(arr_hshKeyMap[i]['key'] == intKey && arr_hshKeyMap[i]['ctrl'] == e.ctrlKey && arr_hshKeyMap[i]['shift'] == e.shiftKey && arr_hshKeyMap[i]['alt'] == e.altKey)
                {
                    var hshEvent = new Object();
                    hshEvent['key'] = arr_hshKeyMap[i]['key'];
                    hshEvent['ctrl'] = arr_hshKeyMap[i]['ctrl'];
                    hshEvent['shift'] = arr_hshKeyMap[i]['shift'];
                    hshEvent['tag'] = arr_hshKeyMap[i]['tag'];
                    hshEvent['stopDefault'] = arr_hshKeyMap[i]['stopDefault'];
                    hshEvent['event'] = e;
                    hshEvent['object'] = objThis;
                    arr_hshKeyMap[i]['handler'](hshEvent);
                    if(hshEvent['stopDefault'])
                        g_fStopEvent(hshEvent['event']);
                }
            }
        }
    }*/
    //-----------------------------------------------
    fInit();
    //-----------------------------------------------
}
var g_objKeyManager = new clsKeyManager('globalKeyManager');

/**
    Duomenu struktura su funkciniu klavisu kodais.
    @author Rimantas Sipkus
    @version 1.0 2007.01.09
    @constructor
*/
function clsFKeys()
{
    this.cDEL = 46;
    this.cF1 = 112;
    this.cF2 = 113;
    this.cF3 = 114;
    this.cF4 = 115;
    this.cF5 = 116;
    this.cF6 = 117;
    this.cF7 = 118;
    this.cF8 = 119;
    this.cF9 = 120;
    this.cF10 = 121;
    this.cF11 = 122;
    this.cF12 = 123;
    this.cTAB = 9;
    this.cENTER = 13;
    this.cESC = 27;
    this.cPGUP = 33;
    this.cPGDOWN = 34;
    this.cEND = 35;
    this.cHOME = 36;
    this.cWINDOWS = 91;
    this.cCAPSLOCK = 20;
    this.cSPACE = 32;
}
var g_objFKeys = new clsFKeys();

/**
    Duomenu struktura su standartiniu veiksmu tagais ir juos suzadinanciu klavisu informacija.
    @author Rimantas Sipkus
    @version 1.0 2007.01.09
    @constructor
*/
function clsKeysMap()
{
    this.cNEW = {ctrl:true, shift:false, alt:false, key:78, tag:'001', stopDefault:true};
    this.cDELETE = {ctrl:false, shift:false, alt:false, key:g_objFKeys.cDEL, tag:'002', stopDefault:true};
    this.cEDIT = {ctrl:true, shift:false, alt:false, key:69, tag:'003', stopDefault:true};
    this.cPRINT = {ctrl:true, shift:false, alt:false, key:80, tag:'004', stopDefault:true};
    this.cSEARCH = {ctrl:true, shift:false, alt:false, key:70, tag:'005', stopDefault:true};
    this.cSAVE = {ctrl:true, shift:false, alt:false, key:83, tag:'006', stopDefault:true};
    this.cHELP = {ctrl:false, shift:false, alt:false, key:g_objFKeys.cF1, tag:'007', stopDefault:true};
}
var g_objDefaultKeysMap = new clsKeysMap();

//-----------------------------------------------
var g_hshDBVS;
/**
    Pagal paduota prisijungimo eilutes taga grazina duomenu bazes tipa
    @param p_strDbString duomenu bazes prisijungimo eilutes tagas, pvz '[confCmcDbString]'
    @returns duomenu bazes tipas
*/
function g_str_fGetDbType(p_strDbString)
{
    if(g_hshDBVS == null)
        eval('var g_hshDBVS = ' + cCONNECTIONS);
    var strType = g_hshDBVS[p_strDbString.substring(1, p_strDbString.length - 1)];
    if(strType != null)
        return(strType);
    else
        return('sqlserver');
}
//-----------------------------------------------
/**
    Sql sakiniui uzdeda maksimalu rezultatu kieki.
    @param p_strRawSql pradinis SQL SELECT sakinys
    @param p_strDbType duomenu bazes tipas
    @param p_intMax maksimalus rezultatu skaicius (jei nepaduotas - naudojama cMAX_QUERY_COUNT)
    @returns suformuotas SQL sakinys su irasu maksimumu
*/
function g_str_fSqlTop(p_strRawSql, p_strDbType, p_intMax)
{
    var intMax = cMAX_QUERY_COUNT;
    if(p_intMax != null) intMax = p_intMax;
    if(p_strDbType == 'sqlserver')
        return('SELECT TOP ' + intMax + ' * FROM (' + p_strRawSql + ') AS lenta1');
    else if(p_strDbType == 'mysql')
        return('SELECT * FROM (' + p_strRawSql + ') AS lenta1 LIMIT 0, ' + intMax + '');
}
//-----------------------------------------------

/**
    Nustato elemento pozicija
*/
function g_arr_int_fPosition(p_objElement)
{
	var objElement = p_objElement;
	if (!objElement)
	    objElement = document.body;
	if (typeof(objElement) == 'string')
	{
	    objElement = document.getElementById(objElement);
	}
	var l=0; var t=0; var w=0; var h=0;
	w = objElement.offsetWidth;
    h = objElement.offsetHeight;
	if (objElement.offsetParent)
	{
		for (posX = 0, posY = 0; objElement.offsetParent; objElement = objElement.offsetParent)
		{
			l += objElement.offsetLeft - objElement.scrollLeft;
			t += objElement.offsetTop - objElement.scrollTop;
		}
	}

	return([l, t, w, h]);
}

/**
    Nustato ar pele yra viduje tam nurodyto elemento.
    @param p_objEvent vykstantis ivykis;
    @param p_objDOMObject DOM elementas, kuriam atliekamas testas;
*/
function g_bln_fIsInside(p_objEvent, p_objDOMObject)
{
    var arr_intMouseCoords = getMouse(p_objEvent);
    var arr_intRectCoords = g_arr_int_fPosition(p_objDOMObject);
    return (arr_intMouseCoords[0] >= arr_intRectCoords[0] && arr_intMouseCoords[0] <= arr_intRectCoords[0] + arr_intRectCoords[2] &&
        arr_intMouseCoords[1] >= arr_intRectCoords[1] && arr_intMouseCoords[1] <= arr_intRectCoords[1] + arr_intRectCoords[3]);
}

var intLastNr = 0;
/**
    Generuoja autoincrementini Id.
*/
function g_str_fIdGenerator()
{
    intLastNr++;
    return 'gen' + intLastNr;
}

/**
    Ismatuoja teksto ploti.
    Bugas, kai ilga eilute.
*/
function g_int_fGetTextWidth(p_strText, p_strClassName)
{
    var objElement = document.createElement('SPAN');
    objElement.innerHTML = '<nobr>' + p_strText + '</nobr>';
    objElement.style.position = 'absolute';
    if (p_strClassName)
        objElement.className = p_strClassName;
    document.body.appendChild(objElement);
    var intWidth = objElement.offsetWidth;
    document.body.removeChild(objElement);
    return intWidth;
}



/**
    Priskiria nurodytas stiliaus savybes nurodytam DOM elementui.
    @param p_objDOMElement - DOM elementas, turi tureti style objekta;
    @param p_objStyle - Dirbtinis stiliaus objektas su nurodytomis savybemis, kurias reikia perrasyti;
*/
function g_fApplyStyleProperties(p_objDOMElement, p_objStyle)
{
    if (!p_objDOMElement || !p_objDOMElement.style || !p_objStyle)
        return;
    var objElementStyle = p_objDOMElement.style;
    for (var key in p_objStyle)
    {
        objElementStyle[key] = p_objStyle[key];
    }
}

/**
    Gauna kiekvieno simbolio koda eiluteje.
    @param p_strText - eilute;
    @returns int[] - kodu masyva.
*/
function g_arr_int_fGetCharCodes(p_strText)
{
    var arr_intReturn = [];
    if (!p_strText || !p_strText.charCodeAt)
        return arr_intReturn;
    for (var i = 0, intLength = p_strText.length; i < intLength; i++)
    {
        arr_intReturn[i] = p_strText.charCodeAt(i);
    }
    return arr_intReturn;
}

/**
    Gauna visus tevus nuo vaiko iki window objekto tokiu formatu:
        [tag_name].[class_name] #[id]
*/
function g_arr_str_fGetParentChain(p_objElement)
{
    var arr_strResult = [];
    var objElement = p_objElement;
    while(objElement)
    {
        var strItem = objElement.tagName;
        if (objElement.className)
            strItem += '.' + objElement.className;
        if (objElement.id)
            strItem += ' #' + objElement.id;
        arr_strResult.push(strItem);
        var objParent = objElement.parentNode;
        if (objParent == objElement)
            break;
        objElement = objParent;
    }

    return arr_strResult;
}

if (cFF)    // FF
{
    g_fSetEnabled = function(p_objElement, p_blnEnabled)
    {
        if (p_blnEnabled)
        {
            p_objElement.style.cursor = 'pointer';
            p_objElement.style.MozOpacity = '1';
        }
        else
        {
            p_objElement.style.cursor = 'default';
            p_objElement.style.MozOpacity = '0.5';
        }
    }
}
else if (cIE)
{
    g_fSetEnabled = function(p_objElement, p_blnEnabled)
    {
        if (p_blnEnabled)
        {
            p_objElement.style.cursor = 'pointer';
            p_objElement.style.filter = '';
        }
        else
        {
            p_objElement.style.cursor = 'default';
            p_objElement.style.filter = 'alpha (opacity=50)';
        }
    }
}

if( document.implementation.hasFeature("XPath", "3.0") )
{
	XMLDocument.prototype.selectNodes = function(cXPathString, xNode)
	{
		if( !xNode ) { xNode = this; }

		var oNSResolver = this.createNSResolver(this.documentElement)
		var aItems = this.evaluate(cXPathString, xNode, oNSResolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null)
		var aResult = [];
		for( var i = 0; i < aItems.snapshotLength; i++)
		{
			aResult[i] =  aItems.snapshotItem(i);
		}

		return aResult;
	}
	XMLDocument.prototype.selectSingleNode = function(cXPathString, xNode)
	{
		if( !xNode ) { xNode = this; }

		var xItems = this.selectNodes(cXPathString, xNode);
		if( xItems.length > 0 )
		{
			return xItems[0];
		}
		else
		{
			return null;
		}
	}

	Element.prototype.selectNodes = function(cXPathString)
	{
		if(this.ownerDocument.selectNodes)
		{
			return this.ownerDocument.selectNodes(cXPathString, this);
		}
		else{throw "For XML Elements Only";}
	}

	Element.prototype.selectSingleNode = function(cXPathString)
	{
		if(this.ownerDocument.selectSingleNode)
		{
			return this.ownerDocument.selectSingleNode(cXPathString, this);
		}
		else{throw "For XML Elements Only";}
	}

}


/**
    Padaugina eilute is nurodyto skaiciaus t.y. sujungia tiek p_strString eiluciu, kiek
    nurodyta p_intCount parametru. Reikia prideti 1, nes elementai apjunginejami tik viduje.
*/
function g_str_fGetJoinedString(p_strString, p_intCount)
{
    return new Array(p_intCount + 1).join(p_strString);
}

/**
    Is into padaro stringa reikiamo ilgio.
*/
function g_str_fPadIntToRequestedLength(p_intItem, p_intRequestedLength, p_strPad)
{
    var strStringFromInt = p_intItem.toString();
    var intDiff = p_intRequestedLength - strStringFromInt.length;
    if (intDiff < 0)
    {
        return strStringFromInt.substr(-p_intRequestedLength);
    }
    else
    {
        return g_str_fGetJoinedString(p_strPad, intDiff) + strStringFromInt;
    }
}

/**
    Gauna XML nodo aprasa su vidumi.
    KM 07.06.26
*/
if (cFF)    // FF
{
    g_str_fOuterXML = function(p_objNode)
    {
        if (!p_objNode || (p_objNode.constructor != Element && p_objNode.constructor != XMLDocument && p_objNode.constructor != Text))
        {
            return '';
        }
        return (new XMLSerializer()).serializeToString(p_objNode);
    }
}
else
if (cIE)
{
    g_str_fOuterXML = function(p_objNode)
    {
        if (!p_objNode || !p_objNode.xml)
        {
            return '';
        }
        return p_objNode.xml;
    }
}

/**
    Gauna XML nodo vidu.
    KM 07.06.26
*/
function g_str_fInnerXML(p_objNode)
{
    var strResult = '';
    if (!p_objNode || !p_objNode.childNodes)
        return strResult;
    var arr_objChildren = p_objNode.childNodes;
    for (var i = 0, intLength = arr_objChildren.length; i < intLength; i++)
    {
        strResult += g_str_fOuterXML(arr_objChildren[i]);
    }
    return strResult;
}

/**
    Gauna XML nodo vidu kaip teksta.
    KM 07.07.04
*/
if (cFF)
{
    var g_str_fInnerText = function(p_objNode)
    {
        return p_objNode.textContent;
    }
}
if (cIE)
{
    var g_str_fInnerText = function(p_objNode)
    {
        return p_objNode.innerText;
    }
}

/**
    Pazymi inputo elementa nuo starto iki galo indeksu
*/
if (cIE)
{
    g_fSetSelectionRange = function(p_objInput, p_intStart, p_intEnd)
    {
        var strValue = p_objInput.value;
        var strEnding = strValue.substr(0, p_intEnd);
        var strBegining = strValue.substr(0, p_intStart).replace(/\r\n/g, '\n');
        var strEnding = strValue.substr(0, p_intEnd).replace(/\r\n/g, '\n');
        strValue = strValue.replace(/\r\n/g, '\n');
        var objRange = p_objInput.createTextRange();
        objRange.moveStart('character', strBegining.length);
        objRange.moveEnd('character', strEnding.length - strValue.length);
        objRange.select();
    }
}
if (cFF)
{
    g_fSetSelectionRange = function (p_objInput, p_intStart, p_intEnd)
    {
        p_objInput.setSelectionRange(p_intStart, p_intEnd);
    }
}

function g_bln_fIsArray(p_objObject)
{
    if (p_objObject == null)
        return false;
    if (p_objObject.constructor == Array)
        return true;
    return false;
}


var cDecimalSymbol = ',';
var cFloatPrecision = 2;
var cGroupingSymbol = '.';
/**
    Skaiciaus grupavimo budas.
    0 - negrupuoti;
    1 - grupuoti tukstanciais;
    2 - pirma grupe tukstanciais, o po to simtais.
*/
var cDigitGroupingType = 1;
var cDisplayLeadingZero = 1; // true/false
var cDisplayTrailingZero = 0; // true/false

var cDoublePrecision = 3;

var cShortDateFormat = 'yyyy.MM.dd';
var cLongDateFormat = 'yyyy \'m.\' MMMM d \'d.\'';
var cTimeFormat = 'HH:mm:ss';
var cYearAhead = 22;