// ---------------------------------------
// INICIO Variables Globales
// ---------------------------------------

// Funciones de mensajes de Error
var arrMensajesError = new Array();
var arrMensajesSistema = new Array();

// ---------------------------------------
// FIN Variables Globales
// ---------------------------------------

// ---------------------------------------
// INICIO Funciones de Eventos del Teclado
// ---------------------------------------

function isCtrlPressed(e) {
  return(e? e.ctrlKey: window.event.ctrlKey);
}

function isShiftPressed(e) {
  return(e? e.shiftKey: window.event.shiftKey);
}

function isAltPressed(e) {
  return(e? e.altKey: window.event.altKey);
}        

// ---------------------------------------
// FIN Funciones de Eventos del Teclado
// ---------------------------------------


// ---------------------------------------------------
// INICIO Funciones de Eventos y propiedades del Mouse
// ---------------------------------------------------

// nqfh: qué hace esta función?
function getMouseObject(e) {
  var ev = (e? (e.target? e.target: window.event.srcElement) : (window.event ? window.event.srcElement : null));  
  if (ev != null){
    return ev;
  }else{
    var ev;
    var arrIframes = document.getElementsByTagName('iframe');
    for(var i=0; i<arrIframes.length; i++){
      if (arrIframes[i].contentWindow){
        var evTemp = arrIframes[i].contentWindow.window.event;
        if (evTemp){
          ev = evTemp;
          break;
        }
      }
    }
    return(ev? ev.srcElement: null); 
  }
}
    
function getMouseX(e) {
  if (e != null){
    return(e.clientX? e.clientX: window.event.clientX);
  }else{
    return(window.event? window.event.clientX: null); 
  }  

//    if (!e) e = window.event;
//    var theLeft;
//    if (document.documentElement && document.documentElement.scrollLeft){
//        theLeft = document.documentElement.scrollLeft;
//    }else if (document.body){
//        theLeft = document.body.scrollLeft;
//    }
//    return(e.clientX + theLeft);
}
      
function getMouseY(e) {
  if (e != null){
    return(e.clientY? e.clientY: window.event.clientY);
  }else{
    return(window.event? window.event.clientY: null); 
  }

//    if (!e) e = window.event;
//    var theTop;
//    if (document.documentElement && document.documentElement.scrollTop){
//        theTop = document.documentElement.scrollTop;
//    }else if (document.body){
//        theTop = document.body.scrollTop
//    }          
//    return(e.clientY + theTop);
}

function isMouseBelowObject (e,objTarget) {
  var iMouseTop = getMouseY(e) + getWindowScrollTop();            
  var iObjTop = getAbsTop(objTarget);
  var iObjHeight = objTarget.clientHeight;
  var iObjBottom = iObjTop + iObjHeight;
  if (iMouseTop <= iObjBottom) {
    return false;
  } else {                
    return true;
  }
}

function isMouseAboveObject (e,objTarget) {
  var iMouseTop = getMouseY(e) + getWindowScrollTop();
  var iObjTop = getAbsTop(objTarget);
  if (iMouseTop >= iObjTop) {
    return false;
  } else {
    return true;
  }
}

function isMouseRightOffObject (e,objTarget) {                
  var iMouseLeft = getMouseX(e) + getWindowScrollLeft();
  var iObjLeft = getAbsLeft(objTarget);
  var iObjWidth = objTarget.clientWidth;
  var iObjRight = iObjLeft + iObjWidth;
  if (iMouseLeft <= iObjRight) {
    return false;
  } else {                
    return true;
  }
}

function isMouseLeftOffObject (e,objTarget) {
  var iMouseLeft = getMouseX(e) + getWindowScrollLeft();
  var iObjLeft = getAbsLeft(objTarget);
  if (iMouseLeft >= iObjLeft) {
    return false;
  } else {                
    return true;
  }
}

function isMouseAfterObject (e,objTarget) {      
  return isMouseBelowObject(e,objTarget) || isMouseRightOffObject(e,objTarget);
}

function isMouseBeforeObject (e,objTarget) {
  return (isMouseLeftOffObject(e,objTarget) && !isMouseBelowObject(e,objTarget)) || isMouseAboveObject(e,objTarget);
}

// ---------------------------------------------------
// FIN Funciones de Eventos y propiedades del Mouse
// ---------------------------------------------------

// --------------------------------------------------------------
// INICIO Funciones de Posicion o Visualización de elementos HTML
// --------------------------------------------------------------

function mostrarObjeto(varObjeto, idObjeto, blnMostrar){
  if(varObjeto == null){
    if(idObjeto == null){
      //nqfh: decidir si existirá esta variable
//      if(DEBUG){
        alert('No se mandaron los parámetros de la función mostrarObjeto');
//      }
      return false;
    }
    varObjeto = document.getElementById(idObjeto);
    if (varObjeto == null){
      alert('No existe el objeto ' + idObjeto);
      return false;
    }
  }
  if (blnMostrar == true){
    varObjeto.style.display = '';
  } else {
    varObjeto.style.display = 'none';
  }
  return true;
}

// <Posicion Absoluta de un elemento>
function getAbsLeft(el){
  var l = el.offsetLeft;
  while(el = el.offsetParent)
    l+=el.offsetLeft;
  return l;
}

function getAbsTop(el){
  var t = el.offsetTop;
  while(el = el.offsetParent)
  //while((el=el.parentNode) && el!=document)
  t+=el.offsetTop;
  return t;
}
// </Posicion Absoluta de un elemento>

// <Posicion Relativa de un elemento>  
function getOffLeft(el){
  return el.offsetLeft;
}

function getOffTop(el){
  return el.offsetTop;
}
// </Posicion Relativa de un elemento>  


// <Posicion de las Barras de Desplazamiento (ScrollBars)>  
function getWindowScrollLeft() {
  return window.pageXOffset ? window.pageXOffset : (document.body.scrollLeft ? document.body.scrollLeft : document.documentElement.scrollLeft);
}

function getWindowScrollTop() {
  return window.pageYOffset ? window.pageYOffset : (document.body.scrollTop ? document.body.scrollTop : document.documentElement.scrollTop);
}
// </Posicion de las Barras de Desplazamiento (ScrollBars)>  

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

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


// ---------------------------------------------------
// FIN Funciones de Posicion de elementos HTML
// ---------------------------------------------------

// ---------------------------------------------------------
// INICIO Funciones de que leen QueryString o cambian la URL
// ---------------------------------------------------------

function goBack(){
  //window.history.back()
  history.go(-1)
}

function redirectToURL(strURL, blnNewWindow) {
  if (blnNewWindow){
    window.open(strURL, "WinE", "resizable=yes,scrollbars=yes");
//width=300
//Use this to define the width of the new window. 
//
//height=200
//Use this to define the height of the new window. 
//
//toolbar=yes or no
//Whether or not the new window should have the browser navigation bar at the top (The back, foward, stop buttons..etc.). 
//
//location=yes or no
//Whether or not you wish to show the location box with the current url (The place to type http://address). 
//
//directories=yes or no
//Whether or not the window should show the extra buttons. (what's cool, personal buttons, etc...). 
//
//status=yes or no
//Whether or not to show the window status bar at the bottom of the window. 
//
//menubar=yes or no
//Whether or not to show the menus at the top of the window (File, Edit, etc...). 
//
//copyhistory=yes or no
//Whether or not to copy the old browser window's history list to the new window. 
  }else{
    window.location = strURL;
  }
}

function getQueryStringArgs() {
  var args = new Object();
  var query = location.search.substring(1);
  var pairs = query.split('&');
  for(var i = 0; i < pairs.length; i++) {
  var pos = pairs[i].indexOf('=');
  if (pos == -1) {
  continue;
  }
  var argname = pairs[i].substring(0,pos);
  var value = pairs[i].substring(pos+1);
  args[argname] = unescape(value);
  }
  return args;
  /*
  ejemplo
  
  var QueryStringArgs = getQueryStringArgs();
      var TipoInf =QueryStringArgs.TipoInf;
      if (TipoInf ==0){
        var IdEvdor =QueryStringArgs.IdEvdor;
        CargarPantInforme(IdEvdor);  
      }
      
  */
}

// ---------------------------------------------------
// FIN Funciones de que leen o cambian la URL
// ---------------------------------------------------

// ---------------------------------------------------
// INICIO Funciones de Pantalla (que trabajan sobre el Screen)
// ---------------------------------------------------

function clearSelection () {
  if (document.selection){
    document.selection.empty();
  }else{
    if (window.getSelection){
      window.getSelection().removeAllRanges();
    }
  }
}

// ---------------------------------------------------
// FIN Funciones de Pantalla (que trabajan sobre el Screen)
// ---------------------------------------------------

// -------------------------------------------------------
// INICIO Funciones de lectura/escritura en elementos HTML
// -------------------------------------------------------

// Funciones de Lectura

// -------------------------------------------------------
// INICIO Funciones de lectura/escritura en elementos HTML
// -------------------------------------------------------

// Funciones de Lectura

function getObjectValue(idObjeto){
  var varObjeto = document.getElementById(idObjeto);
  return getObjectValueByObject(varObjeto);
/*
  var strTypeOrTagName = getObjectTypeOrTagName(varObjeto);
  switch (strTypeOrTagName){
    case 'DIV':
    case 'SPAN':
      return getDivValue(idObjeto);
      break;
    case 'RADIO':
      var varNameRbl = varObjeto.name;
      return getRblSelectedItem(varNameRbl);
      break;
    case 'CHECKBOX':
      var varPrefijoCbl = String(idObjeto).split('_')[0]
      return getItemsObjectCbl(varPrefijoCbl);
      break;
//    case 'SELECT-ONE':
//      break;
    default: // nqfh: HIDDEN ,  text | textarea -> deberían estar en los case; si no, los tags no contemplados van a tratarse como textboxes
      return varObjeto.value;
      break;
  }
*/
}

function getObjectValueById(idObjeto){
  var varObjeto = document.getElementById(idObjeto);
  return getObjectValueByObject(varObjeto);
}

function getObjectValueByObject(varObjeto){
  var strTypeOrTagName = getObjectTypeOrTagName(varObjeto);
  switch (strTypeOrTagName){
    case 'DIV':
    case 'SPAN':
      return getDivValue(idObjeto);
      break;
    case 'RADIO':
      var varNameRbl = varObjeto.name;
      return getRblSelectedItem(varNameRbl);
      break;
    case 'CHECKBOX':
      var varPrefijoCbl = String(idObjeto).split('_')[0]
      return getItemsObjectCbl(varPrefijoCbl);
      break;
//    case 'SELECT-ONE':
//      break;
    default: // nqfh: HIDDEN , text | textarea -> deberían estar en los case; si no, los tags no contemplados van a tratarse como textboxes
      return varObjeto.value;
      break;
  }
}

function getDivValue(idDiv){
  var objDiv = document.getElementById(idDiv);
  if(objDiv != null){
    return getInnerText(objDiv);
  }
}

function getRblSelectedItem(rblName){
  // Devuelve el ítem seleccionado del Rbl con nombre rblName
  // Si no existe o no está seleccionado ninguno, devuelve -1
  var arrObjRbl = document.getElementsByName(rblName);
  for (i=0 ; i<arrObjRbl.length ; i++){
    var objRbl = arrObjRbl[i];
    if (objRbl.checked == true){
      return i; //objRbl.id;
    }
  }
  return -1;
}

// nqfh: que devuelve esta funcion? adecuar el nombre; poner ejemplo
function getItemsObjectCbl(prefCblId, idContenedor){
  //Recibe: prefCblId: prefijo de los cbl buscados; Ej: id='cblNombres_1' -> prefCblId='cblNombres'
  //Devuelve concatenación de parejas de chk (el postfijo) y valor (0 ó 1), separadas por '_'
  // Ej: si hay 3 chk: cblNombres_1, cblNombres_2 y cblNombres_3, con el segundo chequeado, devuelve: 1;0_2;1_3;0
  var objContenedor = document.getElementById(idContenedor);
  if (objContenedor == null){
    objContenedor = document.getElementsByTagName('body')[0];
  }
  var strCblItemsValues = '';
  var arrObjCbl = objContenedor.getElementsByTagName('input');
  for (i=0 ; i<arrObjCbl.length ; i++){
    var objCblItem = arrObjCbl[i];
    if (String(objCblItem.id).split('_')[0] == prefCblId){
      if (objCblItem.checked == true){
        strCblItemsValues += String(objCblItem.id).split('_')[1] + ';1_'
      } else {
        strCblItemsValues += String(objCblItem.id).split('_')[1] + ';0_'
      }
    } 
  }
  strCblItemsValues += 'dummy';
  strCblItemsValues = strCblItemsValues.replace('_dummy',''); // se quita el _dummy agregado al filal del loop
  return strCblItemsValues;
}

// nqfh: esta con mayusculas solo por compatibilidad con versiones anteriores
function GetInnerText (node){
  return (node.textContent || node.innerText || node.text);
}

function getInnerText (node){
  return (node.textContent || node.innerText || node.text);
}

// Funciones de Escritura

function setObjectValue(idObjeto, varValue, blnSetFocus,blnSelect,blnOmitirValue){
  var varObjeto = document.getElementById(idObjeto);
  var strTypeOrTagName = getObjectTypeOrTagName(varObjeto);
  switch (strTypeOrTagName){
    case 'DIV':
    case 'SPAN':
    case 'LABEL':
      setDivValue(idObjeto, varValue);
      //escribirMensajeInDiv(Valor,varObjeto);
      break;
    case 'RADIO':
      //setRblValue(idObjeto, varValue);
      var varNameRbl = varObjeto.name;
      setRblItem(varNameRbl, varValue);
      break;
    case 'CHECKBOX':
      setChkValue(idObjeto, varValue, null);
      break;
//    case 'SELECT-ONE':
//      break;
    default: // nqfh: text y textarea -> deberían estar en los case; si no, los tags no contemplados van a tratarse como textboxes
      if (blnOmitirValue != true){
        varObjeto.value = varValue;  
      }
      if (blnSelect == true){
        varObjeto.select();
      }
      break;
  }
  if (blnSetFocus == true){
    varObjeto.focus();
  }
  return true;
}

function setDivValue(idDiv, varValue){
  var objDiv = document.getElementById(idDiv);
  if(objDiv != null){
    setObjectInnerText(objDiv, varValue);
  }
}

function setChkValue(idCbl, varValue, idContenedor){
  var objContenedor = document.getElementById(idContenedor);
  if (objContenedor == null){
    objContenedor = document.getElementsByTagName('body')[0];
  }
  var arrObjCbl = objContenedor.getElementsByTagName('input');
  for (i=0; i<arrObjCbl.length; i++){
    var objCbl = arrObjCbl[i];
    if (objCbl.id == idCbl){
      if (varValue == '0' || varValue == false || varValue == null){
        varValue = false;
      } else {
        varValue = true;
      }
      objCbl.checked = varValue;
      break;
    }
  }
  return true;
}

function setRblItem(rblName, iItem){
  // Setea el iItem del Rbl con el nombre rblName
  var arrObjRbl = document.getElementsByName(rblName);
  if (arrObjRbl.length > 0){
    if (iItem >=0 && iItem < arrObjRbl.length){
      arrObjRbl[iItem].checked = true;
    }
  }
//  var objRbl = document.getElementById(idRbl);
//  if(objRbl != null){
//    objRbl.checked = varValue;
//  }
}

function setObjectInnerText(varObject, varValue){
  if (document.all){
    varObject.innerText = varValue;
  }else{
    varObject.textContent = varValue;
  }
}

// Funciones de Lectura de Propiedades de Elementos HTML

function getObjectTypeOrTagName(varObjeto){
  // Devuelve en MAYÚSCULAS el Tipo de objeto y, en caso de no tener tipo, devuelve el nombre del Tag
  // Ejemplos: DIV, SPAN, RADIO, CHECKBOX, SELECT-ONE (ddl)
  var strTypeOrTagName = varObjeto.type;
  if (varObjeto.type == null){
    strTypeOrTagName = varObjeto.tagName;
  }
  return strTypeOrTagName.toUpperCase();
}


// Funciones de DDL (dropDownList) ---------------------------

function vaciarDdl(objDdl, idDdl){
  if(objDdl == null){
    if(idDdl == null){
      //nqfh: decidir si existirá esta variable
//      if(DEBUG){
//        alert('No existe el Ddl ' + idDdl);
//      }
      return false;
    }
    objDdl = document.getElementById(idDdl);
  }
  if (objDdl.length > 0){
    var i;
    for(i=objDdl.length-1; i>=0; i--){
      objDdl.remove(i);
    }
  }
}

function llenarDdlFromXML(objDdl, itemsArray, textoDefecto, valorDefecto){
  //Es mejor dejar fuera del ciclo, pues si no existen registros igual mostrará el texto
  var newOption = document.createElement('option');
  newOption.value = valorDefecto;
  newOption.text = textoDefecto;
  try{
    objDdl.add(newOption, null); // Standard
  }catch(err){
    objDdl.add(newOption); // IE
  }
  var i;
  for (i=0; i<itemsArray.length; i++){
    var newOption = document.createElement('option');
    newOption.value = getInnerText(itemsArray[i].getElementsByTagName('value')[0]);
    newOption.text = getInnerText(itemsArray[i].getElementsByTagName('text')[0]);
    try{
      objDdl.add(newOption, null); // Standard
    }catch(err){
      objDdl.add(newOption); // IE
    }
  }
  objDdl.cargaCompleta = true;
}

function llenarDdlFromArray(objDdl, arrDdl, textoDefecto, valorDefecto){
  //Es mejor dejar fuera del ciclo, pues si no existen registros igual mostrará el texto
  if (textoDefecto != null && valorDefecto != null){
    var newOption = document.createElement('option');
    newOption.value = valorDefecto;
    newOption.text = textoDefecto;
    try{
      objDdl.add(newOption, null); // Standard
    }catch(err){
      objDdl.add(newOption); // IE
    }
  }
  var i;
  for (i=0; i<arrDdl.length; i++){
    var newOption = document.createElement('option');
    newOption.value = String(arrDdl[i]).split('|')[0];
    newOption.text = String(arrDdl[i]).split('|')[1];
    try{
      objDdl.add(newOption, null); // Standard
    }catch(err){
      objDdl.add(newOption); // IE
    }
  }
  objDdl.cargaCompleta = true; 
}


// -------------------------------------------------------
// FIN Funciones de lectura/escritura en elementos HTML
// -------------------------------------------------------


// -------------------------------------------------------
// INICIO Funciones AJAX
// -------------------------------------------------------

function CreateXmlHttp(){
  //Creando objeto XMLHTTP en IE
  try{
    XmlHttp = new ActiveXObject('Msxml2.XMLHTTP');
  }catch(e){
    try{
      XmlHttp = new ActiveXObject('Microsoft.XMLHTTP');
    }catch(oc){
      XmlHttp = null;
    }
  }
  //Creando objeto XMLHTTP en Mozilla o Safari
  if(!XmlHttp && typeof XMLHttpRequest != 'undefined'){
    XmlHttp = new XMLHttpRequest();
  }
  return XmlHttp;
}

// -------------------------------------------------------
// FIN Funciones AJAX
// -------------------------------------------------------






// ----------------------
// Funciones Controles NQ 
// ----------------------

// Control NqDdlFecha
function llenarDdlAno(objDdl,idDdl,textoDefecto,valorDefecto,anoDesde,anoHasta){ 
  llenarDdlNumeros(objDdl,idDdl,textoDefecto,valorDefecto,anoDesde,anoHasta)
}
function llenarDdlDia(objDdl,idDdl,textoDefecto,valorDefecto){ 
  llenarDdlNumeros(objDdl,idDdl,textoDefecto,valorDefecto,1,31)
}
function llenarDdlMes(objDdl,idDdl,textoDefecto,valorDefecto){ 
  llenarDdlNumeros(objDdl,idDdl,textoDefecto,valorDefecto,1,12)
}

function llenarDdlNumeros(objDdl,idDdl,textoDefecto,valorDefecto,valorDesde,valorHasta){ 
  var ddl;
  if (objDdl == null){
    if (idDdl == null){
      alert('Debe enviar el objDdl o el idDdl');
    }
    objDdl = document.getElementById(idDdl);
  }
  objDdl.cargaCompleta = false;
  objDdl.validarCarga = true;
  if (objDdl.length > 0){
    vaciarDdl(ddl);
  }
  var newOption = document.createElement('option');
  newOption.value = valorDefecto;
  newOption.text = textoDefecto;
  try{
    objDdl.add(newOption, null); // Standard
  }catch(err){
    objDdl.add(newOption); // IE
  }
  var i;
  for (i=valorDesde; i<=valorHasta ; i++){
    var newOption = document.createElement('option');
    newOption.value = i;
    newOption.text = i;
    try{
      objDdl.add(newOption, null); // Standard
    }catch(err){
      objDdl.add(newOption); // IE
    }
  }
  objDdl.cargaCompleta = true;
}

function limpiarPantalla(strNomObjetos){
  //Recibe una lista de Id de elementos HTML y limpia(txtbox: borra textos; ddl: posiciona en index 0)
  //Soporta: textboxes, textareas y dropdownlists;
  //No soporta: rbl, chk, etc.
  //Ej: strNomObjetos = 'txtRut|ddlUsuarios|txtDescripcion'
  var arrNomObjetos = new Array();
  arrNomObjetos = String(strNomObjetos).split('|');

  var i;
  for (i=0; i<arrNomObjetos.length; i++){
    var idObjetoHtml = arrNomObjetos[i];
    var varObjeto = document.getElementById(idObjetoHtml);
    if (varObjeto != null){
      var valor = '';
      var tipoObjeto = getObjectTypeOrTagName(varObjeto);
      if (varObjeto == 'SELECT-ONE'){
        valor = 0;
      }
      setObjectValue(idObjetoHtml,valor,false);
    } else {
      alert('El objeto ' + idObjetoHtml + ' no existe en la página');
    }
  }
}

// ---------------------------------------
// INICIO Funciones Generales de Objetos
// ---------------------------------------

//<DESHABILITAR CONTROLES>
function disableChilds(idContenedor, blnDisable){
  var objCont = document.getElementById(idContenedor);
  var arrChildren = objCont.childNodes;
  for (var i = 0; i < arrChildren.length; i++){
    arrChildren[i].disabled = blnDisable;
  }
}

function disableCblItem(itemCblId, blnDisable){
  var objItemCbl = document.getElementById(itemCblId);
  if(objItemCbl != null){
    objItemCbl.disabled = blnDisable;
    return true;
  }
  return false;
//  var arrObjItemCbl = document.getElementsByTagName('input');
//  for (i=0 ; i<arrObjItemCbl.length ; i++){
//    var objItemCbl = arrObjItemCbl[i];
//    if (objItemCbl.id == itemCblId){
//      objItemCbl.disabled = blnDisable;
//    } 
//  }
}

function disableCbl(prefCblId, blnDisable, idContenedor){
  var objContenedor = document.getElementById(idContenedor);
  if (objContenedor == null){
    objContenedor = document.getElementsByTagName('body')[0];
  }
  var arrObjItemCbl = objContenedor.getElementsByTagName('input');
  for (i=0 ; i<arrObjItemCbl.length ; i++){
    var objItemCbl = arrObjItemCbl[i];
    if (String(objItemCbl.id).split('_')[0] == prefCblId){
      objItemCbl.disabled = blnDisable;
    } 
  }
  return true;
}

function disableRbl(rblName, blnDisable){
  var arrObjRbl = document.getElementsByName(rblName);
  for (i=0 ; i<arrObjRbl.length ; i++){
    arrObjRbl[i].disabled = blnDisable;
  }
  return true;
}
//</DESHABILITAR CONTROLES>


// ---------------------------------------
// FIN Funciones Generales de Objetos
// ---------------------------------------

// -----------------------------------------------------------------------------
// INICIO Funciones para codificación/decodificación de caracteres (acentos, etc)
// -----------------------------------------------------------------------------

var Utf8 = {
  // public method for url encoding
  encode : function (string) {
    string = string.replace(/\r\n/g,"\n");
    var utftext = "";

    for (var n = 0; n < string.length; n++) {
      var c = string.charCodeAt(n);
      if (c < 128) {
        utftext += String.fromCharCode(c);
      }
      else if((c > 127) && (c < 2048)) {
        utftext += String.fromCharCode((c >> 6) | 192);
        utftext += String.fromCharCode((c & 63) | 128);
      }
      else {
        utftext += String.fromCharCode((c >> 12) | 224);
        utftext += String.fromCharCode(((c >> 6) & 63) | 128);
        utftext += String.fromCharCode((c & 63) | 128);
      }
    }
    return utftext;
  },

  // public method for url decoding
  decode : function (utftext) {
    var string = "";
    var i = 0;
    var c = c1 = c2 = 0;

    while ( i < utftext.length ) {
      c = utftext.charCodeAt(i);
      if (c < 128) {
        string += String.fromCharCode(c);
        i++;
      }
      else if((c > 191) && (c < 224)) {
        c2 = utftext.charCodeAt(i+1);
        string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
        i += 2;
      }
      else {
        c2 = utftext.charCodeAt(i+1);
        c3 = utftext.charCodeAt(i+2);
        string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
        i += 3;
      }
    }
    return string;
  }
}

// -----------------------------------------------------------------------------
// FIN Funciones para codificación/decodificación de caracteres (acentos, etc)
// -----------------------------------------------------------------------------


// -----------------------------------------
// INICIO Funciones de mensajes de Error
// -----------------------------------------

function agregarMensajeError(strMensaje){
  arrMensajesError[arrMensajesError.length] = strMensaje;
}

function resetearMensajesError(){
  arrMensajesError = new Array();
}

function mostrarMensajesError(idContenedor, strCssClass){
  mostrarMensajesEnContenedor(arrMensajesError, idContenedor, strCssClass)
}

function mostrarMensajesEnContenedor(arrMensajes, idContenedor, strCssClass){
  if(idContenedor == null){
    idContenedor='divError';
  }
  var objContenedor = document.getElementById(idContenedor);
  if(strCssClass != null){
    idContenedor.className = strCssClass;
  }
  setObjectValue(idContenedor,'');  // Limpia el contenedor
  var objUl = document.createElement("ul");
  for (var i=0; i<arrMensajes.length; i++){
    var objLi = document.createElement("li");
    setObjectInnerText(objLi, arrMensajes[i]);
    objUl.appendChild(objLi);
  }
  objContenedor.appendChild(objUl);
}

// -----------------------------------------
// FIN Funciones de mensajes de Error
// -----------------------------------------

// -----------------------------------------
// INICIO Funciones no genéricas
// -----------------------------------------

function getValorParametro(NomParametro,Parametros){
  //NomParametro*?*valor|NomParametro*?*valor
  var resto = String(Parametros).split(NomParametro + '*?*')[1];
  return String(resto).split('|')[0];
}

//function CambiarControlPorDato(objContenedor, idContenedor, TagHTMLDato, css){
function cambiarDatoPorControl(objContenedor, tipoCtrl, idContenedor, cssControl){
  // tipoCtrl: indica el tipo de control para editar/ingresar datos
  if(objContenedor == null){
    if(idContenedor == null){
      return;
    }
    objContenedor = document.getElementById(idContenedor);
  }
  // el objeto contenedor debe debe ser el que tendra directamente el texto
  // y contenedor del nuevo objeto a insertar dentro de él
  
  // cómo capturo el contenido del objeto (el valor o el texto que tiene si no sé de que tipo es el contenedor)
  // no recuerdo por qué el tipo de control es un parametro... no debería ser una propiedad del contenedor????? no sé
  //lo siguiente se hizo pensando en que fuera el span
  
  switch (tipoCtrl){
  case 'nqDdlFecha':
    r.appendChild(crearDdlFecha('ddlFecha',2000,curyear,""));      
    break;
  case 'ddl':
    // falta definir el partametro tipo arreglo que necesita este 
    r.appendChild(crearNqDdl('ddlCuetaCorriente','celda_datos',arrDatos,"Selec. una cta. cte.","0"));          
    break;
  case 'txt':
    objContenedor.appendChild(crearNqTextBox("txtCaja",cssControl,"nnn"));
    setObjectValue("txtCaja","nn",true);
    break;
  }
}
// no seguí avanzado porque no se cual objeto debe tener el evento click...
// cuando hago click, suponiendo si el click se hace un click sobre un span
// IE ejecuta el evento 

// -----------------------------------------
// INICIO Funciones no genéricas
// -----------------------------------------


// FUNCIONES QUE HAY QUE REEMPLAZAR:
// cambiar llamado por setDivValue(idDiv, varValue); // Nota: se entrega el id y no el objeto, como en escribirMensajeInDiv
// function escribirMensajeInDiv(strError, div){
//    if (document.all){
//      div.innerText = strError;
//    }else{
//      div.textContent = strError;
//    }
//    div.parentNode.style.display = '';
//  }
  

// FUNCIONES CANDIDATAS A DESAPARECER:
function existeObjeto(idObjeto){
  var varObjeto = document.getElementById(idObjeto);
  if (varObjeto == null){
    return false;
  }
  return true;
}

function setFocus(idObjeto){
  var varObjeto = document.getElementById(idObjeto);
  varObjeto.focus();
}






//nqfh: no sé en qué lugar o seccion de este doc puede ir esta funcion 
function Trim(str,blnOnlyTrailingSpaces){  
    if (blnOnlyTrailingSpaces){
        return String(str).replace(/^\s*|\s*$/g,'');
    }else{
        if (String(str).indexOf('  ') >= 0){
            str = String(str).replace('  ',' ');
            return Trim(str,false);
        }else{
            return String(str).replace(/^\s*|\s*$/g,'');
        }
    }
}


//nqfh: no sé en qué lugar o seccion de este doc puede ir esta funcion
//esta se encarga de detectar tecla que presionó
function getkey(e){
  if (window.event){
    return window.event.keyCode;
  }  else if (e){
    return e.which;
   }else {
   return null;
   }
}

//FUNCIONES QUE TIENEN QUE VER CON EL FCK_EDITOR
function getFckEditorEditionArea(idFck){
  var fckTextoIframe = document.getElementById(idFck + '___Frame');
  if (fckTextoIframe){
    var srcDoc = fckTextoIframe.contentWindow.document;
    var fckAreaEdicion = srcDoc.getElementById("xEditingArea").getElementsByTagName('IFRAME')[0];
    var docAreaEdicion = fckAreaEdicion.contentWindow.document;
    var bodyAreaEdicion = docAreaEdicion.getElementsByTagName('BODY')[0];
    return bodyAreaEdicion;
  }else{
    return null;
  }
}

function getFckText(idFck){
  var oEditor = FCKeditorAPI.GetInstance(idFck);
  return oEditor.GetHTML();
//  var bodyAreaEdicion = getFckEditorEditionArea(idFck);
//  if (bodyAreaEdicion != null){
//    return bodyAreaEdicion.innerHTML;
//  }else{
//    return '';
//  }
}

function deleteFckText(idFck){
  var oEditor = FCKeditorAPI.GetInstance(idFck);
  return oEditor.SetHTML('');
//  var bodyAreaEdicion = getFckEditorEditionArea(idFck);
//  if (bodyAreaEdicion != null){
//    bodyAreaEdicion.innerHTML = '';
//  }else{
//    return null;
//  }
}


// -----------------------------------------
// INICIO Funciones verificacion de tipos de datos o variables
// -----------------------------------------

function varExists(vr){
  return Boolean(window.vr != 'undefined' && vr);
}

function isInteger(strDato){
  var i;

  var patron = new RegExp("[^0-9]", "i");
  if (strDato.search(patron) != -1){//encuentra caracteres inválidos de acuerdo a la E.R.
    return false;
  }
  return true;
}


function esEmailValido(strEmail) {
  var RegExPattern = new RegExp("^([0-9a-zA-Z]+[-._+&])*[0-9a-zA-Z]+@([-0-9a-zA-Z]+[.])+[a-zA-Z]{2,6}$", "i"); // "i" -> case insensitive
  if (strEmail.search(RegExPattern) == 0) {
    return true;
  }
  return false;
}

function esFechaValida(strFecha) {
  
  var RegExPattern = new RegExp("^[0-3]?[0-9]/[0-1]?[0-9]/[0-9]{4}$", "i"); // Fecha con formato dd/mm/yyyy
  if (strFecha.search(RegExPattern) == 0) {
      return true;
    arrFecha = strFecha.split('index.html');
    if(parseInt(arrFecha[0]) <= 31 && parseInt(arrFecha[1]) <= 12){
      return true;
    }
  }
  return false;
}
/*
function esSoloTexto(strTexto) {
  var RegExPattern = new RegExp("[a-zñüáéíóú ]+[a-zñüáéíóú ]$", "i"); // "i" -> case insensitive
  if (strTexto.search(RegExPattern) != 0) {
    return false;
  }
  return true;
}
*/
// -----------------------------------------
// FIN Funciones verificacion de tipos de datos o variables
// -----------------------------------------


function getNaturalHeight(img) {
    if( img.naturalHeight ) {
      return img.naturalHeight;
    } else {
      lgi = new Image();
      lgi.src = img.src;
      return lgi.height;
    }
  }

  function getNaturalWidth(img) {
    if( img.naturalWidth ) {
      return img.naturalWidth;
    } else {
      lgi = new Image();
      lgi.src = img.src;
      return lgi.width;
    }
  }