_sv_enter_init(); function _sv_enter_init() { var x; _sv._sventer = {}; x = _sv._sventer; x.trans = {}; //# Almacena trancisiones de visible a invisible y al revés de cada ID x.estados = {}; //# Almacena el estado visible/invisible (1/0) de cada ID. x.depends = {}; //# x.id_actual = false; //# _sv.init_sv_enter = init_sv_enter; _sv.load_function(_l_load,20); /* *** ** sv_type = 'enter' ** sv_conf = value: string . ID del elemento. Varios elementos pueden tener un mismo ID ** modo que las acciones enter/leave realizadas sobre uno cualquiera ** de ellos se considera que actuan sobre todos. ** sv_conf = master_value: string . ID del elemento maestro. Las acciones enter/leave ** sobre los objetos esclavos, repercutirán también en los maestros. ** master: Si es verdadero, se trata del objeto maestro (no se oculta ** ni se deja de apuntar). ** y: Si se define, será la posición en la y referida a la del objeto maestro. ** x: Si se define, será la posición en la x referida a la del objeto maestro. ** */ //# Se mantiene _sv._enter, que es un array asociativo donde cada clave es un ID de objeto //# sventer, y cada item es un array numérico con las siguientes propiedades: //# //# _sv._enter[id].master => Referencia al objeto maestro. //# _sv._enter[id][0] => Referencia a un objeto esclavo. //# _sv._enter[id][1] => Referencia a otro objeto esclavo. //# ... //# _sv._enter[id][N] => Referencia al objeto esclavo N. //# //# //# //# //# Cuando el cursor entra en un objeto sventer, la librería se encarga de que todos los //# objetos esclavos del mismo ID, sean mostrados, así como aquellos que contengan //# function init_sv_enter(o) { var c,d,v,s,m,mv; c = o.getAttribute("sv_conf"); if(_sv.is_emp(c)) { c=''; } o._sv_conf = new Object(); d = o._sv_conf; _sv.parse_atts(c,d); if(d.value) { //# Si tiene atributo value. v = d.value; //# | Se toma en v. } else { //# Si no lo tiene. v = "qwerty"; //# | v = value por defecto. d.value = v; //# | Se guarda éste en o._sv_conf. } //# if(d.master_value) { //# Si tiene atributo master_value. mv = d.master_value; //# | Se toma en mv. } else { //# Si no lo tiene. mv = 0; //# | mv = master_value por defecto. d.master_value = mv; //# | Se guarda éste en o._sv_conf. } //# if(d.master) { //# Si tiene atributo master. m = d.master; //# | Se toma en m. } else { //# Si no lo tiene. m = 0; //# | m = master por defecto. d.master = m; //# | Se guarda éste en o._sv_conf. } //# //#------------------------------------ //# Ahora se deja en _sv._enter[v] un array de objetos esclavos con el mismo //# ID, con una propiedad master que se refiere al objeto maestro, y otra //# propiedad master_value que se refiere al objeto maestro. //#------------------------------------ if(!_sv._enter) { _sv._enter = {}; } if(!_sv._enter[v]) { _sv._enter[v] = []; } s = _sv._enter[v]; if(m) { s.master = o; } else { s[s.length] = o; } if(mv!=0) { s.master_value = mv; } _sv.add_event_handler(o, 'm_enter', hme); _sv.add_event_handler(o, 'm_leave', hml); } /** * Función manejadora del evento m_enter (mouse_enter) para los objetos DOM de este tipo. * * Muestra todos los objetos DOM esclavos con este mismo ID. * * @param: Objeto sv_event * @author: a_vera. */ function hme(e) { var t,cc; t = e.self; //# t = El propio objeto DOM. if(t!=e.target) { return; } if(!t._sv_conf) { //# Si no tiene configuración. return; //# | Final sin más. } //# ------------------------------------------------------- cc = t._sv_conf; //# cc = Configuración del objeto DOM. if(!cc) { //# Si no es válida. return; //# | Final sin más. } //# ------------------------------------------------------- _mostrar(cc.value); } //#-------------------------------------------------------------------------------------------- /** * Función manejadora del evento m_leave (mouse_leave) para los objetos DOM de este tipo. * * @param: Objeto sv_event * @author: a_vera. */ function hml(e) { var id; id = _get_id(e.fromto); _mostrar(id); } //#-------------------------------------------------------------------------------------------- //# Dado un objeto, que está actualmente apuntado, deja en el array // Al entrar en un objeto sv_enter, se comprueba su ID de objeto, y se comprueba si // sale de un objeto con el mismo ID, si es así, no hace nada. /** * Obtiene el ID de objeto sventer de un determinado objeto. Si este objeto no es un sventer * busca uno que lo sea entre sus padres en el modelo DOM y devuelve su ID. Si no se * encuentra devuelve false. * * @param: objeto DOM. El objeto DOM cuyo ID (o de alguno de sus padres) se desea. * @return: string o false. Si se encuentra un ID válido, una cadena con dicho ID. false si * este ID no se encuentra * @author: a_vera. */ //# Calcula las transiciones necesarias para que se muestren los objetos sventer con un ID //# determinado. Las transiciones se guardan en _sv._sventer.trans, que es un array asociativo //# donde cada clave es un ID de objeto sventer, y el item es un entero. El bit 0 de este entero //# indica el estado actual, y el bit 1 el que debe tener tras la trancisión. Un valor 0 en un //# bit indica "invisible" y un bit igual a 1 indica "visible". //# //# Aunque la función recibe un ID de objeto sventer, calcula las transiciones para todos los //# objetos sventer. El ID pasado es el de aquel objeto sventer que debe ser mostrado en primera //# instancia (por ejemplo, el objeto apuntado por el ratón), pero eso puede implicar que otros //# también sean mostrados (si la visibilidad del pasado depende de otros), o que otros sean //# ocultados (si estaban siendo mostrados, ya que solo se puede mostrar un objeto sventer y sus //# 'padres' en cada momento). //# //# En realidad esta función solo calcula directamente el bit 0 de las transiciones, y delega //# en _mostrar_aux2 para que calcule el bit 1 (el estado futuro). function _get_id(o) { var p,tp; while(1) { //# Bucle para buscar el ID. if(!o.getAttribute) { //# | Si el objeto no tiene getAttribute(). break; //# | | Salir del bucle para volver con false. } //# | tp = o.getAttribute('sv_type'); //# | Tomar el atributo 'sv_type'. if(tp) { //# | Si es válido. if(tp=='enter') { //# | | Si es 'enter' return o._sv_conf.value; //# | | | Devolver el ID. } //# | | ----------------------------------------------- } //# | p = o.parentNode; //# | p = Objeto padre. if(!p) { //# | Si no es válido. break; //# | | Salir del bucle para volver con false. } //# | if(p==o) { //# | Si es el propio objeto. break; //# | | Salir del bucle para volver con false. } //# | o = p; //# | Probar con el padre en la siguiente iteración. } //# return false; //# Terminar con false. } //#-------------------------------------------------------------------------------------------- /** * Muestra aquellos objetos sventer cuyo ID coincida con uno dado, y aquellos de los que depende * y oculta todos los demás. * * @param: string. El ID de objeto sventer. * @author: a_vera. */ //# Esta función mantiene actualizado _sv._sventer.id_actual, con el último ID con el que fue //# llamada, de modo que ignora llamadas consecutivas con el mismo ID. También mantiene el //# estado de visible/invisible de cada ID por separado en _sv._sventer.estados (puede que //# mostrar un ID, fuerce que también se muestren otros, de ahí que sea necesario un control //# individual). //# //# El algorimo consiste en llamar a _mostrar_aux1 que calculara transiciones de visible a //# invisible y al revés de cada objeto por separado, después, para cada transición, los //# objetos DOM afectados por un ID, se muestran con __mostrar, al tiempo que se guarda //# en un array los bordes del rectangulo que encierra a cada objeto mostrado. //# //# Finalmente, este array se usa (solo en versiones anteriores de IE) para ocultar los //# campos select que colisionen con los objetos mostrados. //# function _mostrar(id) { var se,t,rcts,i,ii,o,r,rr,ua; se = _sv._sventer; //# se => referencia a los datos de sventer. if(se.id_actual==id) { //# Si el ID actual coincide con el pasado. return; //# | Final sin hacer nada. } //# --------------------------------------------------- rcts = []; //# Aquí se guardan los rectangulos mostrados. _mostrar_aux1(id); //# Calcular las transiciones. for(var x in se.trans) { //# Para x = cada ID de objeto sventer. t = 3 & se.trans[x]; //# | t = transicion del objeto. if(t==1) { //# | Si el ID se debe ocultar __mostrar(x, false, rcts); //# | | Se oculta. se.estados[x] = 0; //# | | Se actualiza su estado (invisible) } else if(t==2) { //# | Si el ID se debe mostrar, __mostrar(x, true, rcts); //# | | Se muestra se.estados[x] = 1; //# | | Se actualiza su estado (visible) } else if(t==3) { //# | Si el ID debe permanecer mostrado, __mostrar(x, true, rcts); //# | | Se muestra (en realidad ya está mostrado //# | | pero es necesario actualizar rcts). } //# | } //# se.id_actual = id; //# Actualizado el ID mostrado actual. //#---------------------------------------- //# El resto del código oculta los campos SELECT que colisionen con alguna capa mostrada pero //# sólo si el navegador es alguna versión de Internet Explorer anterior a la 7. //#---------------------------------------- ua = _sv.user_agent(); //# Tomar el User Agent. if(ua!='IE') { //# Si no es una versión de IE anterior a la 7. return; //# | Final. } //# --------------------------------------------------- ii = _sv.select_list.length; //# ii = Número de campos select. rr = rcts.length; //# rr = Número de objetos mostrados. for(i=0; i referencia a un campo select de la página. if(rr) { //# | Si hay objetos mostrados. _sv.object_rec(o); //# | | _sv.rv => bordes del campo select. for(r=0; rrcts[r][0]) && //# | | | select. (_sv.rv[3]>rcts[r][1]) ) { //# | | | break; //# | | | | Hay que ocultar el select, salir del bucle. } //# | | | } //# | | if(r>=rr) { //# | | Si se rastreó sin colisiones el array entero. o.style.visibility='visible'; //# | | | El campo select se muestra. } else { //# | | Si se halló alguna colisión. o.style.visibility='hidden'; //# | | | El campo select se oculta. } //# | | } else { //# | Si no hay campos mostrados. o.style.visibility='visible'; //# | | El campo se muestra siempre. } //# | } //# Fin del bucle de campos SELECT. } //#-------------------------------------------------------------------------------------------- /** * Calcula las transiciones de visibilidad/invisibilidad de todos los objetos sventer, teniendo * en cuenta el ID de aquel que debe ser mostrado en primera instancia. * * @param: string. El ID de aquel objeto sventer que debe ser mostrado en primera instancia. * @return: Directamente no devuelve nada, pero indirectamente _sv._sventer.trans será * modificado para que contenga las transiciones. * @author: a_vera. */ //# Calcula las transiciones necesarias para que se muestren los objetos sventer con un ID //# determinado. Las transiciones se guardan en _sv._sventer.trans, que es un array asociativo //# donde cada clave es un ID de objeto sventer, y el item es un entero. El bit 0 de este entero //# indica el estado actual, y el bit 1 el que debe tener tras la trancisión. Un valor 0 en un //# bit indica "invisible" y un bit igual a 1 indica "visible". //# //# Aunque la función recibe un ID de objeto sventer, calcula las transiciones para todos los //# objetos sventer. El ID pasado es el de aquel objeto sventer que debe ser mostrado en primera //# instancia (por ejemplo, el objeto apuntado por el ratón), pero eso puede implicar que otros //# también sean mostrados (si la visibilidad del pasado depende de otros), o que otros sean //# ocultados (si estaban siendo mostrados, ya que solo se puede mostrar un objeto sventer y sus //# 'padres' en cada momento). //# //# En realidad esta función solo calcula directamente el bit 0 de las transiciones, y delega //# en _mostrar_aux2 para que calcule el bit 1 (el estado futuro). //# function _mostrar_aux1(id) { var se; se = _sv._sventer; //# se => referencia a los datos de sventer. for(var x in se.estados) { //# Para x = cada ID de objeto sventer. se.trans[x] = se.estados[x]; //# | Actualizado el bit 0 con su estado actual y el //# | bit 1 es cero provisionalmente. } //# _mostrar_aux2(id); //# Calcular el bit 1 de las transiciones. } //# ------------------------------------------------------------------------------------------- /** * Hace parte del cáculo de transiciones de visibilidad/invisibilidad de los objetos sventer. * * @param: string. El ID de un objeto sventer que debe ser mostrado. * @author: a_vera. */ //# Calcula el bit 1 de las transiciones de explicadas en los comentarios de _mostrar_aux1. //# //# Se hace en una función aparte porque se necesita recursión en el algoritmo. Es recursivo //# por definición, ya que si un objeto debe ser mostrado también lo deben ser aquellos de //# los que depende, en los cuales se debe volver a aplicar el mismo criterio. //# function _mostrar_aux2(id) { var se,i,ii; if(!id) { //# Si el ID no es válido. return; //# | Final sin hacer nada. } //# --------------------------------------------------- se = _sv._sventer; //# se => referencia a los datos de sventer. if(se.trans[id]>=2) { //# Si ya se ha tratado este ID. return; //# | Final sin hacer nada. } //# --------------------------------------------------- se.trans[id] |= 2; ii = se.depends[id].length; //# ii = Número de ID de los que depende. for(i=0; i