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



						 Funciones Java para el manejo de objetos
								(C) Alberto Blanco 2008


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

/***************************************************************************************************************************
 Busca todos los tag del tipo que se le pasa en la pagina y los hace invisibles.
 Contenedor puede llevar la referencia de un objeto, en cuyo caso no oculta los que pertenezcan al contenedor o sus hijos,
  o null, que ocultará todos
 Esta función se debe a la imposibilidad de usar el zindex con el select o con el object
 Se guarda el estado en el que estuvieran para poder restaurarlos
***************************************************************************************************************************/
//Matriz donde voy guardando las referencias a los select y su estado antes de ocultarlos, en cada llamada
//Cada llamada a la funcion crea un array de select, dentro de un elemento de este array
var OBJSELECTEstado=new Array(); 

//Oculta los select
function OBJSELECTOculta(Contenedor,Tag)
{
var Select;
var flag;
var idx=0;
var idxP=OBJSELECTEstado.length;
	
	//Me busco el primer hueco en la pila
	//El bucle lo hago por que delete no elimina el elemento de la matriz, lo deja undefined. 
	//Asi la matriz funciona como una pila
	while (idxP>0 && typeof OBJSELECTEstado[idxP-1]=='undefined') idxP--;
	OBJSELECTEstado[idxP]=new Array();	//Me creo un nuevo array dentro de la matriz de select

	Select=document.getElementsByTagName(Tag); //Busco los select de la pagina
	for (var i=0; i<Select.length; i++)
		{
		if (Contenedor == null)
			flag=true; // No hay contenedor, oculto todos
		else
			flag=!OBJHijoDe(Select[i],Contenedor); //Como hay contenedor, miro si el select pertenece, para no ocultarlo
	
		if (flag)
			{
			//Meto el objeto y su estado del visibility en el array
			OBJSELECTEstado[idxP][idx]=Select[i];
			OBJSELECTEstado[idxP][idx+1]=Select[i].style.visibility;
			idx+=2;
			
			//Y lo oculto
			Select[i].style.visibility='hidden';
			};
		};
};

//Repone los tag que oculto la funcion anterior.
function OBJSELECTMuestra()
{
var idxP=OBJSELECTEstado.length-1;

	while (idxP>0 && typeof OBJSELECTEstado[idxP]=='undefined') idxP--; //Busco la ultima entrada en la matriz
	
	//Repongo el estado
	for (var i=0; i<OBJSELECTEstado[idxP].length; i+=2)
		OBJSELECTEstado[idxP][i].style.visibility=OBJSELECTEstado[idxP][i+1];
	
	//elimino la entrada. (No la elimina, deja el elemento "undefined")
	delete OBJSELECTEstado[idxP];
};


/***********************************************************
 Se le pasan las referencias a dos objeto y devuelve true
  si obj1 pertenece a obj2 o a alguno de sus hijos
 Si no, devuelve false
***********************************************************/ 
function OBJHijoDe(obj1,obj2)
{
	var hijo=obj1;
	while (hijo.offsetParent.tagName!='BODY')
		{
		if (hijo.offsetParent==obj2) return true;	//Pertenece, devuelvo true
		hijo=hijo.offsetParent; //Busco el siguiente pa arriba
		};
	return false;
}


/****************************************************************************
 Calcula el top real de un elemento dentro del documento
 Para ello se hace recursiva subiendo por la piramide del documento
 *****************************************************************************/
function OBJTop(objeto)
{
var Pos=0;

	Pos=objeto.offsetTop;
	if (objeto.tagName!='BODY' && objeto.offsetParent!=null)
		Pos+=OBJTop(objeto.offsetParent);
	return Pos;
};

/****************************************************************************
 Calcula el left real de un elemento dentro del documento
 Para ello se hace recursiva subiendo por la piramide del documento
 *****************************************************************************/
function OBJLeft(objeto)
{
var Pos=0;

	Pos=objeto.offsetLeft;
	if (objeto.tagName!='BODY' && objeto.offsetParent!=null)
		Pos+=OBJLeft(objeto.offsetParent);
	return Pos;
};

/*****************************************************************************
 Busca por todas las hojas de estilo hasta que encuentra el rule que se le pasa
 y devuelve el ForeColor del mismo. Si no lo encuentra, devuelve null
 Se usa, entre otras cosas para hacer algo asi:
  .. onclick="this.color=OBJSTYLEForeColor('MIESTILO');"
 y globalizar todos los colores en las hojas de estilo
*****************************************************************************/
function OBJSTYLEForeColor(Rule)
{
var r=OBJSTYLEBuscaRule('.' + Rule);
	
	if (r!=null)
		return r.style.color;
	else
		return null;
};

/*****************************************************************************
 Busca por todas las hojas de estilo hasta que encuentra el rule que se le pasa
 y devuelve el BackColor del mismo. Si no lo encuentra, devuelve null
 Se usa, entre otras cosas para hacer algo asi:
  .. onclick="this.backgroundColor=OBJSTYLEBackColor('MIESTILO');"
 y globalizar todos los colores en las hojas de estilo
*****************************************************************************/
function OBJSTYLEBackColor(Rule)
{
var r=OBJSTYLEBuscaRule('.' + Rule);
	
	if (r!=null)
		return r.style.backgroundColor;
	else
		return null;
};

/*********************************************************************************
Busca por todas las hojas de estilo un objeto rule, y si lo encuentra lo devuelve
si no lo encuentra devuelve null
*********************************************************************************/
function OBJSTYLEBuscaRule(Rule)
{
var a,b;

	//Diferencias de navegador
	//var oneRule = document.styleSheets[0].rules[0]; // IE4+, MacIE5, Safari
	//var oneRule = document.styleSheets[0].cssRules[0]; // NN6+/Moz, MacIE5, Safari
	if (OBJQueNavegador()=='IE')
		{
		//Codigo para explorer
		for (a=0;a<document.styleSheets.length;a++)
			for (b=0;b<document.styleSheets[a].rules.length;b++)
				if (document.styleSheets[a].rules[b].selectorText==Rule)
					return document.styleSheets[a].rules[b];
		}
	else
		{
		//Codigo para Firefox
		for (a=0;a<document.styleSheets.length;a++)
			for (b=0;b<document.styleSheets[a].cssRules.length;b++)
				if (document.styleSheets[a].cssRules[b].selectorText==Rule)
					return document.styleSheets[a].cssRules[b];
		}
	return null;
};



/********************************************************************************************************
Devuelve el zIndex mayor de todos los elementos que cuelgan de objref
Se la llama: OBJzindexMax(RefElemento); o OBJzindexMax('IDElemento');
Si no se le pasa la referencia devolvera el zindex mayor de todos los elementos del body OBJzindexMax();
*********************************************************************************************************/
function OBJzindexMax(objRef)
{
var obj;
var i, group;
var zmax=0,z1;

	if (objRef)
		{
		if (typeof objRef == 'string')
			{
			obj = document.getElementById(objRef);
			}
		else
			{
			obj = objRef;
			};
		}
	else 
		{
		obj = (document.body.parentElement) ? document.body.parentElement : document.body.parentNode;
		};

	group = obj.childNodes;
	for (i = 0; i < group.length; i++) 
		{
		if (group[i].nodeType==1)
			{
			if (group[i].style.zIndex)
				{
				z1=Math.floor(group[i].style.zIndex);
				if (z1>zmax) zmax=z1;
				};
			};
			
		if (group[i].childNodes.length > 0)
			{
			z1=OBJzindexMax(group[i]);
			if (z1>zmax) zmax=z1;
			};
		};
		
	return zmax;
};


/**************************************************
 Devuelve el ancho real en pixels de un objeto.
***************************************************/
function OBJancho(objRef)
{
var obj;
	
	if (objRef)
		{
		if (typeof objRef == 'string')
			{
			obj = document.getElementById(objRef);
			}
		else
			{
			obj = objRef;
			};
		}
	else 
		{
		obj = (document.body.parentElement) ? document.body.parentElement : document.body.parentNode;
		};

	var Max=OBJanchoMAX(obj);
	var Min=OBJanchoMIN(obj);
	if (Max<Min) 
		return -1;	//No habia objetos
	else
		return Max-Min + 1;
};

/*********************************************************************************************
Devuelve la posicion mas a la derecha del objeto que se le pasa o de sus hijos 
sin tener en cuenta los objetos flotantes
 Si no se le pasa objeto devuelve la posicion mas a la derecha rendeada dentro del documento
 Ej. La pantalla del navegador alberga 1000 px. de ancho, pero la página tiene sólo una tabla
 de 800 pixels de ancho centrada... la ultima posicion estará en el pixel 900.
**********************************************************************************************/
function OBJanchoMAX(objRef)
{
var obj;
var i, group;
var zmax=0,z1;

	if (objRef)
		{
		if (typeof objRef == 'string')
			{
			obj = document.getElementById(objRef);
			}
		else
			{
			obj = objRef;
			};
		}
	else 
		{
		obj = (document.body.parentElement) ? document.body.parentElement : document.body.parentNode;
		};

	//Primero miramos en el objeto en si
	if (obj.nodeType==1)
		{
		if (obj.offsetLeft && OBJIsVisible(obj))
			{
			z1=OBJLeft(obj) + obj.offsetWidth -1;
			if (z1>zmax) zmax=z1;
			};
		};
			
	//Y ahora todos sus hijos, si no esta visible
	if (OBJIsVisible(obj))
		{
		group = obj.childNodes;
		for (i = 0; i < group.length; i++) 
			{
			if (group[i].nodeType==1)
				{
				if (group[i].offsetLeft && OBJIsVisible(group[i]))
					{
					z1=OBJLeft(group[i]) + group[i].offsetWidth -1;
					if (z1>zmax) zmax=z1;
					};
				};
				
			if (group[i].childNodes.length > 0)
				{
				z1=OBJanchoMAX(group[i]);
				if (z1>zmax) zmax=z1;
				};
			};
		};
	return zmax;
};

//Igual que la anterior, pero con el minimo
function OBJanchoMIN(objRef)
{
var obj;
var i, group;
var zmin=99999,z1;

	if (objRef)
		{
		if (typeof objRef == 'string')
			{
			obj = document.getElementById(objRef);
			}
		else
			{
			obj = objRef;
			};
		}
	else 
		{
		obj = (document.body.parentElement) ? document.body.parentElement : document.body.parentNode;
		};

	//Primero miramos en el objeto en si
	if (obj.nodeType==1)
		{
		if (obj.offsetLeft && OBJIsVisible(obj))
			{
			z1=OBJLeft(obj);
			if (z1<zmin) zmin=z1;
			};
		};

	//Y ahora todos sus hijos si esta visible
	if (OBJIsVisible(obj))
		{
		group = obj.childNodes;
		for (i = 0; i < group.length; i++) 
			{
			if (group[i].nodeType==1)
				{
				if (group[i].offsetLeft && OBJIsVisible(group[i]))
					{
					z1=OBJLeft(group[i]);
					if (z1<zmin) zmin=z1;
					};
				};
				
			if (group[i].childNodes.length > 0)
				{
				z1=OBJanchoMIN(group[i]);
				if (z1<zmin) zmin=z1;
				};
			};
		};
	return zmin;
};



/***************************************************************************************
 Devuelve el alto real en pixels de un objeto.
****************************************************************************************/
function OBJalto(objRef)
{
var obj;
	
	if (objRef)
		{
		if (typeof objRef == 'string')
			{
			obj = document.getElementById(objRef);
			}
		else
			{
			obj = objRef;
			};
		}
	else 
		{
		obj = (document.body.parentElement) ? document.body.parentElement : document.body.parentNode;
		};

	var Max=OBJaltoMAX(obj);
	var Min=OBJaltoMIN(obj);
	if (Max<Min) 
		return -1;	//No habia objetos
	else
		return Max-Min + 1;
};

/*********************************************************************************************
Devuelve la posicion mas abajo del objeto que se le pasa o de sus hijos
sin tener en cuenta los objetos flotantes
 Si no se le pasa objeto devuelve la posicion mas abajo rendeada dentro del documento
 Ej. La pantalla del navegador alberga 800 px. de alto, pero la página tiene sólo una tabla
 de 400 pixels de alto centrada en al body... la posicion más  abajo estará en el pixel 600.
**********************************************************************************************/
function OBJaltoMAX(objRef)
{
var obj;
var i, group;
var zmax=0,z1;

	if (objRef)
		{
		if (typeof objRef == 'string')
			{
			obj = document.getElementById(objRef);
			}
		else
			{
			obj = objRef;
			};
		}
	else 
		{
		obj = (document.body.parentElement) ? document.body.parentElement : document.body.parentNode;
		};

	//Primero miramos en el objeto en si
	if (obj.nodeType==1)
		{
		if (obj.offsetTop && OBJIsVisible(obj))
			{
			z1=OBJTop(obj) + obj.offsetHeight -1;
			if (z1>zmax) zmax=z1;
			};
		};

	//Y ahora todos sus hijos si esta visible
	if (OBJIsVisible(obj))
		{
		group = obj.childNodes;
		for (i = 0; i < group.length; i++) 
			{
			if (group[i].nodeType==1)
				{
				if (group[i].offsetTop && OBJIsVisible(group[i]))
					{
					z1=OBJTop(group[i]) + group[i].offsetHeight -1;
					if (z1>zmax) zmax=z1;
					};
				};
				
			if (group[i].childNodes.length > 0)
				{
				z1=OBJaltoMAX(group[i]);
				if (z1>zmax) zmax=z1;
				};
			};
		};
	return zmax;
};

//Igual que la anterior, pero con el minimo
function OBJaltoMIN(objRef)
{
var obj;
var i, group;
var zmin=99999,z1;

	if (objRef)
		{
		if (typeof objRef == 'string')
			{
			obj = document.getElementById(objRef);
			}
		else
			{
			obj = objRef;
			};
		}
	else 
		{
		obj = (document.body.parentElement) ? document.body.parentElement : document.body.parentNode;
		};

	//Primero miramos en el objeto en si
	if (obj.nodeType==1)
		{
		if (obj.offsetTop && OBJIsVisible(obj))
			{
			z1=OBJTop(obj);
			if (z1<zmin) zmin=z1;
			};
		};

	//Y ahora todos sus hijos si esta visible
	if (OBJIsVisible(obj))
		{
		group = obj.childNodes;
		for (i = 0; i < group.length; i++) 
			{
			if (group[i].nodeType==1)
				{
				if (group[i].offsetTop && OBJIsVisible(group[i]))
					{
					z1=OBJTop(group[i]);
					if (z1<zmin) zmin=z1;
					};
				};
				
			if (group[i].childNodes.length > 0)
				{
				z1=OBJaltoMIN(group[i]);
				if (z1<zmin) zmin=z1;
				};
			};
		};
	return zmin;
};

/*************************************************************************************
		 Comprueba en un objeto que style.visibility!='hidden'
*************************************************************************************/
function OBJIsVisible(obj)
{
	return (obj.style && obj.style.visibility!='hidden') ? true : false;
};



/****************************************************************************************
 Comprueba si las coordenadas x,y que se le pasan estan dentro del objeto que se le pasa
*****************************************************************************************/
function OBJCoorInObject(y,x,obj)
{
	var Top=OBJTop(obj);
	var Left=OBJLeft(obj);
	var Rigth=Left + obj.offsetWidth-1;
	var Bottom=Top + obj.offsetHeight-1;
	if (x>=Left && x<=Rigth && y>=Top && y<=Bottom)
		return true;
	else
		return false;
};



/**************************************************
	 Hace una pausa de mls milisegundos
  OJO. Es una pausa sin eventos. Se para todo
***************************************************/
function OBJTIMEPause(mls)
{
var t1,t2;

	t1=new Date();
	t2=t1.getTime()+mls;
	while (t2 > t1.getTime())			
		t1=new Date();
};

/*************************************************
 Devuelve el tipo de navegador que se esta usando
***************************************************/
function OBJQueNavegador()
{
	if (navigator.appName=='Microsoft Internet Explorer') return 'IE';
	
	if (navigator.appName=='Netscape')
		{
		//Preguntamos el google Chrome
		var t=''+navigator.appVersion;	
		if (t.match('Chrome')!=null) return 'GC';
		
		//Netscape
		return 'NT';
		}

	return '';
};


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

 	Carga el html que cuelga del body de una página en el innerHTML del objeto que se le pasa

****************************************************************************************************/
var OBJCargaCodigoFrame=null;
var OBJCargaCodigoObj;

function OBJCargaCodigo(pagina, Obj)
{
	if (pagina=='' || OBJCargaCodigoFrame!=null) return; //Si no me da pagina que coño quieren, o si esta cargandose aun otro

	OBJCargaCodigoObj=Obj; //Me guardo el objeto 

	OBJCargaCodigoFrame=document.createElement('IFRAME'); //Me creo el IFRAME oculto
	OBJCargaCodigoFrame.style.position='absolute';		// Fuerzo al iframe a permanecer oculto y que no estorbe :)
	OBJCargaCodigoFrame.style.visibility='hidden';
	document.body.appendChild(OBJCargaCodigoFrame);

	EVTAsignaEvento(OBJCargaCodigoFrame, 'load', OBJCargaCodigoEND);	//Le asigno el evento para cuando termine de cargar
	OBJCargaCodigoFrame.src=pagina; //Cargo la página
};

//Cuando termina de cargar el iframe, le pasamos el contenido al objeto
function OBJCargaCodigoEND()
{
	try
		{
		//El IFRAME ya tiene la pagina cargada. Cargamos el html en el objeto
		OBJCargaCodigoObj.innerHTML+=OBJCargaCodigoFrame.contentWindow.document.body.innerHTML;
		}
	catch(e)
		{
		//Me deniega el acceso (supongo que se podrá configurar) cuando la pagina es de otro dominio
		};

	//Terminamos la carga
	delete OBJCargaCodigoFrame;
	OBJCargaCodigoFrame=null;
};


/********************************************************************************************************************
 Devuelve el querystring como una matriz
 La matriz contendrá objetos OBJQuery, y si los nombres de las variables del query estan repetidos, una matriz.
 Ejemplos:
 ?Dato1=pepe&Dato2=juan
 mat[0].name='Dato1' y mat[0].value='pepe'
 mat[1].value='Dato2' y mat[1].value='juan'
 mat['Dato1'].value='pepe'
 mat['Dato2'].value='juan' 
	
 ?Dato=pepe&Dato=juan
 mat[0][0].name='Dato' y  mat[0][0].value='pepe'
 mat[0][1].name='Dato' y  mat[0][1].value='juan'
 mat['Dato'][0].value='pepe'
 mat['Dato'][1].value='juan'
 
 Para saber si un elemento es una matriz:
 if ( typeof(mat['Dato'].value)=='undefined' ) // es una matriz de elementos   mat['Dato'][0],  mat['Dato'][1] ...
********************************************************************************************************************/
function OBJQueryStringToArray()
{
var input = location.search.substr(1);

	return OBJQueryStringStrToArray(input);
};


/********************************************************
 Devuelve el querystring que se le pasa como una matriz
 La cadena que se le pasa debe ser del tipo:
 variable=valor&variable=valor ...
*********************************************************/
function OBJQueryStringStrToArray(input)
{
var results = new Array();
var i,j,a;
var nombre,valor;

	if (input)
		{
		var srchArray = input.split('&');
		var tempArray = new Array();
		for (var i = 0; i < srchArray.length; i++) 
			{
			//varible - valor
			tempArray = srchArray[i].split('='); 
			nombre=tempArray[0];
			valor=unescape(tempArray[1]);
			
			//Referenciamos por indice numerico
			i=results.length;
			results[i]=new OBJQuery(nombre,valor);
						
			//Y ahora referenciamos por el nombre de la variable directamente
			//Pero tenemos que saber si el nombre de esta variable esta repetido, para
			//crearnos una matriz de referencias de la misma
			for (j=0,a=0;j<srchArray.length;j++)
				if (srchArray[j].indexOf(nombre + '=')!=-1) a++;
			
			if (a>1)
				{
				//Hay varias variables con el mismo nombre, me monto una matriz para ese nombre
				if (typeof(results[nombre])=='undefined') results[nombre]=new Array();
				a=results[nombre].length;
				results[nombre][a]=results[i];
				}
			else
				{
				//El nombre de esta variable es único, referenciamos su indice numerico
				results[nombre] = results[i];
				};
			};
		};
	return results;
};


//Clase para la matriz que devuelve OBJQueryStringToArray()
function OBJQuery(name,value)
{
	this.name=name;
	this.value=value;
};


/*************************************************************
  Devuelve la posición del cursor dentro del cuadro de texto
  tb es una referencia a un objeto input
*************************************************************/
function OBJposicionCursor(tb)
{
var cursor = -1;
	
	if (document.selection && (document.selection != 'undefined'))
		{
		var _range = document.selection.createRange();
		var contador = 0;
		while (_range.move('character', -1)) contador++;
		cursor=contador;
		}
	else
		{
		if (tb.selectionStart >= 0) cursor=tb.selectionStart;
		};
	
	return cursor;
};