/*
epsc - entra porco sai chourico
translation: pig in, sausage out
server nfo

Version 2.0.0 - 2008/10/26
  closurefied epsc = vrajax (Versenet Ajax)

Version 1.4.2 - 2008/10/21
jsstr = jsstr + evallst[i].getElementsByTagName('js')[0].childNodes[j].data;
  in epscParse, eval processing
   changed from jsstr = jsstr + decodeURIComponent(evallst[i]. (.....)
    jsstr = jsstr + evallst[i].getElementsByTagName('js')[0].childNodes[j].data;

Version 1.4.1 - 2007/08/26
  in epscProcess
    if (section_url != null) {
      section_url = unescape(section_url); //weird shit


Version 1.4.0 - 2007/08/06
  removed epscCall function (it was a sweet and tender exploitable piece of tish)

Version 1.3.11 - 2007/02/02
  created epscParse: XML parsing and evaluation occurs here instead of in epscProcess
  created epscCheckDOM: checks DOM tree for the IDs in epscWatchIds, parses, executes and cleans up the "content" property
  epscGet && epscPost checks for initialization

Version 1.3.10 - 2007/01/30
  Loading... (reporting)
  needs epsc_statusVisible   = true; to show the label
  needs epsc_statusRefresh   = true; to show the refresh countdown
  epsc_statusStyle describes the style for the label
  function UpdateIdWithURL(req, argsString) {
      (.....)
      var objProp    = (args[1])?args[1]:'innerHTML';
  function updateElement ....
      removeElement(container, name); //make sure the object was deleted

Version 1.3.8 - 2007/01/19
  corrected javascript eval code: jsstr = jsstr + decodeURIComponent(evallst[i].getElementsByTagName('js')[0].childNodes[i].data);
  (problem reading more than 4096 bytes of the element's value)

*/

  function time_elapsed() {
    return this.timeend - this.timestart;
  }

  function sortUpdtObj(a, b) {
    return a.displayOrder - b.displayOrder;
  }

  function element_exists(array, item) {
    if (array ==null) return false;
    for (i = 0; i < array.length; i++) {
      if (array[i] == item) return true;
    }
    return false;
  }
  
  function updt_item(objId, objProp, objContent, displayOrder, displayMode) {
    this.objId        = objId;
    this.objProp      = objProp;
    this.objContent   = objContent;
    this.displayOrder = displayOrder;
    this.displayMode  = displayMode;
    this.updated      = false;
    this.sortable     = false;
    this.tries        = 0;
  }

  function eval_item(str) {
    this.evalStr    = str;
    this.tries      = 0;
  }

  function slot(epsc_connId) {
    this.state     = 0;
    this.id        = epsc_connId;
    this.timestart = 0;
    this.timeend   = 0;
    this.url       = 0;
    this.ro        = vrajax.Create(); //fra fra fra
    this.elapsed   = time_elapsed;
  }

  function queue_item(fn, url, callback, args, enqueueing_type, enqueueing_val) {
    this.fn              = fn;
    this.url             = url;
    this.callback        = callback;
    this.args            = args;
    this.enqueueing_type = enqueueing_type;
    this.enqueueing_val  = enqueueing_val;
    /*
    if ((typeof(allow_enqueueing) != 'undefined')||(allow_enqueueing != null)) {
      this.allow_enqueueing = allow_enqueueing;
    } else {
      this.allow_enqueueing = -1;
    }
    */
  }

  function refreshable_item(period, url, target, property) {
    this.period    = period; //Notice: period is in seconds!!
    this.last_updt = (new Date()).getTime();
    this.url       = url;
    this.target    = target;
    this.property  = property;
  }

var vrajax = new function() {
  
  var server_qsSeparator   = "?";
  
  var b_ie4 = (document.all) ? true : false;
  var b_ns4 = (document.layers) ? true : false;
  var b_ns6 = (document.getElementById && !document.all) ? true : false;
  
  //framework specific
  var epsc_initialized     = false;
  var epsc_connId          = 0;
  var epsc_remotereqs      = true;
  var epsc_defaultCallback = this.Process;//fra fra fra
  var epsc_separator       = "|;";
  var epsc_startupUrl      = "";
  var epsc_requestTimeout  = 15000;//timeout of requests in milliseconds
  var epsc_handleCookies   = true;
  var epsc_objectBroker    = "/cgi-bin/epsc_broker.cgi";
  var xmlHttpReqs          = new Array();
  var reqQueue             = new Array();
  var updtQueue            = new Array(); //queue for objects to be updated
  var updtQueueMaxTries    = 10;
  var evalQueue            = new Array(); //queue for javascript evaluations
  var evalQueueMaxTries    = 10;
  var refreshQueue         = new Array(); //queue for refreshable sections
  var epsc_sessionName     = 'sessionID';
  var epsc_statusVisible   = true;
  var epsc_statusRefresh   = true;
  var epsc_statusStyle     = 'background-color:#ff0000; color:white; border:1px solid #00cc00; padding:0.2em; position:absolute; top: 0.3em; right: 0.3em;';
  var epscWatchIds         = new Array("epscXML");
  var epscCacheSize        = 2000000;
  var epscCache            = new Array();
  
  function getSlot(reqId) {
    for (i = 0; i < xmlHttpReqs.length; i++) {
      if (xmlHttpReqs[i].id == reqId) return xmlHttpReqs[i];
    }
    return false;
  }
 /* 
  function queue_item(fn, url, callback, args, enqueueing_type, enqueueing_val) {
    this.fn              = fn;
    this.url             = url;
    this.callback        = callback;
    this.args            = args;
    this.enqueueing_type = enqueueing_type;
    this.enqueueing_val  = enqueueing_val;
    / *
    if ((typeof(allow_enqueueing) != 'undefined')||(allow_enqueueing != null)) {
      this.allow_enqueueing = allow_enqueueing;
    } else {
      this.allow_enqueueing = -1;
    }
    * /
  }
  function refreshable_item(period, url, target, property) {
    this.period    = period; //Notice: period is in seconds!!
    this.last_updt = (new Date()).getTime();
    this.url       = url;
    this.target    = target;
    this.property  = property;
  }
*/
  
  function refreshableEnqueue(period, url, target, property) {
    //check if exists
    var exists = -1;
    for (i = 0; i < refreshQueue.length; i++) {
      if ((period == refreshQueue[i].period)&&(refreshQueue[i].url == url)&&(refreshQueue[i].target == target)&&(refreshQueue[i].property == property)) {
        exists = i;
      }
    }
    //ads refresheable update to the refreshQueue queue.
    if (exists < 0) {
      var item = new refreshable_item(period, url, target, property);
      refreshQueue.push(item);
    }
  }
  
  function refreshableProcess() {
    for (i = 0; i < refreshQueue.length; i++) {
      if ((eval("refreshQueue[i].url"))&&(refreshQueue[i].period)) {
        var periodms  = refreshQueue[i].period*1000;
        var time_diff = refreshQueue[i].last_updt + periodms - (new Date()).getTime();
        if (time_diff < 0) {
          refreshQueue[i].last_updt = (new Date()).getTime();
          if (refreshQueue[i].target != null) {
            Get(refreshQueue[i].url, this.UpdateIdWithURL, refreshQueue[i].target + epsc_separator + refreshQueue[i].property);
          } else {
            Get(refreshQueue[i].url);
          }
        } else {
          if ((epsc_statusVisible)&&(epsc_statusRefresh)&&(time_diff > 1)) {
            var seconds = Math.round(time_diff/1000);
            updateElement(null, 'epscRefresh', 'Refresh in ' + seconds + "s", epsc_statusStyle);
          }
        }
      }
    }
  }
  
  function refreshableClear() {
    if ((epsc_statusVisible)&&(epsc_statusRefresh)) removeElement(null, 'epscRefresh');
    refreshQueue = new Array();
  }
  
  function Create() {
    xmlHttpObj = false;
    try {
      xmlHttpObj = new XMLHttpRequest();
    } catch (trymicrosoft) {
      try {
        xmlHttpObj = new ActiveXObject("Msxml2.XMLHTTP");
    }   catch (othermicrosoft) {
        try {
          xmlHttpObj = new ActiveXObject("Microsoft.XMLHTTP");
        } catch (failed) {
          xmlHttpObj = false;
          alert("Unable to create XMLHttpRequest object");
        }
      }
    }
    return xmlHttpObj;
  }
  
  function Initialize() {
    if (epsc_initialized == true) return epsc_initialized;
  
    try {
      netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");
    } catch (e) {
      epsc_remotereqs = false;
    }
  
    try {
      netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
    } catch (e) {
      //alert("File upload not permitted." + e);
    }
  
    epsc_initialized = true;
    queueMonitor();
    LifecycleCheck();
    return true;
  }
  
  function ReqEnqueue(fn, url, callback, args, enqueueing_type, enqueueing_val) {
    var item = new queue_item(fn, url, callback, args, enqueueing_type, enqueueing_val);
    reqQueue.push(item);
  }
  
  function ReqDequeue() {
    if (reqQueue.length < 1) return false;
    var item = reqQueue.shift();
    var fn   = item.fn;
    var pfunc= null;
    if (typeof(fn) == "string") pfunc = eval(fn);
    if (fn != null)             pfunc = fn;
    if (pfunc == null)          pfunc = Get;
    pfunc(item.url, item.callback, item.args, item.enqueueing_type, item.enqueueing_val);
  }
  
  function UpdtEnqueue(objId, objProp, objContent, displayOrder, displayMode) {
    var exists = -1;
    if (displayMode == null) {
      displayMode = "change";
    }
    for (i = 0; i < updtQueue.length; i++) {
      if ((objId == updtQueue[i].objId)&&(displayOrder == updtQueue[i].displayOrder)) {
        exists = i;
      }
    }
    if (exists < 0) {
      var item = new updt_item(objId, objProp, objContent, displayOrder, displayMode);
      updtQueue.push(item);
    } else {
      var item = updtQueue[exists];
      if (item.tries >= updtQueueMaxTries) {
        updtQueue.splice(exists,1);
      }
    }
  }
  
  function UpdtObj() {
    if (updtQueue.length < 1) return false;
    var items = updtQueue.sort(sortUpdtObj);
    var sorted = false;
    //select item
    for (i = 0; i < items.length; i++) {
      if (sorted == false) {
        if (items[i].displayOrder > 0) {
          items[i].sortable     = true;
          items[i].displayOrder = 0;
          sorted = true;
        }
      }
      if ((items[i].sortable)&&(items[i].displayOrder == 0)) {
        sorted = true;
      }
    }
  
    //display
    for (i = 0; i < items.length; i++) {
      if (items[i].updated == false) {
        if (items[i].displayOrder == 0) {
          items[i].tries  += 1;
          if (this.SetObjProp(items[i].objId, items[i].objProp, items[i].objContent, items[i].displayOrder, items[i].displayMode)) {
            items[i].updated = true;
          }
        } //end of if item.displayOrder == 0
      } //end of if updated == false
    }
  
    //cleanup
    updtQueue = new Array();
    for (i = 0; i < items.length; i++) {
      if ((items[i].updated == false)&&(items[i].tries < updtQueueMaxTries)) updtQueue.push(items[i]);
    }
  }
  /*
  function UpdtObj() {
    if (updtQueue.length < 1) return false;
    for (i = 0; i < updtQueue.length; i++) {
      var item = updtQueue[i];
    //  var item = updtQueue.sort(sortUpdtObj)
      if (item.tries < updtQueueMaxTries) {
        if (epscSetObjProp(item.objId, item.objProp, item.objContent, item.displayOrder, item.displayMode)) {
          updtQueue.splice(i,1);
          return epscUpdtObj();
        }
      } else {
        updtQueue.splice(i,1);
        return epscUpdtObj();
      }
      item.tries += 1;
    }
    return true;
  }
  */
  function EvalEnqueue(evalStr) {
    var exists = -1;
    for (i = 0; i < evalQueue.length; i++) {
      if (evalStr == evalQueue[i].evalStr) {
        exists = i;
      }
    }
    if (exists < 0) {
      var item = new eval_item(evalStr);
      evalQueue.push(item);
    } else {
      var item = evalQueue[exists];
      if (item.tries >= evalQueueMaxTries) {
        evalQueue.splice(exists,1);
      }
    }
  }
  
  function EvalObj() {
    if (evalQueue.length < 1) return false;
    for (i = 0; i < evalQueue.length; i++) {
      var item = evalQueue[i];
      if (item.tries < evalQueueMaxTries) {
        if (EvalJS(item.evalStr)) {
          evalQueue.splice(i,1);
          return EvalObj();
        }
      } else {
        evalQueue.splice(i,1);
        return EvalObj();
      }
      item.tries += 1;
    }
    return true;
  }
  
  function Reserve() {
    epsc_connId++;
    var _slot = new slot(epsc_connId);
    if (epsc_statusVisible) {
      removeElement(null, 'epscRefresh');
      updateElement(null, 'epscStatus', 'Loading ....', epsc_statusStyle);
    }
    xmlHttpReqs.push(_slot);
    return _slot;
  }
  
  function Release(req) {
    for (var i = 0; i < xmlHttpReqs.length; i++) {
      if (req.id == xmlHttpReqs[i].id) {
        if ((epsc_statusVisible)&&(xmlHttpReqs.length <= 1)) {
          removeElement(null, 'epscRefresh');
          removeElement(null, 'epscStatus');
        }
        xmlHttpReqs.splice(i,1);
        return true;
      }
    }
    return false;
  }
  
  function scriptName(url) {
    var string = unescape(escape(url));
    var parts  = string.split(server_qsSeparator);
    if (parts[0]) return parts[0];
    return url;
  }
  
  function processHeaders(headers) {
    var lines      = headers.split(/\r?\n/);
    var in_cookies = false;
    for (i = 0; i < lines.length; i++) {
      if (lines[i].match(/set-cookie:\ +?/i)) {
        in_cookies = true
        var pair = lines[i].split(/^set-cookie:\ +/i);
        document.cookie = pair[1];
      } else {
        if (lines[i].match(/[a-z\-_]+:/i)) {
          in_cookies = false;
        }
        if (in_cookies) {
          document.cookie = lines[i];
        }
      }
    }
  }
  
  function validRequest(url, enqueueing_type, enqueueing_val) {
    /*
      0 - only one request (script name)
      1 - only one request with same arguments (url)
      2 - allow enqueueing_val requests (script name)
      3 - allow enqueueing_val requests (url)
      4 - allow any number of requests
      5 - load only if enqueueing_val script is not in process
      6 - load only if enqueueing_val url is not in process
      666 - invalid request!
    */
  
    if (url.length == 0) return 666;
  
    var scriptname   = scriptName(url);
    var scriptcount  = 0;
    var urlcount     = 0;
    var scriptcountq = 0;
    var urlcountq    = 0;
    var reqOk        = 0;
    for (i = 0; i < xmlHttpReqs.length; i++) {
      if ((url == xmlHttpReqs[i].url)&&(xmlHttpReqs[i].state != 0)) urlcount++;
      if ((scriptname == scriptName(xmlHttpReqs[i].url))&&(xmlHttpReqs[i].state != 0)) scriptcount++;
    }
  
    for (i = 0; i < reqQueue.length; i++) {
      if (url == reqQueue[i].url) urlcountq++;
      if (scriptname == scriptName(reqQueue[i].url)) scriptcountq++;
    }
  
    switch (enqueueing_type) {
      case 0:
        scriptcount += scriptcountq;
        if (scriptcount == 0) reqOk = 1;
        break;
      case 1:
        urlcount += urlcountq;
        if (urlcount == 0) reqOk = 1;
        break;
      case 2:
        scriptcount += scriptcountq;
        if (scriptcount <= enqueueing_val) reqOk = 1;
        break;
      case 3:
        urlcount += urlcountq;
        if (urlcount <= enqueueing_val) reqOk = 1;
        break;
      case 4:
        reqOk = 1;
        break;
      case 5:
        reqOk = 2;
        break;
      case 6:
        if ((urlcount > 0)||(scriptcount > 0)) {
          reqOk = 2;
        } else {
          reqOk = 1;
        }
        break;
      default:
        reqOk = 1;
    }
  //document.getElementById('debug_nfo').innerHTML = "<textarea cols=100 rows=20>" + enqueueing_type + "--" + reqOk + "</textarea>";
    return reqOk;
  }
  
  function epsc(method, url, callback, args, enqueueing_type, enqueueing_val) {}
  
  function Get(url, callback, args, enqueueing_type, enqueueing_val) {
    if (epsc_initialized) {
      var req   = Reserve();
      var reqOk = true;
      var pfunc = null;
      var count = 0;
      if (typeof(callback) == "string") pfunc = eval(callback);
      if (callback != null) pfunc = callback;
      if (pfunc == null) pfunc = Process;
      reqOk = validRequest(url, enqueueing_type, enqueueing_val);
      switch (reqOk) {
        case 1:
          if (req.state == 0) {
            try {
              req.timestart = (new Date()).getTime();
              req.ro.open("GET", url, true);
              req.ro.onreadystatechange = function () { pfunc(req, args) };
              req.ro.send(null);
              req.state     = 1;
              req.timeend   = req.timestart;
              req.url       = url;
            } catch (exception) {
              this.ReqEnqueue(Get, url, callback, args, enqueueing_type, enqueueing_val);
              this.Release(req);
            }
          } else {
            this.ReqEnqueue(Get, url, callback, args, enqueueing_type, enqueueing_val);
            this.Release(req);
          }
          break;
        case 2: //dependency in progress; enqueue!
          this.ReqEnqueue(Get, url, callback, args, enqueueing_type, enqueueing_val);
          this.Release(req);
          break;
        default:
      }
    } else {
      this.Initialize();
      this.ReqEnqueue(Get, url, callback, args, enqueueing_type, enqueueing_val);
      this.Release(req);
    }
  }
  
  function Post(url, callback, args, enqueueing_type, enqueueing_val) {
    if (epsc_initialized) {
      var req   = Reserve();
      var reqOk = true;
      var pfunc = null;
      var count = 0;
      if (typeof(callback) == "string") pfunc = eval(callback);
      if (callback != null) pfunc = callback;
      if (pfunc == null) pfunc = epsc_defaultCallback;
      reqOk = this.validRequest(url, enqueueing_type, enqueueing_val);
      switch (reqOk) {
        case 1:
          if (req.state == 0) {
            try {
              req.timestart = (new Date()).getTime();
              req.ro.open("POST", url, true);
              req.ro.onreadystatechange = function () { pfunc(req, args) };
              req.ro.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
              req.ro.send(args);
              req.state     = 1;
              req.timeend   = req.timestart;
              req.url       = url;
            } catch (exception) {
alert("ola3" + exception);
              this.ReqEnqueue(this.Post, url, callback, args, enqueueing_type, enqueueing_val);
              this.Release(req);
            }
          } else {
            this.ReqEnqueue(this.Post, url, callback, args, enqueueing_type, enqueueing_val);
            this.Release(req);
          }
          break;
        case 2: //dependency in progress; enqueue!
          this.ReqEnqueue(this.Post, url, callback, args, enqueueing_type, enqueueing_val);
          this.Release(req);
          break;
        default:
      }
    } else {
      this.Initialize();
      this.ReqEnqueue(this.Post, url, callback, args, enqueueing_type, enqueueing_val);
      this.Release(req);
    }
  }
  
  function UpdateIdWithURL(req, argsString) {
    req.state = req.ro.readyState;
    if (req.ro.readyState == 4) {
      if (req.ro.status == 200) {
        processHeaders(req.ro.getAllResponseHeaders());
        var args       = argsString.split(epsc_separator);
        var objId      = args[0];
        var objProp    = (args[1])?args[1]:'innerHTML';
        var objContent = req.ro.responseText;
        SetObjProp(objId, objProp, objContent, 0, null);
      }
      Release(req);
    }
  }
  
  //key1=val1|key2=val2|key3=val3 ....
  function UpdateSelectBox(req, argsString) {
    req.state = req.ro.readyState;
    if (req.ro.readyState == 4) {
      if (req.ro.status == 200) {
        var args       = argsString.split(epsc_separator);
        var objId      = args[0];
        var format     = args[1];
            format     = format?format:'plain';
        var objContent = req.ro.responseText;
        var options    = objContent.split(/\n/);
        var selectbox  = document.getElementById(objId);
        while (selectbox.options.length > 0) {
          selectbox.options[0] = null;
        }
        for (i = 0; i < options.length; i++) {
          var pair = options[i].split(/=/);
          var key  = pair[0];
          var val  = pair[1];
          if (!val) val = key;
          var option = new Option(key, val);
          selectbox.options.add(option);
        }
      }
      this.Release(req);
    }
  }
  
  function GetObjProp(objId, objProp) {
    var value = null;
    try {
      value = eval("document.getElementById(\"" + objId + "\")." + objProp);
    } catch (exception) {
alert("ola5" + exception + " " + objProp + " " + objId);
      return null;
    }
    return value;
  }
  
  //review
  function SetObjProp(objId, objProp, objContent, displayOrder, displayMode) {
    var content = unescape(objContent);
    if (displayOrder > 0) {
      UpdtEnqueue(objId, objProp, objContent, displayOrder, displayMode);
      return false;
    }
  
    if (eval("document.getElementById(\"" + objId + "\")")) {
      if (displayMode == 'change') {
      } else if (displayMode == 'append') {
        content = GetObjProp(objId, objProp) + content;
      } else if (displayMode == 'prepend') {
        content = content + GetObjProp(objId, objProp);
      }
  
      eval("document.getElementById(\"" + objId + "\")." + objProp + " = content;");
      return true;
    } else {
      UpdtEnqueue(objId, objProp, objContent, displayOrder, displayMode);
    }
    return false;
  }
  
  function EvalJS(evalStr) {
    try {
      eval(evalStr);
      return true;
    } catch(exception) {
alert("olax" + exception);
      this.EvalEnqueue(evalStr);
    }
    return false;
  }
  
  function CheckDOM() {
    try {
      for (i = 0; i < epscWatchIds.length; i++) {
        var obj = document.getElementById(epscWatchIds[i]);
        if (obj.getAttribute('content').length > 0) {
          Parse(XMLLoadFromStr(obj.getAttribute('content')));
          obj.setAttribute('content', "");
        }
      }
    } catch (e) {
  
    }
  }
  
  function Parse(xmldoc) {
    var update   = xmldoc.getElementsByTagName("update");
    for (i = 0; i < update.length; i++) {
      var item = update.item(0);
      for (j = 0; j < item.childNodes.length; j++) {
        if (item.childNodes[j].nodeName == "section") {
          var listVars = new Array('url', 'urlclass', 'target', 'property', 'value', 'require', 'callback', 'mode', 'order', 'refresh');
          for (k = 0; k < listVars.length; k++) {
            eval("var section_" + listVars[k] + " = null"); 
            try {
              var varValue = item.childNodes[j].getElementsByTagName(listVars[k]).item(0).textContent?
                             item.childNodes[j].getElementsByTagName(listVars[k]).item(0).textContent:
                             item.childNodes[j].getElementsByTagName(listVars[k]).item(0).firstChild.data;
              if (varValue != null) eval("section_" + listVars[k] + " = varValue;");
            } catch (exceptionGetvars) {
              //alert("uink (" + listVars[k] + ") " + exceptionGetvars.message);
            }
          }
          if (section_urlclass == null) section_urlclass = 'html';
          if (section_mode     == null) section_mode     = 'change';
          if (section_property == null) section_property = 'innerHTML';
          if (section_order    == null) section_order    = 0;
          if (section_refresh  == null) section_refresh  = 0;
          if (section_require != null) this.LoadJS(section_require);
          if (section_url != null) {
            section_url = unescape(section_url); //weird shit
            if (section_callback == null) {
              if (section_urlclass == "html") Get(unescape(section_url), UpdateIdWithURL, section_target + epsc_separator + section_property + epsc_separator + section_mode);
              if (section_urlclass == "xml") Get(unescape(section_url), null, section_target + epsc_separator + section_property);
            } else {
              Get(unescape(section_url), section_callback, section_target + epsc_separator + section_property + epsc_separator + section_mode);
            }
          }
          if (section_value != null) {
            if (section_callback == null) {
              SetObjProp(section_target, section_property, section_value, section_order, section_mode);
            } else {
              pfunc = eval(section_callback);
              pfunc(unescape(section_value));
            }
          }
          //review: only works with urls
          if (section_refresh > 0) {
            if (section_url != null) {
              refreshableEnqueue(section_refresh, section_url, section_target, section_property);
            }
          }
        }
      }
    }
    //<onload> section!
    var onload   = xmldoc.getElementsByTagName("onload");
    for (i = 0; i < onload.length; i++) {
      var item = onload.item(0);
      for (j = 0; j < item.childNodes.length; j++) {
        if (item.childNodes[j].nodeName == "get") {
          var get_url       = item.childNodes[j].getElementsByTagName('url').item(0)?
                              item.childNodes[j].getElementsByTagName('url').item(0).firstChild.data:null;
          var get_callback  = item.childNodes[j].getElementsByTagName('callback').item(0)?
                              item.childNodes[j].getElementsByTagName('callback').item(0).firstChild.data:null;
          //epscGet(unescape(get_url), get_callback, null, 6, get_url);
          this.ReqEnqueue(Get, get_url, get_callback, null, 6, req.url); //review!!
        }
      }
    }
    //<eval> section
    var evallst  = xmldoc.getElementsByTagName("eval");
    for (i = 0; i < evallst.length; i++) {
      //javascript evaluations
      try {
        var jsstr = "";
        for (j = 0; j < evallst[i].getElementsByTagName('js')[0].childNodes.length; j++) {
          //epscEvalJS(unescape(evallst[i].getElementsByTagName('js')[0].childNodes[j].data));
          //jsstr = jsstr + decodeURIComponent(evallst[i].getElementsByTagName('js')[0].childNodes[j].data);
          jsstr = jsstr + evallst[i].getElementsByTagName('js')[0].childNodes[j].data;
        }
        EvalJS(unescape(jsstr));
      } catch (eval_exception) {
      }
    }
  }
  
  function Process(req, args) {
    req.state = req.ro.readyState;
    if (req.ro.readyState == 4) {
      refreshableClear();
      try {
        if (req.ro.status == 200) {
          if (epsc_handleCookies) 
            processHeaders(req.ro.getAllResponseHeaders());
          var isXml    = false;
          var text     = req.ro.responseText;
          if (text.match(/xml version/)) isXml = true;
          if (isXml) {
            //var xmldoc   = req.ro.responseXML;
            //<update> section!
            Parse(req.ro.responseXML);
          } else {//no XML
            if (eval("document.getElementById(\"" + args + "\")")) {
              SetObjProp(args, 'innerHTML', text, 0, null);
            } else {
              //updateElement(container, name, html, style)
              updateElement(null, 'staticContent', text, "");
            }
          }
        } else {
          //error - status unexpected
        }
      } catch (exception) {
alert('ola1' + exception);
        //error accessing object status - FAILED TO PUT CONTENT THERE!?
        //return 0;
        //alert(exception);
      }
      Release(req);
    }
  
  }
  
  //MARTELO!!! review - review - review - review - review - review
  function WrapVars(str) {
    if (!str.match("|")) {
      str += "|";
    }
    var keys   = str.split("|");
        keys.push(epsc_sessionName);
    var pairs  = new Array();
    var regexp = /([a-z0-9_]+)=(.*)/i;
    for (var i = 0; i < keys.length; i++) {
      var value = null;
      if (regexp.test(keys[i])){
        var pair = regexp.exec(keys[i]);
        keys[i] = pair[pair.length - 2];
        value   = pair[pair.length - 1];
      } else {
        /*
        try {
          if (document.getElementById(keys[i]).nodeName.match(/^select$/i)) {
            for (k = 0; k < document.getElementById(keys[i]).childNodes.length; k++) {
              var option = document.getElementById(keys[i]).childNodes[k].nodeName;
              if (option.match(/^option$/i)) {
                var selected   = document.getElementById(keys[i]).childNodes[k].selected;
                var localValue = document.getElementById(keys[i]).childNodes[k].value;
                if (selected == true) pairs.push(keys[i] + "=" + localValue);
              }
            }
          } else {
            value = document.getElementById(keys[i]).value;
          }
        } catch (exceptionField) {
          try {
            value = cookieRead(keys[i]);
          } catch (exceptionCookie) {
  
          }
        }
        */
        try {
          value = cookieRead(keys[i]);
        } catch (exceptionCookie) {
  
        }
      }//end of if regexp.test
  
      if (value == null) {
        try {
          var formItems = Array('input','textarea','select');
          for (h = 0; h < formItems.length; h++) {
            var formItem = formItems[h];
            var itemList;
            try {
              itemList = document.getElementById(keys[i]).getElementsByTagName(formItem); //all items inside a form with the given tagname
            } catch (exceptionNotAForm) {
              itemList = document.getElementsByTagName(formItem); //all items by tagname
            }
            if (itemList.length == 0) { //try grabbing if no items are found in the form
              itemList = document.getElementsByTagName(formItem); //all items by tagname
            }
            for (j = 0; j < itemList.length; j++) {
              var nodeName   = itemList[j].nodeName;
              var itemName   = itemList[j].name;
              var itemValue  = escape(itemList[j].value);
              if (itemList[j].type == 'checkbox') {
                if (itemList[j].checked != true) itemValue = "";
              }
              if (itemList[j].type == 'radio') {
                if (itemList[j].checked != true) itemValue = "";
              }
              if ((nodeName.match(/^input$/i))||(nodeName.match(/^textarea$/i))) {
                if (itemValue != "") {
                  if (!element_exists(pairs, itemName + "=" + itemValue)) pairs.push(itemName + "=" + itemValue);
                  //if ((itemList[j].type == 'text')||(itemList[j].type == 'button')||(nodeName.match(/^textarea$/i))) {
                  //} else {
                  //  pairs.push(itemName + "=" + itemValue);
                  //}
                }
              } else if (nodeName.match(/^select$/i)) {
                var optionList = itemList[j].getElementsByTagName('option');
                for (k = 0; k < optionList.length; k++) {
                  var selected   = optionList[k].selected;
                  var localValue = optionList[k].value;
                  if ((selected == true)&&(!element_exists(pairs, itemName + "=" + localValue))) pairs.push(itemName + "=" + localValue);
                }
              } else {
                //handle other types
              }
            }
          }
        } catch (exceptionForm) {
          alert("Exception: " + exceptionForm.message);
        }
      }
  
      if ((typeof(value) != 'undefined')&&(value != null)&&(value != "")) {
        if (!element_exists(pairs, keys[i] + "=" + value)) pairs.push(keys[i] + "=" + value);
      } else {
        pairs.push("_undefined_" + keys[i] + "=" + value);
      }
    }
    return pairs.join("&");
  }
  
  function queueMonitor() {
    UpdtObj(); //check for objects that failed to update
    EvalObj(); //check for eval code that did not run yet
    ReqDequeue();  //check for requests pending
    if ((reqQueue.length > 0)||(updtQueue.length > 0)) {
      setTimeout(queueMonitor,100);
    } else {
      setTimeout(queueMonitor,500);
    }
  }
  
  function LifecycleCheck() {
    var timenow = (new Date()).getTime();
    var count   = 0;
    for (var i = 0; i < xmlHttpReqs.length; i++) {
      if (xmlHttpReqs[i].state != 0) count++;
    }
  
    for (var i = 0; i < xmlHttpReqs.length; i++) {
      //cleans requests working for more than epsc_requestTimeout
      if (((timenow - xmlHttpReqs[i].timestart > epsc_requestTimeout)&&(xmlHttpReqs[i].state != 0))||(xmlHttpReqs[i].timestart < 1)) {
        Release(this.getSlot(xmlHttpReqs[i].id));
      }
    }
  
    refreshableProcess();
    CheckDOM();
    setTimeout(LifecycleCheck,1000);
  }
  
  //framework functions
  //onload=epscStart;
  function Start(url) {
    this.Initialize();
    if ((typeof(url) != 'undefined')||(url != null)) {
      this.Get(url, null, 0);
    } else {
      this.Get(epsc_startupUrl, null, 0);
    }
  }
  /*
  function CreateElement(object) {
    if (epscLibLoaded(url)) return true;
    var e      = document.createElement("epscobj");
    e.name     = object.name;
    e.instance = object;
    document.getElementsByTagName("head")[0].appendChild(e);
  }
  
  function ElementExists {
  
  }
  */
  function LoadJS(url) {
    if (this.LibLoaded(url)) return true;
    var e = document.createElement("script");
    e.src = url;
    e.type="text/javascript";
    document.getElementsByTagName("head")[0].appendChild(e);
  }
  
  function LibLoaded(lib) {
    var head = document.getElementsByTagName("script");
    for (i = 0; i < head.length; i++) {
      if (head[i].src.indexOf('/' + lib) >= 0) return true;
    }
  }
  
  //DUMP AND DEBUG STUFF!
  function dumpState(reqId) {
    var dumpTxt       = "<b>Pool slots state and info.</b><br>";
    var dumpObjDetail = "<table cellpadding=0 cellspacing=2 border=0 width=100%>";
    var dumpObjState  = "<table cellpadding=2 cellspacing=2 border=0 width=100%><tr>";
    var sbgcolor;
    for (var i = 0; i < xmlHttpReqs.length; i++) {
      sbgcolor       = (xmlHttpReqs[i].state == 0)?'#00ff00':
                       (xmlHttpReqs[i].state == 1)?'#cc0000':
                       (xmlHttpReqs[i].state < 4)?'#cccc00':
                       '#cc0000';
      dumpObjState  += "<td align=center bgcolor=" + sbgcolor + ">(" + xmlHttpReqs[i].state + ")</td>";
      dumpObjDetail += "<tr>";
      dumpObjDetail += "<td><b>" + i + "</b></td>";
      dumpObjDetail += "<td>url:" + xmlHttpReqs[i].url + "</td>";
      dumpObjDetail += "<td>state:" + xmlHttpReqs[i].state + "</td>";
      dumpObjDetail += "<td>id:" + xmlHttpReqs[i].id + "</td>";
      dumpObjDetail += "<td>timestart:" + xmlHttpReqs[i].timestart + "</td>";
      dumpObjDetail += "<td>elapsed:" + xmlHttpReqs[i].elapsed() + "</td>";
      dumpObjDetail += "</tr>";
      //dumpTxt = dumpTxt + " -" + xmlHttpReqs[i].elapsed() + "\n";
      //dumpTxt = dumpTxt + " -" + xmlHttpReqs[i].url + "\n";
    }
    dumpObjState  += "</tr></table>";
    dumpObjDetail += "</table>";
    dumpTxt += "<table>";
    dumpTxt += "<tr><td bgcolor=#aaaaaa>" + dumpObjState + "</td></tr>";
    dumpTxt += "<tr><td>" + dumpObjDetail + "</td></tr>";
    dumpTxt += "</table>";
    return dumpTxt;
  }
  
  function dumpQueue() {
    var dumpTxt = "";
    for (var i = 0; i < evalQueue.length; i++) {
      dumpTxt = dumpTxt + "+ Queue(E): " + evalQueue[i].evalStr + " - " + evalQueue[i].tries + "\n";
    }
    for (var i = 0; i < updtQueue.length; i++) {
      dumpTxt = dumpTxt + "+ Queue(U): " + updtQueue[i].objId + " - " + updtQueue[i].tries + "\n";
    }
    for (var i = 0; i < reqQueue.length; i++) {
      dumpTxt = dumpTxt + "+ Queue(R): " + reqQueue[i].url + "(" + typeof(reqQueue[i].fn) + ") - " + reqQueue[i].enqueueing_type + "\n";
    }
    return dumpTxt;
  }


  /* methods */
this.getSlot = getSlot;
this.queue_item = queue_item;
this.refreshable_item = refreshable_item;
this.refreshableEnqueue = refreshableEnqueue;
this.refreshableProcess = refreshableProcess;
this.refreshableClear = refreshableClear;
this.Create = Create;
this.Initialize = Initialize;
this.ReqEnqueue = ReqEnqueue;
this.ReqDequeue = ReqDequeue;
this.UpdtEnqueue = UpdtEnqueue;
this.UpdtObj = UpdtObj;
this.EvalEnqueue = EvalEnqueue;
this.EvalObj = EvalObj;
this.Reserve = Reserve;
this.Release = Release;
this.scriptName = scriptName;
this.processHeaders = processHeaders;
this.validRequest = validRequest;
this.Get = Get;
this.Post = Post;
this.UpdateIdWithURL = UpdateIdWithURL;
this.UpdateSelectBox = UpdateSelectBox;
this.GetObjProp = GetObjProp;
this.SetObjProp = SetObjProp;
this.EvalJS = EvalJS;
this.CheckDOM = CheckDOM;
this.Parse = Parse;
this.Process = Process;
this.WrapVars = WrapVars;
this.queueMonitor = queueMonitor;
this.LifecycleCheck = LifecycleCheck;
this.Start = Start;
this.LoadJS = LoadJS;
this.LibLoaded = LibLoaded;
this.dumpState = dumpState;
this.dumpQueue = dumpQueue;
 
} // end of var vrajax = new function() {
  
  /**********************************************************/
  /**********************************************************/
  /************ Auxiliary Functions *************************/
  /**********************************************************/
  /**********************************************************/
  function trim(str) {
    var tmpstr = str.replace(/^\ +/, "");
    return tmpstr.replace(/\ +$/, "");
  }
  
  //http://www.quirksmode.org/js/cookies.html
  function cookieCreate(name,value,days) {
    if (days) {
      var date = new Date();
      date.setTime(date.getTime()+(days*24*60*60*1000));
      var expires = "; expires="+date.toGMTString();
    } else var expires = "";
    document.cookie = name+"="+value+expires+"; path=/";
  }
  
  function cookieRead(name) {
    var nameEQ = name + "=";
    var ca = document.cookie.split(';');
    for(var i=0;i < ca.length;i++) {
      var c = ca[i];
      while (c.charAt(0)==' ') c = c.substring(1,c.length);
      if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length);
    }
    return null;
  }
  
  function cookieErase(name) {
    cookieCreate(name,"",-1);
  }
  
  function updateElement(container, name, html, style) {
    try {
      if (document.getElementById(name).innerHTML) {
        document.getElementById(name).innerHTML = html;
      }
    } catch (exceptionNoDiv) {
      if (container == null) {
        container = document.body;
      }
      removeElement(container, name); //make sure the object was deleted
      var div = document.createElement('div');
      div.setAttribute('style', style);
      try { //Opera workaround (b_ie4 is true in opera)
        if (b_ie4) div.style.setAttribute('cssText', style);
      } catch (exceptionSetAttr) {}
      div.id = name;
      div.innerHTML = html;
      container.appendChild(div);
    }
  }
  
  function removeElement(container, ID) {
    try {
      if (container == null) {
        container = document.body;
      }
      var element = document.getElementById(ID);
      container.removeChild(element);
    } catch (e) {}
  }
  
  function nop() {}
  
  /**
   * based on: http://www.webreference.com/programming/javascript/definitive2/index.html
   * Create a new Document object. If no arguments are specified,
   * the document will be empty. If a root tag is specified, the document
   * will contain that single root tag. If the root tag has a namespace
   * prefix, the second argument must specify the URL that identifies the
   * namespace.
   */
  function XMLNewDocument(rootTagName, namespaceURL) {
    if (!rootTagName) rootTagName = "";
    if (!namespaceURL) namespaceURL = "";
    if (document.implementation && document.implementation.createDocument) {
      // This is the W3C standard way to do it
      return document.implementation.createDocument(namespaceURL, rootTagName, null);
    }
    else { // This is the IE way to do it
      // Create an empty document as an ActiveX object
      // If there is no root element, this is all we have to do
      var doc = new ActiveXObject("MSXML2.DOMDocument");
      // If there is a root tag, initialize the document
      if (rootTagName) {
        // Look for a namespace prefix
        var prefix = "";
        var tagname = rootTagName;
        var p = rootTagName.indexOf(':');
        if (p != -1) {
          prefix = rootTagName.substring(0, p);
          tagname = rootTagName.substring(p+1);
        }
        // If we have a namespace, we must have a namespace prefix
        // If we don't have a namespace, we discard any prefix
        if (namespaceURL) {
          if (!prefix) prefix = "a0"; // What Firefox uses
        }
        else prefix = "";
        // Create the root element (with optional namespace) as a
        // string of text
        var text = "<" + (prefix?(prefix+":"):"") +  tagname +
            (namespaceURL
             ?(" xmlns:" + prefix + '="' + namespaceURL +'"')
             :"") +
            "/>";
        // And parse that text into the empty document
        doc.loadXML(text);
      }
      return doc;
    }
  }
  
  function XMLLoadFromURL(url) {
      // Create a new document with the previously defined function
      var xmldoc = XMLNewDocument();
      xmldoc.async = false;  // We want to load synchronously
      xmldoc.load(url);      // Load and parse
      return xmldoc;         // Return the document
  }
  
  /**
   * Parse the XML document contained in the string argument and return
   * a Document object that represents it.
   */
  function XMLLoadFromStr(text) {
      if (typeof DOMParser != "undefined") {
          // Mozilla, Firefox, and related browsers
          return (new DOMParser()).parseFromString(text, "application/xml");
      }
      else if (typeof ActiveXObject != "undefined") {
          // Internet Explorer.
          var doc = XMLNewDocument();  // Create an empty document
          doc.loadXML(text);            // Parse text into it
          return doc;                   // Return it
      }
      else {
          // As a last resort, try loading the document from a data: URL
          // This is supposed to work in Safari. Thanks to Manos Batsis and
          // his Sarissa library (sarissa.sourceforge.net) for this technique.
          var url = "data:text/xml;charset=utf-8," + encodeURIComponent(text);
          var request = new XMLHttpRequest();
          request.open("GET", url, false);
          request.send(null);
          return request.responseXML;
      }
  }