///////////////////////////////////////////////////////////////////////////////
// STANDARD LINGÜÍSTIC (C) 2002, 2003, 2004, 2005
//
// windows.js -> funciones para facilitar operaciones con ventanas
//
//  Version inicial programada por Gerardo García Peña
//
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
// function getWinX(hwin)
// function getWinY(hwin)
//
// DESCRIPCIÓN: Obtiene la posicion de la ventana
// PARÁMETROS:  El objeto ventana. Por defecto vale 'window.self'.
//
///////////////////////////////////////////////////////////////////////////////

function getWinX(hwin)
{
  if(!hwin)
    hwin = window.self;

  return (is_ie) ? hwin.screenLeft : hwin.screenX;
}

function getWinY(hwin)
{
  if(!hwin)
    hwin = window.self;

  return (is_ie) ? hwin.screenTop : hwin.screenY;
}

///////////////////////////////////////////////////////////////////////////////
// function popup(link, winname, int w, int h)
//
// DESCRIPCIÓN: Crea una ventana popup
// PARÁMETROS: link       -> Pagina web a abrir
//             winname    -> Identificador
//             w,h        -> Anchura y altura de la ventana
//             extraprops -> Propiedades extra a añadir a la ventana
//
///////////////////////////////////////////////////////////////////////////////

function resizedPopupEvent()
{
  if(is_ie)
  {
    // el IE no me permite acceder a las variables globales de la página que a
    // generado el evento, así que ajo y agua y me quedo con las ganas :'(
  } else {
    if(this.__firstResizeDone)
      this.setDefaultPopupSize = false; 
    else
      this.__firstResizeDone = true;
  }
}

function popup(link, winname, w, h, extraprops)
{
  var lprops = new Array(0);
  var top = 0;
  var calc_height = screen.availHeight;
  var calc_width = (screen.availWidth - (window.outerWidth - window.innerWidth));
  var notDefinedSize = (w == null || h == null);

  // Por defecto activamos los scrollbars y que sea redimensionable
  if(extraprops)
  {
    if(extraprops.search(/scrollbars\s*=\s*no/i) == -1)
      lprops[top++] = "scrollbars=yes";
    if(extraprops.search(/resizable\s*=\s*no/i) == -1)
      lprops[top++] = "resizable=yes";
    if(extraprops.search(/^\s*$/) == -1)
      lprops[top++] = extraprops;
  } else {
    lprops[top++] = "scrollbars=yes,resizable=yes";
  }
  lprops[top++] = "status=yes";
  
  // Si estamos con el explorer calculamos a ojo (y hardcoded) los elementos de
  // la ventana, bordes, etc... (no soporta bien las propiedades outerX)
  if(is_ie)
  {
    calc_height -= 32;
    if(extraprops)
    {
      if(extraprops.search(/menubar\s*\=\s*yes/i) != -1)
        calc_height -= 44;
      if(extraprops.search(/location\s*\=\s*yes/i) != -1)
        calc_height -= 25;
      if(extraprops.search(/status\s*\=\s*yes/i) != -1)
        calc_height -= 19;
      if(extraprops.search(/toolbar\s*\=\s*yes/i) != -1)
        calc_height -= 33;
    }
  }
  
  // Si no se ha indicado ninguna anchura ni altura, asignamos una por defecto
  if(w == null) w = 600;
  if(h == null) h = 400;

  // Calculamos altura y anchura
  lprops[top++] = (w > 0)
                    ? "width=" + w + ",left=" + ((screen.availWidth - w)/2)
                    : "width=" + calc_width + ",screenX=" + screen.availLeft;
  lprops[top++] = (h > 0)
                    ? "height=" + h + ",top=" + ((screen.availHeight - h)/2)
                    : "height=" + calc_height + ",screenY=" + screen.availTop;

  // Generamos el string con las propiedades de la ventana
  var put_coma = false;
  var wprops = "";
  var i;
  for(i = 0; i < lprops.length; i++)
  {
    if(put_coma) wprops = wprops + ",";
    wprops = wprops + lprops[i];
    put_coma = true;
  }

  // Creamos la ventana
  var newwin = window.open(link, winname, wprops);

  // Si estamos en mozilla nos aseguramos que la ventana no sea mas
  // alta que la pantalla (la redimensionamos is hace falta)
  if(!is_ie && newwin.outerHeight >= screen.availHeight)
    newwin.resizeBy(0, screen.availHeight - newwin.outerHeight);

  // Damos el control a la ventana
  newwin.focus();

  if(notDefinedSize)
    newwin.setDefaultPopupSize = true; 

  newwin.__firstResizeDone = false;
  if(is_ie)
  {
    newwin.attachEvent("onresize", resizedPopupEvent);
  } else {
    newwin.captureEvents(Event.RESIZE);
    newwin.onresize = resizedPopupEvent;
  }

  return newwin;
}

///////////////////////////////////////////////////////////////////////////////
// function newpopupwin(link, winname, w, h)
//
// DESCRIPCIÓN: Crea una ventana completa, nueva.
// PARÁMETROS: Idem que popup(). De hecho se basa en ella.
//
///////////////////////////////////////////////////////////////////////////////

function newpopupwin(link, winname, w, h)
{
  return popup(link, winname, w, h, "toolbar=yes,status=yes,menubar=yes,location=yes");
}

///////////////////////////////////////////////////////////////////////////////
// function popuphelp(section, part)
//
// DESCRIPCIÓN: Saca una ventanita de ayuda.
// PARÁMETROS:  section -> Sección de la ayuda
//              part    -> Parte de la ayuda
//
///////////////////////////////////////////////////////////////////////////////

function popuphelp(section, part)
{
  var hposX, hposY, helpwin, loc;

  loc = "/help/do_" + section;
  if((part != "undefined") && (part != ""))
    loc = loc + "." + part;
  loc += ".html";
  hposX = getWinX();
  hposY = getWinY();
  helpwin = window.open(loc, "popuphelp", "resizable=yes,scrollbars=yes,width=200,height=200,top="+hposY+",left="+hposX);
  helpwin.focus();
}

///////////////////////////////////////////////////////////////////////////////
// function refreshopener(parentloc)
//
// DESCRIPCIÓN: Se ejecuta desde la ventana popup hija. Dependiendo del
//              parametro, actualiza la ventana padre o cambia la ubicación de
//              la ventana padre.
// PARÁMETROS:  parentloc:
//                (indefinido) o (integer) -> actualiza la ventana padre
//                (string URL)             -> Lleva el padre a la URL
//                                            especificada
//
///////////////////////////////////////////////////////////////////////////////

function refreshopener(loc)
{
  var wndp = window.opener;

  if(wndp != null && !wndp.closed)
    wndp.location = (typeof(loc) == "string") ? loc : window.opener.location;
}

///////////////////////////////////////////////////////////////////////////////
// function closepopup_timefunc(t)
//
// DESCRIPCIÓN: Función usada por la función 'closepopup' para cerrar el popup
//              actual de modo diferido. NO DEBE USARSE EN EL RESTO DE SCRIPTS
//              DE LA WEB.
// PARÁMETROS:  t: Si es 0 cierra la ventana automáticamente.
//                 Si es distinto de 0, se cierra la ventana SÓLO SI la ventana
//                 padre está cargada (flag 'is_loaded' es cierto) o cerrada, o
//                 en caso contrario, se reprograma esta función para que
//                 vuelva a ejecutarse al cabo de un tiempo.
//                    
///////////////////////////////////////////////////////////////////////////////

function closepopup_timefunc(t)
{
  var wndp = window.opener;
  var do_close;

  // Comprobación de seguridad
  if(window.closed)
    return;

  // Si 't' es distinto de cero, sólo terminamos si la ventana padre se ha
  // recargado (su flag 'is_loaded' vuelve a ser cierto) o se ha cerrado.
  if(t != 0)
  {
    do_close = (wndp == null || wndp.closed || wndp.is_loaded);
    if(!do_close)
      setTimeout("closepopup_timefunc(1);", 500);
  } else {
    t = true;
  }

  // Si 'do_close' es cierto, se cierra la ventana y punto
  if(do_close)
  {
    window.close();
    if(wndp != null && !wndp.closed)
      wndp.focus();
  }
}

///////////////////////////////////////////////////////////////////////////////
// function closepopup(parentloc)
//
// DESCRIPCIÓN: Se ejecuta desde la ventana popup hija. Destruye la ventana
//              y, dependiendo del parametro, actualiza el padre, activa
//              el padre, o cambia la ubicación del padre.
// PARÁMETROS:  parentloc:
//                Puede tomar varios valores. Según el tipo del valor se
//                realizará una acción u otra:
//
//                  indefinido
//                    Solo se activa el padre
//
//                  string
//                    Lleva el padre a la URL especificada
//
//                  númber
//                    Hace un refresco de la info del padre:
//                      Si es 0, se refresca el padre inmediatamente.
//                      Si es positivo (mayor que cero), se refresca el padre
//                        inmediatamente y se espera X segundos a cerrar la
//                        ventana.
//                      Si es negativo (menor que cero), se refresca el padre
//                        inmediatamente y se espera a que el padre haya
//                        terminado de recargarse para cerrar la ventana.
//                    
///////////////////////////////////////////////////////////////////////////////

function closepopup(parentloc)
{
  var wndp;

  wndp = window.opener;
  if(wndp != null && !wndp.closed &&
     ((typeof(parentloc) == "string") || (typeof(parentloc) == "number")))
  {
    wndp.location = (typeof(parentloc) == "number")
                      ? window.opener.location
                      : parentloc;
    wndp.is_loaded = false;
  }
  if(typeof(parentloc) == "number" && parentloc != 0)
  {
    if(parentloc > 0)
    {
      setTimeout("closepopup_timefunc(0);", parentloc * 1000);
    } else {
      closepopup_timefunc(1);
    }
  } else {
    window.close();
    if(wndp != null && !wndp.closed)
      wndp.focus();
  }
}

///////////////////////////////////////////////////////////////////////////////
// function HideElementById(id)
// function ShowElementById(id)
//
// DESCRIPCIÓN: Oculta/muestra un elemento de la página identificado por
//              su id (generalmente un bloque DIV, aunque puede ser cualquier
//              tipo de elemento)
// PARÁMETROS: id - Identificador (id) del elemento o un array de id's
//
///////////////////////////////////////////////////////////////////////////////

function HideElementById(id)
{
  var elem, i;

  if(id instanceof Array)
  {
    for(i = 0; i < id.length; i++)
      HideElementById(id[i]);
  } else {
    elem = document.getElementById(id);
    elem.style.visibility = 'hidden';
    elem.style.display = 'none';
  }
}

function ShowElementById(id)
{
  var elem, i;

  if(id instanceof Array)
  {
    for(i = 0; i < id.length; i++)
      ShowElementById(id[i]);
  } else {
    elem = document.getElementById(id);
    if(elem.nodeName == 'TABLE')
    {
      // Mostramos segun el rollo de tabla
      elem.style.visibility = 'visible';
      elem.style.display = (is_ie) ? 'block' : 'table';
    } else if(elem.nodeName == 'TD' || elem.nodeName == 'TH') {
      // Mostramos segun el rollo de celda de tabla
      elem.style.visibility = 'visible';
      elem.style.display = (is_ie) ? 'inline' : 'table-cell';
    } else if(elem.nodeName == 'TR') {
      // Mostramos segun el rollo de fila de tabla
      elem.style.visibility = 'visible';
      elem.style.display = (is_ie) ? 'inline' : 'table-row';
    } else {
      // Todo lo demás lo hacemos a lo bestia cual bloque DIV
      elem.style.visibility = 'visible';
      elem.style.display = 'block';
    }
  }
}

///////////////////////////////////////////////////////////////////////////////
// function ShowHideElementById(show, elem)
//
// DESCRIPCIÓN: Oculta/muestra un elemento de la página identificado por su id
//              (generalmente un bloque DIV) según si 'show' es cierto o falso
// PARÁMETROS: 
//    show  booleano. cierto si se debe mostrar el elemento, falso en caso de
//          desear ocultarlo.
//    elem  elemento/elementos a mostrar/ocultar
//             
///////////////////////////////////////////////////////////////////////////////

function ShowHideElementById(show, elem)
{
  if(show)
    ShowElementById(elem);
  else
    HideElementById(elem);
}

///////////////////////////////////////////////////////////////////////////////
// function ShowHideByCheckbox(cbname, elemname, neg)
//
// DESCRIPCIÓN: Oculta/muestra un elemento de la página identificado por
//              su id (generalmente un bloque DIV) según el estado de
//              un checkbox (identificado tambien por su id)
// PARÁMETROS: 
//    cbname  ID del checkbox que indicará si muestra/oculta
//    id      ID del objeto a ocultar/mostrar
//    neg     Si vale 'true' se comporta al reves de lo habitual, que sería
//            cuando vale 'false'. Simplemente si está marcado (el checkbox)
//            oculta el elemento, si no está marcado lo muestra
//             
///////////////////////////////////////////////////////////////////////////////

function ShowHideByCheckbox(cbname, elemname, neg)
{
  if((!neg && document.getElementById(cbname).checked) || (neg && !document.getElementById(cbname).checked))
    ShowElementById(elemname);
  else
    HideElementById(elemname);
}

///////////////////////////////////////////////////////////////////////////////
// function statusSet(msg)
//
// DESCRIPCIÓN: Cambia el mensaje de estado del explorador. Util para poner
//              información en la barra de estado del explorador con más
//              sentido que un simple link.
// PARÁMETROS:  msg - Mensaje a poner. Un simple String.
//
///////////////////////////////////////////////////////////////////////////////

function statusSet(msg)
{
  window.defaultStatus = "";
  window.status = msg;
}

///////////////////////////////////////////////////////////////////////////////
// function getClientWidth()
// function getClientHeight()
//
// DESCRIPCIÓN: Dan el tamaño del area visible de la ventana dedicada a mostar
//              la página
// PARÁMETROS:  Ninguno conocido
//
///////////////////////////////////////////////////////////////////////////////

function getClientWidth()
{
  return (is_ie) ? document.body.clientWidth : window.innerWidth;
}

function getClientHeight()
{
  return (is_ie) ? document.body.clientHeight : window.innerHeight;
}

///////////////////////////////////////////////////////////////////////////////
// function ChangeParametersInURL(url, lpar)
//
// DESCRIPCIÓN: Cambia el valor de los parámetros en la URL pasada
// PARÁMETROS: url  - URL donde concatenar los parámetros
//             lpar - parámetros a cambiar/añadir. Es un array de pares
//                            nombre - valor
//
///////////////////////////////////////////////////////////////////////////////

function ChangeParametersInURL(url, lpar, newmark)
{
  var baseurl;
  var params;
  var mark;
  var i;

  // Copiamos la direccion URL por si acaso viene de un window.location
  url = new String(url);
  // Obtenemos la direccion a secas de la web
  baseurl = url.replace(/(\?[^#]*)?(\#.*)?$/, "");
  // Obtenemos los parámetros actuales de la web
  if(url.indexOf("?") >= 0)
  {
    params = url.replace(/^.*\?/, "");
    params = params.replace(/\#.*/, "");
  } else
    params = "";
  // Obtenemos la marca
  if(newmark != null)
  {
    mark = newmark;
    if(newmark.indexOf("#") < 0)
      mark = "#" + mark;
  } else
    mark = (url.indexOf("#") >= 0) ? url.replace(/^[^#]*/, "") : "";
  // Eliminamos los parametros que ya existan en la direccion
  for(i = 0; i < lpar.length; i += 2)
    params = params.replace(new RegExp(lpar[i] + "\\=[^\\&]*\\&?"), "");
  // Averiguamos cual es el ultimo &, y si no es el ultimo caracter
  // de la cadena, lo añadimos (excepto si la cadena esta vacia)
  if(params != "")
    if(params.lastIndexOf("&") < params.length - 1)
      params += "&";
  // Concatenamos los nuevos parametros
  for(i = 0; i < lpar.length; i += 2)
    params = params + lpar[i] + "=" + lpar[i+1] + "&";
  // Quitamos el ultimo & si existe
  params = params.replace(/\&$/, "");
  // Devolvemos el resultado
  return baseurl + "?" + params + mark;
}