var ie  = document.all;
var Gecko = document.getElementById&&!document.all;
/********************************************************************/
/* utils.js */
var g_activeEl;
var g_ID_COUNT = 0;
var g_modalChild;
var g_lastOpenedWnd = null;
var g_Window_Height = null;
var g_Window_Width = null;
var g_MAX_WAIT = 10;
var g_NB_WAIT = 0;

function getAutoId()
{
	g_ID_COUNT++;
	return "JSID_"+g_ID_COUNT;
}

function openHelpWnd(url)
{
 window.open(url,'help','resizable=yes,scrollbars=yes,menubar=no,status=no,toolbar=no,left=0,top=0,width=1000,height=600');
}

function openCenterWnd(url,name,w,h,size,scroll)
{
	var str ="width=" + w;
	str += ",height=" + h;
	str+=",left=" + (screen.width-w)/2;
	str+=",top=" + (screen.height-h)/2;
	str+=",resizable=" + ((size) ? "yes" : "no");
	str+=",scrollbars=" + ((scroll) ? "yes" : "no");
	str +=",menubar=no,status=no,toolbar=no";
	g_lastOpenedWnd = window.open(url,name,str);
	g_lastOpenedWnd.opener = window;
	g_NB_WAIT = 0;
	return centerWindow(g_lastOpenedWnd, w, h);
}

function isWindowReady(wnd)
{
	var ready = wnd.document.readyState;
	var readyState = 'complete';
	if( ready )
		readyState = ready;

	if(wnd.document != null && readyState == 'complete' && wnd.document.body != null && wnd.document.body.offsetWidth > 0)
		return true;
	else
		return false;
}

function waitForWindowCreation()
{
	if( g_NB_WAIT >= g_MAX_WAIT )		// After a too long time we stop the timer to prevent an infinite loop
	{
		g_lastOpenedWnd = null;
		return;
	}
	else
		g_NB_WAIT++;

	if( g_lastOpenedWnd == null )
		return;

	if(isWindowReady(g_lastOpenedWnd))
		centerWindow(g_lastOpenedWnd, g_Window_Width, g_Window_Height);
	else
		window.setTimeout('waitForWindowCreation()', 500);
}

function centerWindow(wnd, w, h)
{
	g_Window_Height = h;
	g_Window_Width = w;
	g_lastOpenedWnd = wnd;

	var mh = 100;           // default height
	var mw = 100;           // default width

	if( g_lastOpenedWnd == null )
		return null;

	if( isWindowReady(g_lastOpenedWnd) == false )
	{
		waitForWindowCreation();
		return wnd;
	}

	// window border size
	var scrollWidth = wnd.document.body.offsetWidth-wnd.document.body.clientWidth;
	var scrollHeight = wnd.document.body.offsetHeight-wnd.document.body.clientHeight;
	scrollWidth = scrollWidth + scrollWidth/2;

	if( scrollHeight < 38 )				// 38 = Scroolbar value under Windows XP
		scrollHeight = 38;

	if( scrollWidth < 29 )				// 29 = Scroolbar value under Windows XP
		scrollWidth = 29;

	var oContainer = jsFirstChild(wnd.document.body);
	if( oContainer != null )
	{
		mh = oContainer.offsetHeight;
		mw = oContainer.offsetWidth;
		if( ("" + parseInt(w)) == w ) 		// we got a width
		{
			if( w > mw )										// greatest than thes we computed ?
				mw = w;
		}

		if( ("" + parseInt(h)) == h )
		{
			if( h > mh )
				mh = h;
		}

	mh = parseInt(mh) + parseInt(scrollHeight);
	mw = parseInt(mw) + parseInt(scrollWidth);
	}
	else   // no container...maybe a post, we need to wait a little more
	{
		return wnd;
	}

	if( mh > screen.height )
		mh = screen.height;

	if( mw > screen.width )
		mw = screen.width;

	wnd.resizeTo(mw,mh);
	wnd.moveTo((screen.width/2)-(mw/2) ,(screen.height/2)-(mh/2));

	g_lastOpenedWnd = null;
	return wnd;
}

function heritFrom(obj)
{
	var fromObj = obj;
	var toObj = heritFrom.caller;
	toObj.prototype.Super = fromObj;
	for(var i in fromObj.prototype)
		if(!eval("toObj.prototype."+i))
				eval("toObj.prototype."+i+"=fromObj.prototype."+i);
		else
				eval("toObj.prototype.Super_"+i+"=fromObj.prototype."+i);
}

//generic component initialization
function NPComponentInit(lstFct)
{
	var elm;
	var fct;
	var param;

	for(var i = 0; i < lstFct.length; i++)	{
		elm = lstFct[i];

		if(elm && elm.length == 2) {
			fct = elm[0];
			param = elm[1];
			if(fct) fct(param);
		}
	}
}

function unicodeToEscape(str)
{
	var reg1 = new RegExp("%u([A-F0-9][A-F0-9][A-F0-9][A-F0-9])", "g");
	var reg2 = new RegExp("%([A-F0-9][A-F0-9])", "g");

	var res = escape(str);
	res = res.replace(reg1, "\\u$1");
	res = res.replace(reg2, "\\u00$1");

	return escape(res);
}

/***** Get a valid XMLDOM */
function getXMLDOM()	
{
	var moz = (typeof document.implementation != 'undefined') && (typeof document.implementation.createDocument != 'undefined');
	var ie = (typeof window.ActiveXObject != 'undefined');
	var oDom = null;

	if(moz)
		oDom = getMozillaXMLDOM();
	else
		if(ie)
			oDom = getIEXMLDOM();

	return oDom;
}

/***** Get a valid XMLDOM for IE *****/
function getIEXMLDOM()
{
	var arrDOMS = new Array("MSXML4.DOMDocument", "MSXML3.DOMDocument", "MSXML2.DOMDocument", "MSXML.DOMDocument", "Microsoft.XmlDom");
	var oDom = null;

	for(var i=0; i<arrDOMS.length; i++)
	{
		try
		{
			oDom = new ActiveXObject(arrDOMS[i]);
			return oDom;
		}
		catch(objException)
		{
			oDom = null;
		}
	}

	return oDom;
}

/***** Get a valid XMLDOM for Mozilla ******/
/***** Bugs in Mozilla 1.4 (known bug) *****/
/***** works fine with Mozilla 1.6 ********/
function getMozillaXMLDOM()
{
  var oDom = document.implementation.createDocument("", "", null);
  oDom.addEventListener("load", _Document_onload, false);
  return oDom;
}

var isMoz = document.implementation && document.implementation.createDocument;

if( isMoz )
{
	/********************************************************************/
	/*********************** DOM Error management ***********************/

	function parseError()
	{
		this.errCode = 0;
		this.errDescription = '';
	}

	parseError.prototype.__defineGetter__("reason", function() {return this.errDescription;} );
	parseError.prototype.__defineGetter__("errorCode", function() {return this.errCode;} );
	parseError.prototype.__defineGetter__("line", function() {return 0;} );
	parseError.prototype.__defineGetter__("url", function() {return '';} );

	parseError.prototype.setError = function(code, description)
	{
		this.errCode = code;
		this.errDescription = description;
	}


	Element.prototype.selectNodes = function(sExpr)
	{
			var doc = this.ownerDocument;
			if(doc.selectNodes)
				return doc.selectNodes(sExpr, this);
	}

	Element.prototype.__defineGetter__("text", function()
																						 {
																							 if( this.firstChild && this.firstChild.nodeType == 3)
																								return this.firstChild.data;
																							else
																								return '';
																						  }
																		)

	Element.prototype.transformNodeToObject = function(xslDoc, oResult)
	{
		var oDoc = document.implementation.createDocument("", "", null);
		oDoc.copyDOM(this);
		oDoc.transformNodeToObject(xslDoc, oResult);
	}

	Node.prototype.__defineGetter__("xml", function _Node_getXML()
																				{
																				 //create a new XMLSerializer
																				 var objXMLSerializer = new XMLSerializer;

																				 //get the XML string
																				 var strXML = objXMLSerializer.serializeToString(this);

																				 //return the XML string
																				 return strXML;
																				}
	)

	XMLDocument.prototype.__defineGetter__("text", function()
																									{

																										var oNode = jsFirstChild(this);
																										while(oNode.nodeValue == null)
																											oNode = jsFirstChild(oNode);

																										//alert(oNode.nodeName + ': ' + oNode.nodeType + ' -> ' + oNode.nodeValue);
																										return oNode.nodeValue;																									}
	)

	XMLDocument.prototype.__load__ = XMLDocument.prototype.load;

	XMLDocument.prototype.load = function (strURL)
	{
		this.parseError.setError(0, '');
		//change the readyState
		changeReadyState(this, 0);

		try
		{
			//call the original load method
		 return this.__load__(strURL);
		}
		catch(objException)
		{
			changeReadyState(this, 4);
			this.parseError.setError(-99999, objException.message);
			return false;
		}

	}

	XMLDocument.prototype.readyState = 0;

	XMLDocument.prototype.onreadystatechange = null;

	XMLDocument.prototype.parseError = new parseError();

	XMLDocument.prototype.selectSingleNode = function(sExpr, contextNode)
	{
		var ctx = contextNode?contextNode:null;
		sExpr += "[1]";
		var nodeList = this.selectNodes(sExpr, ctx);
		if(nodeList.length > 0)
			return nodeList[0];
		else
			return null;
	}

	XMLDocument.prototype.selectNodes = function(sExpr, contextNode)
	{
		var oResult = this.evaluate(sExpr,
													(contextNode?contextNode:this),
													this.createNSResolver(this.documentElement),
													XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
		var nodeList = new Array(oResult.snapshotLength);
		nodeList.expr = sExpr;
		for(i=0;i<nodeList.length;i++)
			nodeList[i] = oResult.snapshotItem(i);
		return nodeList;
	}

	Element.prototype.insertAdjacentElement = function(where,parsedNode)
	{
		switch (where)
		{
			case 'beforeBegin':
				this.parentNode.insertBefore(parsedNode,this)
				break;
			case 'afterBegin':
				this.insertBefore(parsedNode,this.firstChild);
				break;
			case 'beforeEnd':
				this.appendChild(parsedNode);
				break;
			case 'afterEnd':
				if (this.nextSibling)
					this.parentNode.insertBefore(parsedNode,this.nextSibling);
				else
					this.parentNode.appendChild(parsedNode);
			break;
		}
	}



	XMLDocument.prototype.loadXML = function(strXML)
	{
		//change the readystate
	  changeReadyState(this, 1);

	  //create a DOMParser
		var objDOMParser = new DOMParser();

		//create new document from string
		var objDoc = objDOMParser.parseFromString(strXML, "text/xml");

		//make sure to remove all nodes from the document
		while (this.hasChildNodes())
			this.removeChild(this.lastChild);

		//add the nodes from the new document
		for (var i=0; i < objDoc.childNodes.length; i++)
		{
			//import the node
			var objImportedNode = this.importNode(objDoc.childNodes[i], true);
			//append the child to the current document
			this.appendChild(objImportedNode);
		}

		//we can't fire the onload event, so we fake it
		handleOnLoad(this);
	}

	XMLDocument.prototype.transformNode = function(xslDoc)
	{
		var out = document.implementation.createDocument("", "", null);
		this.transformNodeToObject(xslDoc, out);

		var str = null;
		try
		{
			var serializer = new XMLSerializer();
			str = serializer.serializeToString(out);
		}
		catch(e)
		{
			this.parseError.setError(-999999, e.message);
		}

		// need to remove prefix
		var reg = new RegExp('a0:', 'gi');
		str = str.replace(reg, '');
		return str;
	}

	XMLDocument.prototype.transformNodeToObject = function(xslDoc, oResult)
	{
		var xsltProcessor = null;
		try
		{
			 xsltProcessor = new XSLTProcessor();
			 if(xsltProcessor.reset)
			 {
					  // new nsIXSLTProcessor is available
					  xsltProcessor.importStylesheet(xslDoc);
					  var newFragment = xsltProcessor.transformToFragment(this, oResult);
					  oResult.copyDOM(newFragment);
			 }
			 else
			 {
					  // only nsIXSLTProcessorObsolete is available
					  xsltProcessor.transformDocument(this, xslDoc, oResult, null);
			 }
		}
		catch(e)
		{
			if(xslDoc && oResult)
				throw "TransformNodeToObjectException: Failed to transform document. (original exception: "+e+")";
			else if(!xslDoc)
				throw "TransformNodeToObjectException: No Stylesheet Document was provided. (original exception: "+e+")";
			else if(!oResult)
				throw "TransformNodeToObjectException: No Result Document was provided. (original exception: "+e+")";
			else if(xsltProcessor == null)
					  throw "XSLTProcessorNotAvailableException: Could not instantiate an XSLTProcessor object. (original exception: "+e+")";
				 else
					  throw e;
		}
	}

	XMLDocument.prototype.copyDOM = function(oDoc)
	{
		this.clearDOM();
	  if(oDoc.nodeType == Node.DOCUMENT_NODE || oDoc.nodeType == Node.DOCUMENT_FRAGMENT_NODE)
	  {
			var oNodes = oDoc.childNodes;
			for(i=0;i<oNodes.length;i++)
				 this.appendChild(this.importNode(oNodes[i], true));
	  }
	  else if(oDoc.nodeType == Node.ELEMENT_NODE)
			this.appendChild(this.importNode(oDoc, true));
	}

	XMLDocument.prototype.clearDOM = function()
	{
		while(this.hasChildNodes())
			this.removeChild(this.firstChild);
	}

}	// if isMoz

/********************************************************************/
/*********************** Mozilla DOM functions **********************/

function changeReadyState(objDOMDocument, iReadyState)
{
  //change the readyState
  objDOMDocument.readyState = iReadyState;

  //if there is an onreadystatechange event handler, run it
  if(objDOMDocument.onreadystatechange != null && typeof objDOMDocument.onreadystatechange == "function")
		objDOMDocument.onreadystatechange();
}

function _Document_onload()
{
	handleOnLoad(this);
}

function handleOnLoad(objDOMDocument)
{
	//check for a parsing error

  if(!objDOMDocument.documentElement )
  {
		objDOMDocument.parseError.setError(-999999, 'no documentElement');
	}
	else
	{
		if( objDOMDocument.documentElement.nodeName == "parsererror" )
			objDOMDocument.parseError.setError(-999999, objDOMDocument.documentElement.firstChild.data);
	}

	//change the readyState
  changeReadyState(objDOMDocument, 4);
}

/********************************************************************/
/************************** DOM functions ***************************/

function is_all_ws( nod )		// test if the node is empty
{
  // Use ECMA-262 Edition 3 String and RegExp features
  if( nod )
	return !(/[^\t\n\r ]/.test(nod.data));
  else
	return true;
}

function is_ignorable( nod )
{
  if( nod )
	return ( nod.nodeType == 8) || ( (nod.nodeType == 3) && is_all_ws(nod) ); // a text node, all ws
  else
	return true;
}

function jsFirstChild(oNode)
{
  if( oNode == null ) return null;

  var res=oNode.firstChild;
  while (res)
  {
	 if (!is_ignorable(res)) return res;
	 res = res.nextSibling;
  }
  return null;
}

function jsLastChild(oNode)
{
  if( oNode == null ) return null;

  var res=oNode.lastChild;
  while (res)
  {
	 if (!is_ignorable(res)) return res;
	 res = res.previousSibling;
  }
  return null;
}

function jsPreviousSibling(oNode)
{
	if( oNode == null ) return null;

	while ((oNode = oNode.previousSibling))
	{
	  if (!is_ignorable(oNode)) return oNode;
	}
	return null;
}

function jsNextSibling(oNode)
{
  if( oNode == null ) return null;

  while ((oNode = oNode.nextSibling))
  {
	 if (!is_ignorable(oNode)) return oNode;
  }
  return null;
}

function jsParentNode(oNode)
{
	if( oNode == null ) return null;

	var res=oNode.parentNode;
	while (res)
	{
	  if (!is_ignorable(res)) return res;
	  res = res.parentNode;
	}
	return null;
}

function jsChildNodes(oNode)
{
var arrChilds = oNode.childNodes;
var arrResult = new Array();
var i = 0;

	for(var j=0; j<arrChilds.length; j++)
	{
		if( !is_ignorable(arrChilds[j]) )
			arrResult[i++] = arrChilds[j];
	}

	return arrResult;
}

function jsParentElement(oNode)
{
	return jsParentNode(oNode);
}

/********************************************************************/
/********************************************************************/

function LTrim(str)
{
	var whitespace = new String(" \t\n\r");
	var s = new String(str);
	if (whitespace.indexOf(s.charAt(0)) != -1) {
		var j=0, i = s.length;
		while (j < i && whitespace.indexOf(s.charAt(j)) != -1)
			j++;
		s = s.substring(j, i);
	}
	return s;
}

function RTrim(str)
{
	var whitespace = new String(" \t\n\r");
	var s = new String(str);
	if (whitespace.indexOf(s.charAt(s.length-1)) != -1) {
		var i = s.length - 1;       // Get length of string
		while (i >= 0 && whitespace.indexOf(s.charAt(i)) != -1)
			i--;
		s = s.substring(0, i+1);
	}
	return s;
}

function Trim(str)
{
	return RTrim(LTrim(str));
}

/********************************************************************/
/* array.js */
Array.prototype.size = function(){return this.length;}
Array.prototype.elementAt = function(pos){return this[pos];}
Array.prototype.lastElement = function(){return this[this.length-1]};
Array.prototype.contains = function (elm){ return this.indexOf(elm)>-1;}
Array.prototype.addElement = function(elm)
{
	this[this.size()] = elm;
	return elm;
}
Array.prototype.insertElementAt = function(elm,pos)
{
	if(pos>=this.size())
		this.addElement(elm);
	else
	{
		for(var i=this.size()-1;i>=pos;i--)
		{
			this[i+1] = this[i];
		}
		this[pos] = elm;
	}
	return elm;
}
Array.prototype.removeElementAt = function(pos)
{
	var elm = this.elementAt(pos);
	for(var i=pos;i<this.size()-1;i++)
		this[i] = this[i+1];
	this.length--;
	return elm;
}

Array.prototype.removeElement = function(elm)
{
	var idx = this.indexOf(elm);
	if (idx>-1)
		return this.removeElementAt(idx);
	return null;
}

Array.prototype.indexOf = function(elm)
{
	var res=-1;
	for(var i=0;i<this.size() && res<0;i++)
		if(elm == this[i]) res=i;
	return res;
}

Array.prototype.emptyArray = function()
{
	this.length = 0;
}

/********************************************************************/
/* XmlHttpRequester.js */
var g_xmlHttpRequester = new xmlHttpRequester();

function xmlHttpRequester()
{
	this.classname="xmlHttpRequester";
	this.elements = new Array();
	this.nextFree = false;
}

xmlHttpRequester.contentType =
{
		XML : "text/xml",
		TEXT: "text/text"
}

xmlHttpRequester.message =
{
	OK 		: "#OK",
	TIMEOUT : "#SESSION_TIMEOUT",
	ERR		: "#ERROR:"
}

xmlHttpRequester.prototype.getFreeElement = function()
{
	var res;
	for(var i=0; i<this.elements.length && !res;i++)
		res = this.elements[i].busy ? null : this.elements[i];
	return res;
}

xmlHttpRequester.prototype.getElement = function()
{
	var elm = this.getFreeElement();
	if(!elm)
	{
		elm = new xmlHttprequesterElement(this.elements.length);
		this.elements[this.elements.length] = elm;
	}
	return elm;
}

xmlHttpRequester.prototype.load = function (url,fct,elmlnk,sync)
{
	var elm  = this.getElement();
	return elm.load(url,fct,elmlnk,sync);
}

xmlHttpRequester.prototype.post = function (url,type,doc,fct,elmlnk,sync)
{
	var elm  = this.getElement();
	elm.post(url,type,doc,fct,elmlnk,sync);
}

function xmlHttprequesterElement(idx)
{
	this.classname="xmlHttprequesterElement";
	this.busy = false;
	this.idx = idx;
	this.onLoadFct = eval("fct = function(){g_xmlHttpRequester.elements["+ idx +"].getResponse();}");
}

xmlHttprequesterElement.prototype.checkResponse = function(dom)
{
	var ret = false;
	var txt = this.xmldoc.responseText;
	if(txt == xmlHttpRequester.message.TIMEOUT)
		window.location.reload(true);
	else if(txt == xmlHttpRequester.message.ERR)
		alert(txt);
	else if(this.fct)
		ret = true;

	if(ret)
		this.fct(txt,dom,this.elm);
}



xmlHttprequesterElement.prototype.load = function(url,fct,elmlnk,sync)
{
	this.url = url;
	this.fct = fct;
	this.elm = elmlnk;
	this.busy = true;
	this.initXmlDoc(sync);
	//to force the reload (IE put the XML in the cache)
	if(url.indexOf("?")<0)
		url+="?_date_="+new Date();
	else
		url+="&_date_="+new Date();
	this.xmldoc.open("GET", url , sync ? false : true);
	this.xmldoc.send(null);

	if(sync) this.getResponse();
}

xmlHttprequesterElement.prototype.post = function(url,type,doc,fct,elmlnk,sync)
{
	this.url = url;
	this.fct = fct;
	this.elm = elmlnk;
	this.busy = true;
	this.initXmlDoc(sync);
	//to force the reload (IE put the XML in the cache)
	if(url.indexOf("?")<0)
		url+="?_date_="+new Date();
	else
		url+="&_date_="+new Date();
	this.xmldoc.open("POST", url , true);
	this.xmldoc.setRequestHeader("Content-Type",type);
	try{this.xmldoc.send("<?xml version='1.0' encoding='UTF-8'?>"+doc);}catch(e){alert(e.toString());}
	if(sync) this.getResponse();
}

/********************************************************************/
/* dnd.js */
var g_DnD = new DnD();

function DnD(){this.classname="DnD";}

DnD.prototype.start = function(obj,e)
{
	if(!g_DnD.isactive)
	{
		var pos = eventPos(e);
		var cpos = eventClientPos(e);
		g_DnD.objlnk = obj;
		g_DnD.isactive = true;
		g_DnD.x = pos[0];
		g_DnD.y = pos[1];
		g_DnD.cx = cpos[0];
		g_DnD.cy = cpos[1];
		g_DnD.saveEvent();
		if(obj.dragStart) obj.dragStart(g_DnD);
	}
	return false;
}

DnD.prototype.move = function(e)
{
	if(g_DnD.isactive)
	{
		var x,y;
		var pos = eventPos(e);
		var cpos = eventClientPos(e);
		x  = pos[0];
		y  = pos[1];
		g_DnD.dx = x - g_DnD.x;
		g_DnD.dy = y - g_DnD.y;
		g_DnD.x = x;
		g_DnD.y = y;
		g_DnD.cx = cpos[0];
		g_DnD.cy = cpos[1];
		if(g_DnD.objlnk.dragMove)
			g_DnD.objlnk.dragMove(g_DnD);
	}
	 return false;
}

DnD.prototype.stop = function()
{
	if(g_DnD.isactive)
	{
		if(g_DnD.objlnk.dragEnd) g_DnD.objlnk.dragEnd(g_DnD);
		g_DnD.isactive = false;
		g_DnD.objlnk = null;
		g_DnD.restoreEvent();
	}
	return false;
}
/********************************************************************/
/* bubble.js */
var g_bubble;

function Bubble(div)
{
	if(div)
	{
		this.className="Bubble";
		this.html = div;
		div.objlnk = this;
	}

}

Bubble.prototype.editBubble = function(e,str)
{
	var x, y;
	if( e && e.target )
	{
		x = e.layerX;
		y = e.pageY;
	}
	else
	{
		x = event.clientX + document.body.scrollLeft;
		y = event.clientY + document.body.scrollTop;
	}

	writeIntoLayer(this.html,str);
	moveLayerTo(this.html,x,y+18);
	showLayer(this.html,true);
}

Bubble.prototype.hideBubble = function()
{
	showLayer(this.html,false);
}
/********************************************************************/
/* component_dnd.js */
var g_COLUMNCLASS="npcol";
var g_COMPONENTCLASS="npcomp";
var g_CONTENTCLASS="npcontent";
var g_ActiveComp;
var g_ActiveContent;
var g_UpdatePosition = false;
///////// Net.Portal DOM function ///////////////////
function getComponentParent(div)
{
	var ndiv = div;
	while(ndiv && ndiv.className!=g_COMPONENTCLASS)
		ndiv = jsParentNode(ndiv);

	return ndiv;
}

function getColumnParent(div)
{
	var ndiv = div;
	while(ndiv && ndiv.className!=g_COLUMNCLASS)
		ndiv = jsParentNode(ndiv);
	return ndiv;
}

function getChildContent(div)
{
	var divs = div.getElementsByTagName("DIV");
	var child = null;
	for(var i=0;i<divs.length && child==null;i++)
		if(divs[i].className == g_CONTENTCLASS)
			child = divs[i];
	return child;
}

function getAssociatedContent(div)
{
	return getChildContent(getComponentParent(div));
}

function getColNum(comp)
{
	var col=getColumnParent(comp);
	var divs = document.getElementsByTagName("DIV");
	var num = -1;
	var k=0;
	for(var i=0;i<divs.length && num<0;i++)
	{
		if(divs[i] == col) num = k;
		if(divs[i].className == g_COLUMNCLASS) k++;
	}
	return num;
}

function getOrder(comp)
{
	var col =getColumnParent(comp);
	var divs = col.getElementsByTagName("DIV");
	var num = -1;
	var k=0;
	for(var i=0;i<divs.length && num<0;i++)
	{
		if(divs[i] == comp) num = k;
		if(divs[i].className == g_COMPONENTCLASS) k++;
	}
	return num;
}

////////  Component Drag and Drop function //////////
function componentDnD(evt, div)
{
	if(!evt)
		evt = window.event;

	var ndiv = getComponentParent(div);
	if(ndiv)
	{
		//assign the dnd functions
		ndiv.dragStart = startComponentDnd;
		ndiv.dragMove = moveComponentDnd;
		ndiv.dragEnd = endComponentDnd;
		//launch the dnd
		g_DnD.start(ndiv,evt);
		g_UpdatePosition = true;
	}
	return false;
}

function startComponentDnd(dnd)
{
	var styl = dnd.objlnk.style;
	//define the dynamic properties
	styl.position = "absolute";
	styl.pixelWidth = 250;
	//define the new position
	styl.pixelTop = dnd.y-15;
	styl.pixelLeft = dnd.x-125;
	styl.filter = "alpha(opacity=50)";

}

function moveComponentDnd(dnd)
{
	moveLayerBy(dnd.objlnk,dnd.dx,dnd.dy);
}

function endComponentDnd(dnd)
{
	//move the component, to avoid problem if the function elementFromPoint
	//return the actual dragged element
	dnd.objlnk.style.pixelTop = dnd.y+10;
	dnd.objlnk.style.pixelLeft = dnd.x+10;

	var ndiv = document.elementFromPoint(dnd.cx,dnd.cy);
	var comp = getComponentParent(ndiv);
	if(!comp)
	{
		var col = getColumnParent(ndiv);
		if(col)
			col.appendChild(dnd.objlnk.removeNode(true));
	}
	else
	{
		var node = dnd.objlnk.removeNode(true);
		var col = getColumnParent(comp);

		//check the component not the drag element and a moveable element
		if(!comp.ISMOVEABLE)
		{
			var divs = col.getElementsByTagName("DIV");
			comp = null;
			for(var i=0;i<divs.length && !comp;i++)
				if(divs[i].ISMOVEABLE)
					comp = divs[i];
		}
		if(comp)
			col.insertBefore(node,comp);
		else
			col.appendChild(node);
	}

	dnd.objlnk.style.position = "static";
	dnd.objlnk.style.width = dnd.objlnk.parentNode.style.width;
	dnd.objlnk.style.filter = "alpha(opacity=100)";
	document.selection.empty();
}

///////////////////  Reload functions /////////////////////

function reload(elm,idcomptab,idcomp,bReloadContainer,optionalS)
{
	var div = (bReloadContainer) ? getComponentParent(elm) : getAssociatedContent(elm);
	var content = getAssociatedContent(elm);
	var fctStr = "window.NP_" + content.getAttribute('name') +"_Init";
	var fct = eval(fctStr) ? fctStr + "(" + idcomptab + ")" : null;

	//Use for components info and publication for navigation (next and previous)
	var adds = "";
	if (optionalS != null)
		adds = "&options=" + optionalS;

	var url=g_AbsPath+"flush.jsp?idtabcomp="+idcomptab + ((bReloadContainer) ? "&reloadcontainer=" : "") + adds;
	div.innerHTML = "<IMG SRC=\""+g_AbsPath +"shared/img/clock.gif\">&nbsp;loading...";
	g_HttpRequest.queuing(div,url,bReloadContainer,fct);
}

function openDynamicProfile(elm,url,name,w,h,size,scroll)
{
	g_ActiveComp = getComponentParent(elm);
	g_ActiveContent = getAssociatedContent(elm);
	openCenterWnd(url,name,w,h,size,scroll);
}

function save_display(wndsrc,wndfrm,nexttab,url,bforce)
{
	if(g_UpdatePosition || bforce)
	{
		var frm = wndfrm.document.forms['defaultpage_saving'];
		var str ="<root>\n";
		str+="<tab id=\""+frm.idtab.value+"\">\n";
		var divs = wndsrc.document.getElementsByTagName("DIV");
		var divsComp;
		var colnum=0;
		for(var i=0;i<divs.length;i++)
		{
			if(divs[i].className==g_COLUMNCLASS)
			{
				var order=0;
				var col = divs[i];
				divsComp = col.getElementsByTagName("DIV");
				for(var j=0;j<divsComp.length;j++)
				{
					if(divsComp[j].className==g_COMPONENTCLASS)
					{
						var state;
						if(divsComp[j].style.display == "none")
							state = "close";
						else
						{
							var divContent = getChildContent(divsComp[j]);
							state = (divContent.style.display=="none") ? "hidden" : "visible";
						}
						str+="<comp idtabcomp=\""+divsComp[j].getAttribute('IDTABCOMP')+"\" order=\""+order+"\" col=\""+colnum+"\" state=\""+state+"\" idcomp=\""+divsComp[j].getAttribute('IDCOMP')+"\"/>\n";
						order++;
					}
				}
				colnum++;
			}
		}

		str+="</tab>\n";
		str+="</root>";

		frm.elements['xml'].value = str;
		if(nexttab!=null) frm.elements['taborder'].value = nexttab;
		if(url!=null) frm.elements['url'].value = url;
		frm.submit();
	}
	else
	{
		window.location = g_AbsPath +"defaultpage.jsp?idtab="+nexttab;
	}
}


//////////////////// Javascript http requester //////////////////////
var g_HttpRequest = new HttpRequest;

function HttpRequest_checkState()
{
	var obj = g_HttpRequest;
	var state = obj.xmldoc.readyState;
	var ok;
	var text;

	ok = false;
	if (state == 4)
	{
		var err = obj.xmldoc.parseError;

		if(obj.inProcess.div)
		{
			if (err.errorCode != 0)
				 text = "<FONT COLOR=\"#FF0000\">" + err.reason+"</FONT>";
			else
			{
				ok = true;

				if(!obj.inProcess.outer)
					text = obj.xmldoc.text;
				else
					text = HttpRequest_innerDivCode(obj.xmldoc.text);
			}

			if(text=="#REFRESH#")
				window.location.reload(true);
			else
			{
				obj.inProcess.div.innerHTML = text;
				if(ok && obj.inProcess.onload)
					try
					{
						eval(obj.inProcess.onload);
					}
					catch(ex){}
			}
		}
		else if (err.errorCode != 0)
			alert(err.reason);
		obj.inProcess = null;
		obj.load();
	}
}
function HttpRequest_innerDivCode(cod)
{
	var text = cod;
	var end1,end2;
	text = text.substring(text.indexOf(">")+1);
	end1 = text.indexOf("</div>");
	while(end1>=0)
	{
		end2 = end1;
		end1 = text.indexOf("</div>",end2+1);
	}
	return text.substring(0,end2);
}

function HttpRequest()
{
	//this.xmldoc = new ActiveXObject("Microsoft.XMLDOM");
	this.xmldoc = getXMLDOM();
	this.xmldoc.onreadystatechange = HttpRequest_checkState;
	this.queue = new Array();
	this.inProcess = null;
}

HttpRequest.prototype.queuing = function(div,url,outer,onload)
{
	this.queue.addElement(new HttpRequestElement(div,url,outer,onload));
	this.load();
}

HttpRequest.prototype.load = function()
{
	if(this.inProcess==null && this.queue.size()>0)
	{
		this.inProcess = this.queue.elementAt(0);
		this.queue.removeElementAt(0);
		this.xmldoc.load(this.inProcess.url);
	}
}

function HttpRequestElement(div,url,outer,onload)
{
	this.div = div;
	this.url = url;
	this.outer = outer;
	this.onload = onload;
}
/********************************************************************/
/* rollover.js */
var agt = window.navigator.userAgent.toLowerCase();
var less6 = (agt.indexOf("msie") != -1 && agt.indexOf("msie 6.") == -1)? true:false;
var pointerCursor = (less6)? "hand":"pointer";
var nodropCursor = (less6)? "hand":"no-drop";

function doDisplayLayer(layerName){document.getElementById(layerName).style.display = "";}
function doNotDisplayLayer(layerName){document.getElementById(layerName).style.display = "none";}

function rollOnByClass(evt, param)
{
	var button = null;

	if(evt && evt.target)
		button = evt.target;
	else
		button = window.event.srcElement;

	if (button.className != "" && (button.name == "rollover" || button.name == "reduce" || button.name == "raise")){button.className = "on"+param;}
}

function rollOffByClass(evt, param)
{
	var button = null;

	if(evt && evt.target)
		button = evt.target;
	else
		button = window.event.srcElement;

	if (button.className != "" && (button.name == "rollover" || button.name == "reduce" || button.name == "raise")){button.className = "off"+param;}
	if (button.className != "" && button.name == "thispage"){button.className = "on"+param;}
}

function rollDownByClass(evt, param)
{
	var button = null;

	if(evt && evt.target)
		button = evt.target;
	else
		button = window.event.srcElement;

	if (button.className != "" && (button.name == "rollover" || button.name == "thispage")){button.className = "down"+param;}
}

function doMouseOver(evt)
{
	var button = null;

	if(evt && evt.target)
		button = evt.target;
	else
		button = window.event.srcElement;

	if (button.className != null && (button.className.substr(0,2) == "mo" ||button.className.substr(1,2) == "mo" ))
		button.className = button.className.substr(0,button.className.length-1) + "1";
	if (button.parentNode.className != null && button.parentNode.className.substr(0,2) == "mo")
		button.parentNode.className = button.parentNode.className.substr(0,button.parentNode.className.length-1) + "1";
}

function doMouseOut(evt)
{
	var button = null;

	if(evt && evt.target)
		button = evt.target;
	else
		button = window.event.srcElement;

	if (button.className != null && (button.className.substr(0,2) == "mo" ||button.className.substr(1,2) == "mo" ))
		button.className = button.className.substr(0,button.className.length-1) + "0";
	if (button.parentNode.className != null && button.parentNode.className.substr(0,2) == "mo")
		button.parentNode.className = button.parentNode.className.substr(0,button.parentNode.className.length-1) + "0";
}

function hideZone(evt)
{
	var button = null;

	if(evt && evt.target)
		button = evt.target;
	else
		button = window.event.srcElement;

	if (button.className != null && button.className.substr(0,2) == "up")
	{
		if(button.className.substr(button.className.length-1) == "0")
			{
				button.className = button.className.substr(0,button.className.length-1) + "1";
				document.getElementById('headline').style.display='none';
			}
		else
			{
				button.className = button.className.substr(0,button.className.length-1) + "0";
				document.getElementById('headline').style.display='block';
			}
		}
}

function rollOnByImg(evt, path)
{
	var button = null;

	if(evt && evt.target)
		button = evt.target;
	else
		button = window.event.srcElement;

	if (button.className=='button')
		button.src = button.src.substring(0,button.src.length-5)+"1.gif";
}

function rollOffByImg(evt, path)
{
	var button = null;

	if(evt && evt.target)
		button = evt.target;
	else
		button = window.event.srcElement;

	if (button.className=='button')
		button.src = button.src.substring(0,button.src.length-5)+"0.gif";
}

function chgStatus(evt, path,layerName)
{
	var button = null;

	if(evt && evt.target)
		button = evt.target;
	else
		button = window.event.srcElement;

	switch (button.name)
	{
		case "reduce" :
		button.src = path+"enlarge0.gif";
		button.name = "enlarge";
		doNotDisplayLayer(layerName);
		break;

		case "enlarge" :
		button.src = path+"reduce0.gif";
		button.name = "reduce";
		doDisplayLayer(layerName);
		break;
	}
}

function hrefIt(evt)
{
	var srcIt = null;

	if(evt && evt.target)
		srcIt = evt.target;
	else
		srcIt = window.event.srcElement;

	if (srcIt.className)
		var srcCn = srcIt.className;
	if(srcCn != null && srcCn.length >0)
	{
		switch(srcCn.substr(1,srcCn.length))
		{
			case "href0":
				srcIt.className = srcCn.substr(0,srcCn.length-1)+"1";
				break;
			case "href1":
				srcIt.className = srcCn.substr(0,srcCn.length-1)+"0";
				break;
		}
	}
}

function doButtonMouseover(evt, param)
{
	var button = null;

	if(evt && evt.target)
		button = evt.target;
	else
		button = window.event.srcElement;

	if (button.parentNode.className)
		var parentCn = button.parentNode.className;
	if(button.name && button.name == "toolbarBtn"){
		if (parentCn && button.className.substring(button.className.length-1)!= '0'){
			button.style.cursor = pointerCursor;
			button.parentNode.className = parentCn.substr(0,parentCn.length-1)+param;
		}
		else
			button.style.cursor="default";
	}
}
/********************************************************************/
/* ie/utilie.js */
var g_ref=window;

function focusLayer(div)
{
	if (g_activeEl != div && g_activeEl != null)
		div.style.zIndex = g_activeEl.style.zIndex  + 1;
	g_activeEl = div;
}
function eventPos()
{
	return [event.clientX + document.body.scrollLeft,
			event.clientY + document.body.scrollTop];
}
function eventClientPos()
{
	return [event.clientX,event.clientY];
}

function eventButton(){return event.button;}
function innerWidth(elm){return elm.clientWidth;}
function innerHeight(elm){return elm.clientHeight;}
function moveLayerBy(div,dx,dy){
	div.style.pixelLeft+=dx;
	div.style.pixelTop+=dy;
}
function moveLayerTo(div,x,y)
{
	div.style.pixelLeft=x;
	div.style.pixelTop=y;
}
function sizeLayerBy(div,dw,dh)
{
	div.style.pixelHeight+=dh;
	div.style.pixelWidth+=dw;
}
function sizeLayerTo(div,w,h)
{
	div.style.pixelHeight=h;
	div.style.pixelWidth=w;
}
function showLayer(div,show){div.style.visibility = (show) ? "visible" : "hidden";}
function displayLayer(div,show){div.style.display = (show) ? "block" : "none";}
function createLayer(html,id)
{
	window.document.body.insertAdjacentHTML("BeforeEnd",html);
	return eval("window."+id);
}
function getChildLayerByIdx(div,idChild)
{
	var divs = div.all.tags("DIV");
	return divs[idChild];
}

function setLayerColor(div,bg,fg)
{
	if(bg!=null)
		div.style.backgroundColor = bg;
	if(fg!=null)
		div.style.color = fg;
}
function setLayerClassName(div,className){div.className = className;}
function getLayerTop(div){return div.style.pixelTop;}
function getLayerLeft(div){return div.style.pixelLeft;}
function getLayerWidth(div){return div.style.pixelWidth;}
function getLayerHeight(div){return div.style.pixelHeight;}
function setLayerClip(div,top,right,bottom,left){div.style.clip = "rect("+top+" "+right+" "+bottom+" "+left+")";}
function writeIntoLayer(div,str){div.innerHTML = str;}
function inLayer(div,x,y){return (div.componentFromPoint(x,y)=="");}

/********************************************************************/
/* ie/XmlHttpRequester.js */
function getControlPrefix()
{
	if (getControlPrefix.prefix)
		return getControlPrefix.prefix;

	var prefixes = ["MSXML3","MSXML2", "Microsoft", "MSXML"];
	var o, o2;
	for (var i = 0; i < prefixes.length && !getControlPrefix.prefix; i++)
	{
		try
		{
			// try to create the objects
			o = new ActiveXObject(prefixes[i] + ".XMLHTTP");
			o2 = new ActiveXObject(prefixes[i] + ".XMLDOM");
			return getControlPrefix.prefix = prefixes[i];
		}
		catch (ex) {};
	}
	throw new Error("Could not find an installed XML parser");
}

xmlHttprequesterElement.prototype.initXmlDoc = function()
{
	this.xmldoc = new ActiveXObject(getControlPrefix() + ".XMLHTTP");
	this.xmldoc.onreadystatechange = this.onLoadFct;
}

xmlHttprequesterElement.prototype.getResponse = function()
{
	if(this.xmldoc.readyState == 4 && this.busy)
	{
		this.busy=false;
		var txt = this.xmldoc.responseText;
		var dom = this.xmldoc.responseXML;
		var docElm = dom.documentElement;

		if(txt.length>0 && (dom == null || docElm == null))
		{
			var dom = new ActiveXObject(getControlPrefix() + ".XMLDOM");
			var idx = txt.indexOf("?>");
			if(idx>0) txt = txt.substring(idx+2);
			dom.loadXML(txt);
		}
		this.checkResponse(dom);
	}
}
/********************************************************************/
/* ie/dndie.js */
DnD.prototype.saveEvent = function()
{
	this.saveMove = document.onmousemove;
	this.saveUp = document.onmouseup;
	document.onmousemove=this.move;
	document.onmouseup=this.stop;
}

DnD.prototype.restoreEvent = function()
{
	document.onmousemove=this.saveMove;
	document.onmouseup=this.saveUp;
}
/********************************************************************/
/* ie/tools.js*/
/************************************ NPTool **********************************************/
NPTool = {toString : new function(){return "NetPortal Javascript Tool";}}

//NPTool constants
NPTool.eventType =
{
	Click		: "click",
	DblClick	: "dblclick",
	MouseOut	: "mouseout",
	MouseOver	: "mouveover",
	MouseDown	: "mousedown",
	MouseUp		: "mouseup",
	MouseMove	: "mousemove",
	Scroll		: "scroll"
}

NPTool.coor =
{
	X		: 0,
	Y 		: 1,
	Width	: 0,
	Height	: 1

}
/******************************* Scroll method ***************************************/
NPTool.getScrollTop			= function(){return document.body.scrollTop;}
NPTool.getScrollLeft		= function(){return document.body.scrollLeft;}

/******************************* Coordinate method ***************************************/
NPTool.sizeTo				= function(elm,w,h){if(h) elm.style.pixelHeight =h;if(w) elm.style.pixelWidth =w;}
NPTool.sizeBy				= function(elm,w,h){elm.style.pixelHeight+=h;elm.style.pixelWidth+=w;}
NPTool.getCoor				= function(elm){return [elm.style.pixelLeft,elm.style.pixelTop]}
NPTool.getSize				= function(elm){return [elm.style.pixelWidth,elm.style.pixelHeight]}
NPTool.getOffsetCoor		= function(elm){
	var parent = elm;
	var l = 0;
	var t = 0;

	while(parent)
	{
		if(parent.tagName == "TR") {parent = parent.parentElement;}
		if(parent.offsetLeft) l += parent.offsetLeft;
		if(parent.offsetTop) t += parent.offsetTop;
		parent = parent.parentElement;
	}
	return [l,t];
}

NPTool.getBorderWidth = function(elm){
	var parent = elm;
	var bw = 0;
	var bh = 0;

	while(parent)
	{

		if(parent.borderRightWidth) bw += parent.borderRightWidth;
		if(parent.borderLeftWidth) bw += parent.borderLeftWidth;
		if(parent.borderTopWidth) bh += parent.borderTopWidth;
		if(parent.borderBottomWidth) bh += parent.borderBottomWidth;
		var parent = (parent.tagName == "table")? false : parent = parent.parentElement;
	}
	return [bw,bh];
}

/******************************* Event methods ******************************************/
NPTool.getEvent				= function(e) {return event};

//coordinate
NPTool.getEventPos			= function (e){return [event.clientX + document.body.scrollLeft,event.clientY + document.body.scrollTop];}
NPTool.getEventClientPos 	= function (e){return [event.clientX,event.clientY];}
//event attachement
NPTool.attachEvent			= function(elm,eventType,fct){eval("elm.on" + eventType +"=fct");}
NPTool.releaseEvent			= function(elm,eventType,fct){eval("elm.on" + eventType +"=null");}

/***************************** Content method *********************************************/
NPTool.insertAdjacentHTML	= function(elm,str){elm.insertAdjacentHTML("BeforeEnd", str);}