/*****************************************************
  Initialize function
  Browser Detection
  Language: German locale
*****************************************************/
NS4      = (document.layers) ? true:false;
IE4      = (document.all) ? true:false;
W3C      = (document.documentElement && !document.all) ? true:false;
MAXINT   = Math.pow(2,31);
MAXFLOAT = Math.pow(2,63);

/*****************************************************
  Initialize function
  Event capturing for Netscape
*****************************************************/
if (NS4) {
  document.captureEvents(Event.KEYPRESS);
  document.onkeypress = processKey;
}
if (W3C) {
  document.addEventListener("keypress",processKey,true);
}

//------------------------------------------------
function SetRecSecure(p_lUserId) {
//------------------------------------------------
  if ( document.getElementById('xSetRights').checked == true ) {
    document.getElementById('lownerid').value = p_lUserId;
    document.getElementById('leditid').value = p_lUserId;
    document.getElementById('lviewid').value = p_lUserId;
  } else {
    document.getElementById('lownerid').value = '-1';
    document.getElementById('leditid').value = '-1';
    document.getElementById('lviewid').value = '-1';
  }
}

//------------------------------------------------
function MultiselectFilter(that,p_strName) {
//------------------------------------------------
  l_objLeftBox  = document.getElementById("Left_"+p_strName);
  l_objRightBox = document.getElementById("Right_"+p_strName);
  if (typeof l_objLeftBox  != "object") return false;
  if (typeof l_objRightBox != "object") return false;
  l_arrSelected  = document.getElementById(p_strName).value.split('|');
  l_objAvailable = document.getElementById('hidden_'+p_strName)

  while ( l_objLeftBox.options[0] != null ) {
    l_objLeftBox.options[l_objLeftBox.options.length-1] = null;
  }

  l_strSearch = that.value;

  l_strSearch = l_strSearch.replace(/\\/gi,"\\\\");
  l_strSearch = l_strSearch.replace(/\./gi,"\\.");
  l_strSearch = l_strSearch.replace(/\*/gi,"\\*");
  l_strSearch = l_strSearch.replace(/\+/gi,"\\+");
  l_strSearch = l_strSearch.replace(/\?/gi,"\\?");
  l_strSearch = l_strSearch.replace(/\//gi,"\\/");
  l_strSearch = l_strSearch.replace(/\[/gi,"\\[");
  l_strSearch = l_strSearch.replace(/\]/gi,"\\]");
  l_strSearch = l_strSearch.replace(/\{/gi,"\\{");
  l_strSearch = l_strSearch.replace(/\}/gi,"\\}");
  l_strSearch = l_strSearch.replace(/\(/gi,"\\(");
  l_strSearch = l_strSearch.replace(/\)/gi,"\\)");

  if ( l_strSearch == "" ) l_strSearch = ".";

  l_RX = eval("/"+l_strSearch+"/i");

  for ( var i=0; i < l_objAvailable.options.length; i++ ) {
    l_objAvailable.options[i].setAttribute("isSelected", "false");
  }

  if ( l_arrSelected.length > 0 ) {
    while ( l_strEntry = l_arrSelected.shift() ) {
      for ( var i=0; i < l_objAvailable.options.length; i++ ) {
        if ( l_objAvailable.options[i].value == l_strEntry ) {
          l_objAvailable.options[i].setAttribute("isSelected", "true");
        }
      }
    }
  }

  for ( var i=0; i < l_objAvailable.options.length; i++ ) {
    if ( l_objAvailable.options[i].getAttribute("isSelected") != "true" ) {
      if ( l_RX.test(l_objAvailable.options[i].text) ) {
        l_objLeftBox.options[l_objLeftBox.options.length] = new Option(l_objAvailable.options[i].text,l_objAvailable.options[i].value);
      }
    }
  }
}


//------------------------------------------------
// ** ix2005 -> Calc scriptcode
//------------------------------------------------
var Calculations = new Array();

Calculations.Add = function(p_strField1, p_strField2, p_strTarget, p_lOperator) {
  var i = Calculations.length;
  Calculations[i] = new Calculation(p_strField1, p_strField2, p_strTarget, p_lOperator);
  return i;
}

function Calculation(p_strField1, p_strField2, p_strTarget, p_lOperator) {
  this.Field1             = document.getElementById(p_strField1);
  this.Field1.ixType      = document.getElementById(p_strField1).getAttribute('ixType');
  this.Field1.ixPrecision = document.getElementById(p_strField1).getAttribute('ixPrecision');
  this.Field1.ixGrouping  = document.getElementById(p_strField1).getAttribute('ixGrouping');

  if ( document.getElementById(p_strField2) ) {
    this.Field2             = document.getElementById(p_strField2);
    this.Field2.ixType      = document.getElementById(p_strField2).getAttribute('ixType');
    this.Field2.ixPrecision = document.getElementById(p_strField2).getAttribute('ixPrecision');
    this.Field2.ixGrouping  = document.getElementById(p_strField2).getAttribute('ixGrouping');
  } else {
    this.Field2 = new String();
    this.Field2.value = toLocalFloatString(p_strField2, 6, true, g_strDecimalSymbol, g_strDecimalGroupingSymbol)
    this.Field2.ixType      = "UPFLOAT";
    this.Field2.ixPrecision = 6;
    this.Field2.ixGrouping  = -1;
  }

  this.Target             = document.getElementById(p_strTarget);
  this.Target.ixType      = document.getElementById(p_strTarget).getAttribute('ixType');
  this.Target.ixPrecision = document.getElementById(p_strTarget).getAttribute('ixPrecision');
  this.Target.ixGrouping  = document.getElementById(p_strTarget).getAttribute('ixGrouping');

  this.ixOperator         = new Number(p_lOperator);
}

function Calculate() {
  if ( Calculations.length == 0 ) return;
  var l_lTemp = 0;
  for ( var i=0; i < Calculations.length; i++ ) {
    switch ( parseInt(Calculations[i].ixOperator) ) {
      case 0: // addition
        l_lTemp = parseFloat(toFloat(Calculations[i].Field1.value, Calculations[i].Field1.ixType)) + parseFloat(toFloat(Calculations[i].Field2.value, Calculations[i].Field2.ixType));
        l_lTemp = Math.round(l_lTemp* 1000000) / 1000000
        Calculations[i].Target.value = toLocalFloatString(l_lTemp, Calculations[i].Target.ixPrecision, true, g_strDecimalSymbol, g_strDecimalGroupingSymbol);
      break;

      case 1: // subtraction
        l_lTemp = parseFloat(toFloat(Calculations[i].Field1.value, Calculations[i].Field1.ixType)) - parseFloat(toFloat(Calculations[i].Field2.value, Calculations[i].Field2.ixType));
        l_lTemp = Math.round(l_lTemp* 1000000) / 1000000
        Calculations[i].Target.value = toLocalFloatString(l_lTemp, Calculations[i].Target.ixPrecision, true, g_strDecimalSymbol, g_strDecimalGroupingSymbol);
      break;

      case 2: // multiply
        l_lTemp = parseFloat(toFloat(Calculations[i].Field1.value, Calculations[i].Field1.ixType)) * parseFloat(toFloat(Calculations[i].Field2.value, Calculations[i].Field2.ixType));
        l_lTemp = Math.round(l_lTemp* 1000000) / 1000000
        Calculations[i].Target.value = toLocalFloatString(l_lTemp, Calculations[i].Target.ixPrecision, true, g_strDecimalSymbol, g_strDecimalGroupingSymbol);
      break;

      case 3: // divide
        if ( parseFloat(toFloat(Calculations[i].Field2.value, Calculations[i].Field2.ixType)) == 0 ) break; // don't divide by zero!!!
        l_lTemp = parseFloat(toFloat(Calculations[i].Field1.value, Calculations[i].Field1.ixType)) / parseFloat(toFloat(Calculations[i].Field2.value, Calculations[i].Field2.ixType));
        l_lTemp = Math.round(l_lTemp* 10000000) / 10000000
        Calculations[i].Target.value = toLocalFloatString(l_lTemp, Calculations[i].Target.ixPrecision, true, g_strDecimalSymbol, g_strDecimalGroupingSymbol);
      break;

      default: // error
        alert("unknown operator, calculation aborted!!!");
      break;
    }

    switch ( Calculations[i].Target.ixType ) {
      case "UPCurrency":
        ValidateCurrency(Calculations[i].Target, parseFloat(Calculations[i].Target.ixPrecision), parseFloat(Calculations[i].Target.ixGrouping));
      break;

      case "UPFloat":
        ValidateFloat(Calculations[i].Target, parseFloat(Calculations[i].Target.ixPrecision), parseFloat(Calculations[i].Target.ixGrouping));
      break;

      case "UPSignedInteger":
        ValidateInteger(Calculations[i].Target, parseFloat(Calculations[i].Target.ixGrouping));
      break;
    }
  }
}

//------------------------------------------------
function SwitchMLControl(p_oSelect,p_strField,p_lLCID) {
//------------------------------------------------
  for(i=0;i < p_oSelect.options.length;i++) {
    document.getElementById('ML' + p_strField + '_' + p_oSelect.options[i].value).style.display = 'none';
  }
  document.getElementById('ML' + p_strField + '_' + p_lLCID).style.display = 'block';
}

//------------------------------------------------
function swapimg(oImg, sSearchFor, sReplace, sCursorStyle) {
//------------------------------------------------
  var strSrc = oImg.src.toLowerCase();
  var a=sSearchFor.toLowerCase();
  var b=sReplace.toLowerCase();
  var sC=sCursorStyle.toLowerCase();
  if (sC!='pointer' && sC!='hand') sC='pointer';
  if (IE4)
    if (sC=='pointer') sC='hand';
  strSrc = strSrc.replace(a,b);
  oImg.src=strSrc;
  oImg.style.cursor = sC;
}

/*****************************************************
  Function zum anzeigen des DatePickers
*****************************************************/
function GetDatepickerWindow(p_strFieldname,p_strType,p_strPath) {
  var l_lngPopupX;
  var l_lngPopupY;
  if(p_strPath == null ) {
    p_strPath = "../../../";
  }

  l_lngPopupX = Math.round(screen.width/3);
  l_lngPopupY = Math.round(screen.height/3);
  if (IE4) {
    l_lngPopupX = (window.event.screenX+10);
    l_lngPopupY = (window.event.screenY+10);
  }

  var l_objTargetField = eval("window.document.forms[0]." + p_strFieldname);
  var l_strUrl = p_strPath + "_UpInclude/script/UpCalendars/UpCalendarPicker.asp?rq_strFieldname=" + p_strFieldname;

  if (!p_strType) p_strType = "";
  l_strUrl += "&rq_strType="+p_strType+"&rq_binit=1";
  if (l_objTargetField && l_objTargetField.value!="") {
    if (p_strType == "datetime" && l_objTargetField.value.indexOf(' ')>-1) {
      l_strDate = l_objTargetField.value.substr(0,l_objTargetField.value.indexOf(' '))
      l_strTime = l_objTargetField.value.substr(l_objTargetField.value.indexOf(' ') + 1)
    }
    else {
      l_strDate = l_objTargetField.value;
      l_strTime = "";
    }
    l_strUrl += "&rq_strDate=" + l_strDate;
    l_strUrl += "&rq_strTime=" + l_strTime;
  }
  if (parent && parent.UpAppNav) {
    if (p_strType == "datetime") {
      parent.UpAppNav.wndPrint = window.open(l_strUrl,'wndPrint','width=180, height=192, resizable=NO, help=NO, status=NO, scroll=NO, scrollbars=NO, toolbar=NO, left=' + l_lngPopupX + ', top='+ l_lngPopupY);
    } else {
      parent.UpAppNav.wndPrint = window.open(l_strUrl,'wndPrint','width=180, height=165, resizable=NO, help=NO, status=NO, scroll=NO, scrollbars=NO, toolbar=NO, left=' + l_lngPopupX + ', top='+ l_lngPopupY);
    }
  }
}

//****************************************
// Initialize function: Detect if we are in an popup or not
// Generating a new Parameter
//****************************************
if(parent.window.name == "UpPopup") {
  l_strIsPopup = "&rq_bIsPopup=1";
} else {
  l_strIsPopup = "";
}

//****************************************
// Function to decide to Popup or not
//****************************************
function ButtonAction(p_strLink,p_bNewWindow) {
  if ( p_bNewWindow && window.name != "UpPopup" ) {
    loadPopup(p_strLink);
  } else {
    window.document.__UpForm.action = p_strLink;
    if ( typeof g_arrFK != "undefined" ) {
      if ( SubmitHandlerCrossRref() ) {
        document.forms[0].onsubmit(); // htmlArea3
        document.forms[0].submit();
      }
    } else {
      if ( !/[?&]rq_bDelete=1(?:&|$)/.test(p_strLink) ) {
        if ( ValidateFields(window.document.__UpForm) ) {
          document.forms[0].onsubmit();
          document.forms[0].submit();
        }
      } else {
        document.forms[0].onsubmit();
        document.forms[0].submit();
      }
    }
  }
  return;
}

//----------------------------------------------------
function loadPopup(p_strLink) {
//----------------------------------------------------
  if (parent.opener && l_bPopUpCustom) {
    parent.opener.top.wndPopUpPopUp = open("../../UpAppGlobal/popupframeset.asp?rq_strUrl=" + HexEncodeString(p_strLink),"UpPopupPopUp","resizable=yes,width=380,height=250,screenX=300,screenY=200");
    parent.opener.top.wndPopUpPopUp.focus();
    if(parent.opener.window.name != "UpPopupPopUp") ResetTimeout();
  } else {
    top.wndPopUp = open("../../UpAppGlobal/popupframeset.asp?rq_strUrl=" + HexEncodeString(p_strLink),"UpPopup","resizable=yes,width=380,height=250,screenX=300,screenY=200");
    top.wndPopUp.focus();
    if(window.name != "UpPopup")  ResetTimeout();
  }
  return;
}

//----------------------------------------------------
function closePopup() {
//----------------------------------------------------
  if(top.wndPopUp) {
    if (top.wndPopUp.closed) {
    return;
    } else {
      top.wndPopUp.close();
    }
  }

  if(top.wndPopUpPopUp) {
    if (top.wndPopUpPopUp.closed) {
      return;
    } else {
      top.wndPopUpPopUp.close();
    }
  }
  return;
}

//----------------------------------------------------
function PopUpResizeByContent() {
//----------------------------------------------------
  if(parent.window.name != "UpPopup" && parent.window.name != "UpPopupPopUp" && window.name != "winConfig") return;
  var doc = this.document;
  if (this.parent) {
    var WinToResize = this.parent;
  } else {
    var WinToResize = this;
  }
  var sWidth, sHeight;
  var x = 0, y = 0, w = 0, h = 0, diffWidth = 0, diffHeight = 0, rs;
  sWidth = screen.availWidth;
  sHeight = screen.availHeight;
  sTaskBar = screen.height - screen.availHeight;
  w = 100;
  h = 100;
  // antesten Breite und Höhe
  this.scrollBy(1,0)
  x = doc.body.scrollLeft;
  this.scrollBy(0,1)
  y = doc.body.scrollTop;
  // wenn in einer der beiden Richtungen Scrollbalken vorhanden sein sollten -> anpassen
  if (x > 0 || y > 0) {
    this.scrollTo(0,0);
    this.resizeTo(w,h);
    // damit haben wir die tatsächliche Grösse des Fensters und können davon jetzt die innere Breite/Höhe subtrahieren
    diffHeight = h - this.document.body.offsetHeight;
    diffWidth = w - this.document.body.offsetWidth;
    // Breite anpassen
    this.scrollBy(sWidth, 0);
    x  = this.document.body.scrollLeft;
    rs = parseInt(diffWidth) + parseInt(doc.body.offsetWidth);
    if ((rs + x) < sWidth) {
      WinToResize.resizeBy(x, 0);
    } else {
      WinToResize.resizeBy(sWidth-rs, 0);
    }
    // Höhe anpassen
    this.scrollTo(0, 0);
    this.scrollBy(0, sHeight);
    y = this.document.body.scrollTop;
    rs = parseInt(diffHeight) + parseInt(doc.body.offsetHeight);
    if ((rs + y) < sHeight) {
      WinToResize.resizeBy(0, y);
      WinToResize.resizeBy(0, 0);
    } else {
      WinToResize.resizeBy(0, sHeight-rs-200);
      WinToResize.resizeBy(0,0);
    }
    if ( WinToResize.document.getElementById('UpAppMain') ) {
      WinToResize.document.getElementById('UpAppMain').style.width  = "100%";
      WinToResize.document.getElementById('UpAppMain').style.height = "100%";
    }
    WinToResize.scrollTo(0, 0);
    WinToResize.moveTo(0, 0);
  }
}

/****************************************************************************
 * put datas in two boxes add left add right ,clear list and set init values 
 ****************************************************************************/
icoleft = new Image();
icoleft.src = "../../../images/assets/icoLeft.gif";
icoleftover = new Image();
icoleftover.src = "../../../images/assets/icoLeftOver.gif";
icoleftclick = new Image();
icoleftclick.src = "../../../images/assets/icoLeftClick.gif";

icoright = new Image();
icoright.src = "../../../images/assets/icoRight.gif";
icorightover = new Image();
icorightover.src = "../../../images/assets/icoRightOver.gif";
icorightclick = new Image();
icorightclick.src = "../../../images/assets/icoRightClick.gif";

function changeImage(Image,ImageSrc) {
  window.document.images[Image].src = ImageSrc.src;
}

function OptionJuggler(event, that, p_strLeft, p_strRight, p_strName) {
  if ( window.event) event = window.event;
  var l_lKey = event.keyCode;

  if ( l_lKey == 39 ) {  // cursor right
    if ( OptionJuggler.arguments.length < 5 ) {
      OptionMoveRight();
    } else {
      OptionMoveRight(p_strLeft, p_strRight, p_strName);
    }
  }

  if ( l_lKey == 37 ) {  // cursor left
    if ( OptionJuggler.arguments.length < 5 ) {
      OptionMoveLeft();
    } else {
      OptionMoveLeft(p_strLeft, p_strRight, p_strName);
    }
  }

  if ( l_lKey == 40 && event.ctrlKey && that.selectedIndex < that.length-1 ) {  // cursor down
    for ( var j=that.options.length-1; j>=0; j=j-1 ) {
      if ( that.options[j].selected ) {
        var l_spOld = that.options[(j+1)];
        var l_spNew = that.options[j];
        that.options[(j)]   = new Option(l_spOld.text,l_spOld.value);
        that.options[(j+1)] = new Option(l_spNew.text,l_spNew.value);
        if ( document.all ) { that.options[(j)].selected = true; }
        else { that.options[(j+1)].selected = true; }
      }
    }
  }

  if ( l_lKey == 38 && event.ctrlKey && that.selectedIndex > 0 ) { // cursor up
    for ( var i=0; i < that.options.length; i++ ) {
      if ( that.options[i].selected ) {
        var l_spOld = that.options[(i-1)];
        var l_spNew = that.options[i];
        that.options[(i)]   = new Option(l_spOld.text,l_spOld.value);
        that.options[(i-1)] = new Option(l_spNew.text,l_spNew.value);
        if ( document.all ) { that.options[(i)].selected = true; } 
        else { that.options[(i-1)].selected = true; }
      }
    }
  }
}

//---------------------------------------------------------------------------
function OptionMoveRight(p_strLeft, p_strRight, p_strName) {
//---------------------------------------------------------------------------
  if ( OptionMoveRight.arguments.length < 3 ) {
    p_strLeft  = "left";
    p_strRight = "right";
  }

  if ( OptionMoveRight.arguments.length == 1 ) {
    p_strLeft  = "left_" + OptionMoveRight.arguments[0];
    p_strRight = "right_"+ OptionMoveRight.arguments[0];
  }

  l_oLeft  = eval("document.forms[0]" + "." + p_strLeft);
  l_oRight = eval("document.forms[0]" + "." + p_strRight);

  l_lFirstSelected = l_oLeft.selectedIndex;
  if ( l_lFirstSelected == -1 ) {
    if ( typeof l_strSelectEntry == "string" ) alert(l_strSelectEntry);
  }

  while(l_oLeft.selectedIndex != -1) {
    l_lSelected = l_oLeft.selectedIndex ;
    if(l_lSelected == -1) return;

    l_optNew = new Option(l_oLeft.options[l_lSelected].text);
    l_oRight.options[l_oRight.length] = l_optNew;
    l_oRight.options[l_oRight.length-1].text = l_oLeft.options[l_lSelected].text;
    l_oRight.options[l_oRight.length-1].value = l_oLeft.options[l_lSelected].value;
    l_oLeft.options[l_lSelected] = null;
  }
  if ( l_lFirstSelected < l_oLeft.options.length) l_oLeft.selectedIndex = l_lFirstSelected;
  if ( OptionMoveRight.arguments.length == 3 ) RefreshValue(l_oRight,p_strName);
  return;
}


//---------------------------------------------------------------------------
function OptionMoveLeft(p_strLeft, p_strRight, p_strName) {
//---------------------------------------------------------------------------
  if ( OptionMoveLeft.arguments.length < 3 ) {
    p_strLeft  = "left";
    p_strRight = "right";
  }

  if ( OptionMoveLeft.arguments.length == 1 ) {
    p_strLeft  = "left_" + OptionMoveLeft.arguments[0];
    p_strRight = "right_"+ OptionMoveLeft.arguments[0];
  }

  l_oLeft  = eval("document.forms[0]" + "." + p_strLeft);
  l_oRight = eval("document.forms[0]" + "." + p_strRight);

  l_lFirstSelected = l_oRight.selectedIndex ;
  if ( l_lFirstSelected == -1 ) {
    if ( typeof l_strSelectEntry == "string" ) alert(l_strSelectEntry);
  }

  while ( l_oRight.selectedIndex != -1 ) {
    l_lSelected = l_oRight.selectedIndex ;
    if(l_lSelected == -1) return;

    l_optNew = new Option(l_oRight.options[l_lSelected].text);
    l_oLeft.options[l_oLeft.length] = l_optNew;
    l_oLeft.options[l_oLeft.length-1].text = l_oRight.options[l_lSelected].text;
    l_oLeft.options[l_oLeft.length-1].value = l_oRight.options[l_lSelected].value;
    l_oRight.options[l_lSelected] = null;
  }
  if ( l_lFirstSelected < l_oRight.options.length) l_oRight.selectedIndex = l_lFirstSelected;
  if ( OptionMoveLeft.arguments.length == 3 ) RefreshValue(l_oRight,p_strName);
  return;
}

function RefreshValue(p_oRight,p_strName) {
  var l_arrSelected = new Array();

  if ( typeof p_oRight != "object" ) p_oRight = document.getElementById(p_oRight);
  if ( typeof p_oRight != "object" ) p_oRight = document.getElementsByName(p_oRight)[0];

  for(i=0;i < p_oRight.options.length;i++) {
    l_arrSelected[l_arrSelected.length] = p_oRight.options[i].value;
  }

  l_oHidden  = eval("document.forms[0]" + "." + p_strName);
  l_oHidden.value = l_arrSelected.join("|");
}

function ClearList(p_strLeft, p_strRight) {
  l_oLeft  = eval( "document.forms[0]" + "." + p_strLeft);
  l_oRight = eval("document.forms[0]" + "." + p_strRight);
  l_oLeft.options[0] = null;
  l_oRight.options[0] = null;
  return;
}

/*****************************************************
  Function zum Hinzufügen von Einträgen in Listboxen
*****************************************************/
function LoadForeignWindow(p_strPath,p_strForeignField,p_strField,p_strTable,p_strFilter) {
  if (top.name=="wndInsert") {
    alert(l_strFuncNotAvailable);
    return;
  } 

  l_bIsPicker = false;
  l_lPicker   = 0;
  //Check:Picker ?
  if (typeof g_arrFK != 'undefined') {
    for (i = 0; i < g_arrFK.length; i++) {
      if(typeof g_arrFK[i] != 'undefined') {
        if( g_arrFK[i] == p_strForeignField) l_bIsPicker = true;
      }
    }
  }

  if(l_bIsPicker) l_lPicker = 1;
  p_strPath = HexEncodeString(p_strPath);
  l_strPath = "../../../_UpInclude/Script/UpInserterFrameset.asp?rq_IsPicker=" + l_lPicker + "&rq_strTarget=" + p_strPath + "&rq_ForeignField=" + p_strForeignField + "&rq_strField=" + p_strField + "&rq_strTable=" + p_strTable + "&rq_strFilter=" + p_strFilter;

  if(!top.wndInsert) {
    top.wndInsert = open(l_strPath,"wndInsert","menubar=no,toolbar=no,dependent=yes,resizable=yes,scrollbars=yes,width=600,height=400,left=300,screenX=300,top=200,screenY=200");
  }
  else {
    if (top.wndInsert.closed) {
      top.wndInsert = open(l_strPath,"wndInsert","menubar=no,toolbar=no,dependent=yes,resizable=yes,scrollbars=yes,width=600,height=400,left=300,screenX=300,top=200,screenY=200");
    } else {
      top.wndInsert = open(l_strPath,"wndInsert","menubar=no,toolbar=no,dependent=yes,resizable=yes,scrollbars=yes,width=600,height=400,left=300,screenX=300,top=200,screenY=200");
      top.wndInsert.focus();
    }
  }
  return;
}

/*****************************************************
  Function zum setzen der Hintergrundfarbe in OnBlur
*****************************************************/
function SetFocusColor(p_obField,p_bFocus) {
  ele_type = p_obField.type;
  if (p_bFocus) {
    if (ele_type != "radio" && ele_type != "checkbox" && ele_type != "select-one") {
      p_obField.style.backgroundColor = l_strCOLORONFOCUS;
    }
  } else {
    if (ele_type != "radio" && ele_type != "checkbox" && ele_type != "select-one") {
      p_obField.style.backgroundColor = l_strCOLORONBLUR;
    }
  }
}

/*****************************************************
  Helper: für Control.js -> MakeFloat -> Umwandlung von String in Float unter Berücksichtigung von 
  Dezimaltrennzeichen und TausenderTrennung
  falls eingegebener Wert NaN ist, gibt "0" zurück
*****************************************************/
function MakeFloat(p_strIn,p_strUPtype) {
  var l_fOut = 0;
  l_fOut = toFloat(p_strIn,p_strUPtype);
  if (isNaN(l_fOut)) {
    return parseFloat(0);
  } else {
    return parseFloat(l_fOut);
  }
}

/*****************************************************
  Umwandlung von String in Float unter Berücksichtigung von
  Dezimaltrennzeichen und TausenderTrennung
  gibt Float oder "NaN" zurück
*****************************************************/
function toFloat(p_strIn,p_strUPtype) {
  var l_strIn = p_strIn;
  if (p_strUPtype == "UPCurrency") {
    var l_strGroupSymbol = g_strMonetaryDecimalGroupingSymbol;
    var l_strDecSymbol = g_strMonetaryDecimalSymbol;
  } else {
    var l_strGroupSymbol = g_strDecimalGroupingSymbol;
    var l_strDecSymbol = g_strDecimalSymbol;
  }
  // Tausender Trennzeichen rauswerfen
  l_strIn = replaceSubstring(l_strIn,l_strGroupSymbol,"");
  // Dezimalzeichen ist immer "."
  l_strIn = replaceSubstring(l_strIn,l_strDecSymbol,".");
  if(l_strIn=="" || l_strIn=="-")
  {
    l_strIn = 0;
  }
  // in Float
  l_fOut    = parseFloat(l_strIn);
  if(l_fOut > MAXFLOAT) {
    l_fOut = "isNaN";
  }
  return l_fOut;
}

/*****************************************************
  Helper: für Control.js -> MakeInteger -> Umwandlung von String in Integer unter Berücksichtigung von 
  TausenderTrennung
  falls eingegebener Wert NaN ist, gibt "0" zurück
*****************************************************/
function MakeInteger(p_strIn) {
  var l_lOut = 0;
  l_lOut = toInteger(p_strIn);
  if (isNaN(l_lOut)) {
    return parseInt(0,10);
  } else {
    return parseInt(l_lOut,10);
  }
}

/*****************************************************
  Umwandlung von String in Float unter Berücksichtigung von
  Dezimaltrennzeichen und TausenderTrennung
  gibt Float oder "NaN" zurück
*****************************************************/
function toInteger(p_strIn) {
  var l_strIn = p_strIn;
  var l_strGroupSymbol = g_strDecimalGroupingSymbol;
  // Tausender Trennzeichen rauswerfen
  l_strIn = replaceSubstring(l_strIn,l_strGroupSymbol,"");
  if(l_strIn=="" || l_strIn=="-") l_strIn = 0;
  return parseInt(l_strIn,10);
}

function FillLeading(strIn) {
  var strInput = new String(strIn);
  if(strInput.length > 1) return strInput;
  else return '0' + strInput;
}

function GetCurrDate(obj) {
  obj.value =  GetCurrDateLCID();
}

function GetCurrTime() {
  var dateTime = new Date();
  var strTime = new String(FillLeading(dateTime.getHours()) + ":" + FillLeading(dateTime.getMinutes()));
  if( l_LCID == 1031) strTime = new String(FillLeading(dateTime.getHours()) + ":" + FillLeading(dateTime.getMinutes()));
  if( l_LCID == 2057) strTime = new String(FillLeading(dateTime.getHours()) + ":" + FillLeading(dateTime.getMinutes()));
  if( l_LCID == 1033) {
    l_lHours = dateTime.getHours();

    if(l_lHours > 12) {
      l_lHours = l_lHours - 12;
      strHoursInd = "pm"; 
    } else {
      strHoursInd = "am";
    }
    strTime = new String(FillLeading(l_lHours) + ":" + FillLeading(dateTime.getMinutes()) + " " + strHoursInd);
  }
  return strTime;
}

function GetCurrDateLCID() {
  var currDate = new Date();
  if(l_LCID == 1031) var strDate = new String(FillLeading(currDate.getDate()) + "." + FillLeading(currDate.getMonth() +1) + "." + FillLeading(currDate.getFullYear()));
  if(l_LCID == 2057) var strDate = new String(FillLeading(currDate.getDate()) + "/" + FillLeading(currDate.getMonth() +1) + "/" + FillLeading(currDate.getFullYear()));
  if(l_LCID == 1033) var strDate = new String(FillLeading(currDate.getMonth() +1) + "/" + FillLeading(currDate.getDate()) + "/" +  FillLeading(currDate.getFullYear()));
  return strDate;
}

function GetCurrDateTime(obj) {
  obj.value = GetCurrDateLCID() + ' ' + GetCurrTime();
}

/*****************************************************
  Date specific variables
*****************************************************/
var daysInMonth = makeArray(12);
daysInMonth[1] = 31;
daysInMonth[2] = 29;
daysInMonth[3] = 31;
daysInMonth[4] = 30;
daysInMonth[5] = 31;
daysInMonth[6] = 30;
daysInMonth[7] = 31;
daysInMonth[8] = 31;
daysInMonth[9] = 30;
daysInMonth[10] = 31;
daysInMonth[11] = 30;
daysInMonth[12] = 31;
var whitespace = " \t\n\r";

function charInString(c, s) {
  for (i = 0; i < s.length; i++) {
    if (s.charAt(i) == c) return true;
  }
  return false
}

/*****************************************************
  Number of Days in February
*****************************************************/
function daysInFebruary(year) {
  return ( ((year % 4 == 0) && ((!(year % 100 == 0)) || (year % 400 == 0))) ? 29 : 28 );
}

/****************************************
 validate legal Number Characters,
 return false, if not a legal number
 return "0", if empty String
****************************************/
function validateLegalNumberChars(p_strValue,p_strDecSymbol,p_strGroupSymbol,p_bShowGroupingSymbol) {
  var l_strValue = p_strValue.toString();
  if (l_strValue=="") return "0";

  var l_strDecSymbol = p_strDecSymbol;
  var l_strGroupSymbol = p_strGroupSymbol;
  //falls kein GroupingSymbol Schalter(soll das Control ein Tausendertrenner haben?) reingegeben wird, wird auf "false" setzen
  if(!p_bShowGroupingSymbol) {
    l_bShowGroupingSymbol = false;
  } else {
    l_bShowGroupingSymbol = p_bShowGroupingSymbol;
  }
  // "-" rauswerfen, ausser an erster Stelle
  var regExpMinusSign = new RegExp("-","g");
  l_strRightValue = l_strValue.substring(1,l_strValue.length).replace(regExpMinusSign,"");
  l_strValue = l_strValue.substr(0,1) + l_strRightValue;
  // sind im String nur legale Zeichen?
  for (var i = 0; i < l_strValue.length; i++) {
    var isLegalChar = false;
    var c = l_strValue.charAt(i);
    if (isDigit(c) || (l_strDecSymbol!="" && c==l_strDecSymbol) || (l_bShowGroupingSymbol==true && c==l_strGroupSymbol)) {
      isLegalChar = true;
    }
    // erstes Zeichen darf "-" oder "+" sein
    else if((c=="-" ||c=="+") && i==0) {
      isLegalChar = true;
    }
    if(!isLegalChar) {
      return false;
    }
  }
  return l_strValue;
}

/************************************************
prüft und ergänzt die Tausendertrennzeichen
PARAMETERS:  p_strValue = zu korrigierender Wert
             p_strGroupSymbol = länderabh. Tausender Trennzeichen
             p_bShowGroupingSymbol = Schalter, ob dies Control TausenderTrenner anzeigen soll
RETURNS:     l_strValue = evtl. angepasster Wert ODER false (falls scheitert)
*************************************************/
function correctGroupingSymbol(p_strValue,p_strGroupSymbol,p_bShowGroupingSymbol) {
  var l_strValue = p_strValue.toString();
  // falls kein TausenderTrenner erwünscht -> mit Ausgangswert zurück
  if (!p_bShowGroupingSymbol || p_bShowGroupingSymbol=='') return l_strValue;

  var checkEnd = 0;
  var checkStart = l_strValue.length-1;
  var l_strGroupSymbol = p_strGroupSymbol;

  // löscht alle Tausendertrenner, falls vorhanden
  l_strValue = replaceSubstring(l_strValue,l_strGroupSymbol,"");

  // Funktion parst von rechts nach links durch Vorkommastellen, um Tausender Trenner zu setzen
  // Ende des Parsens finden;"+" oder "-" vorhanden?
  if (l_strValue.substr(0,1)=='+' || l_strValue.substr(0,1)=='-') {
    checkEnd = 1;
  } else {
    checkEnd = 0;
  }
  // Eingaben wie "-,1" in "-0,1" wandeln; für NS4 nötig
  if(checkStart<checkEnd) {
   l_strValue = l_strValue.substring(0,checkEnd) + "0";  
  }
  // Variable j zählt je bis 3=Stelle für Tausendertrenner hoch
  var j = 0;
  // von rechts (checkStart) nach links (checkEnd) durchgehen
  // Tausender Zeichen setzen
  for(i=checkStart;i>=checkEnd;i--) {
    if(j==3) {
      //falls Stelle des Tausendertrenners
      // Tausendertrenner fehlt?
      if(l_strValue.charAt(i) != l_strGroupSymbol) {
        l_strValue = l_strValue.substring(0,i+1) + l_strGroupSymbol + l_strValue.substring(i+1,l_strValue.length);
        i++;
      }
      // Stelle des Tausendertrenners zurücksetzen
      j = 0;
    } else {
      j++;
    }
  }
  return l_strValue;
}

/************************************************
 replaceSubstring(p_strString,p_strSubstringFrom,p_strSubstringTo)
 ersetzt alle Vorkommen von p_strSubstringFrom in p_strString durch p_strSubstringTo;
************************************************/
function replaceSubstring(p_strString,p_strSubstringFrom,p_strSubstringTo) {
  var l_strStingOut = "";
  if(!p_strString || p_strString=="") {
    return "";
  } else {
    var l_strString = p_strString.toString(); 
  }

  if(!p_strSubstringFrom || p_strSubstringFrom=="") {
    return l_strString;
  } else {
    var l_strSubstringFrom = p_strSubstringFrom.toString(); 
  }

  if(!p_strSubstringTo) {
     l_strSubstringTo = "";
  } else {
    var l_strSubstringTo = p_strSubstringTo.toString(); 
  }

  var l_lStartPos  = 0;
  var l_lEndPos  = l_strString.indexOf(l_strSubstringFrom, 0);
  while (l_lEndPos != -1) {
    for (var i = l_lStartPos;i < l_lEndPos;i++) {
      l_strStingOut += l_strString.charAt(i);
    }
    l_strStingOut += l_strSubstringTo;
    l_lStartPos = l_lEndPos + l_strSubstringFrom.length;
    l_lEndPos = l_strString.indexOf(l_strSubstringFrom, l_lStartPos);
  }

  for (i = l_lStartPos; i < l_strString.length; i++) {
    l_strStingOut += l_strString.charAt(i);
  }
  return l_strStingOut;
}

/************************************************
  Helper function
************************************************/
function isIntegerInRange(s, a, b) {
  if ( ! isInteger(s) ) return false;
  var num = parseInt (s);
  return ( ( num >= a ) && ( num <= b ) );
}

/************************************************
  Check for being a integer
************************************************/
function isInteger(s) {
  var i;
  for ( i = 1; i < s.length; i++ ) {
    var c = s.charAt(i);
    if ( ! isDigit(c)) return false;
  }
  return true;
}

/************************************************
 Date Helper function
************************************************/
function isMonth(s) {
  return isIntegerInRange (s, 1, 12);
}

/************************************************
  makeArray
************************************************/
function makeArray(n) {
  var arr = new Array(n + 1);
  for (var i = 1; i <= n; i++) arr[i] = 0
  return arr
}

//****************************************************
//  Trim whitespaces
//****************************************************
function lTrim(s) {
  return s.replace(/^ +/g, "");
}
function rTrim(s) {
  return s.replace(/ +$/g, "");
}
function Trim(s) {
  return s.replace(/^ +| +$/g, "");
}
function trim(s) {
  return s.replace(/^ +| +$/g, "");
}

//****************************************************
// General
//****************************************************
function canInput(str, cKey, iMaxCount) {
  var l_lPrecision = 0;
  for (i = 0; i < str.length; i++) {
    if (str.charAt(i) == cKey) l_lPrecision++;
  }
  return (l_lPrecision < iMaxCount) ? true:false;
}

function isDigit(c) {
  return ( ( c >= "0" ) && ( c <= "9" ) )
}

//****************************************************
// Float Control - inserting trailing zeros
//****************************************************
function getLastZeros(iCount) {
  str = new String();
  var iCounter = iCount;
  for(i=0;i< iCounter;i++) {
    str = str + '0';
  }
  return str;
}

var g_achHex = new Array('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F');
function HexEncodeString(p_str) {
  var l_str = new String();
  for (i = 0; i < p_str.length; i++) {
    var l_n = p_str.charCodeAt(i);
    l_str += g_achHex[(l_n >> 4) & 0x0F] + g_achHex[l_n & 0x0F];
  }
  return l_str + "00";
}

//****************************************************
// function Integer2Screen(p_lInput, p_bFormat)
// Wandelt Float in Formatierten HTML Output:Currency
//****************************************************
function Integer2Screen(p_lInput,p_bFormat) {
  var l_strNewValue = toLocalIntegerString(p_lInput,p_bFormat,g_strDecimalGroupingSymbol);
  if(!l_strNewValue) {
    return "0";
  } else {
    return l_strNewValue;
  }
}

//****************************************************
// toLocalIntegerString(p_lInput, p_bFormat, p_strGroupSymbol)
// Wandelt Integer in Formatierten HTML Output
//****************************************************
function toLocalIntegerString(p_lInput, p_bFormat, p_strGroupSymbol) {
  if(isNaN(parseInt(p_lInput,10))) {
    return false;
  }
  var l_bShowGroupingSymbol = p_bFormat;
  var l_strGroupSymbol = p_strGroupSymbol;
  var l_strNewValue = "";
  // in String wandeln
  var l_strValue = p_lInput.toString();
  l_strNewValue = correctGroupingSymbol(l_strValue,l_strGroupSymbol,l_bShowGroupingSymbol); 
  if(!l_strNewValue) {
    return false;
  }
  return l_strNewValue;
}

//****************************************************
// function FloatToScreenCurrency(p_fInput, p_bFormat)
// Wandelt Float in Formatierten HTML Output:Currency
//****************************************************
function Float2ScreenCurrency(p_fInput,p_lPrecision, p_bFormat) {
  var l_strOut = "";
  var l_strNewValue = toLocalFloatString(p_fInput,p_lPrecision,p_bFormat,g_strMonetaryDecimalSymbol,g_strMonetaryDecimalGroupingSymbol);
  if(!l_strNewValue) {
    l_strOut = "0";
    if(l_lPrecision && l_lPrecision > 0) l_strOut = l_strOut + g_strMonetaryDecimalSymbol + correctDecs("",p_lPrecision);
    return l_strOut;
  } else {
    return l_strNewValue;
  } 
}

//****************************************************
// FloatToScreenFloat(p_fInput,p_lPrecision)
// Wandelt Float in Formatierten HTML Output:Float
//****************************************************
function Float2ScreenFloat(p_fInput,p_lPrecision, p_bFormat) {
  var l_strOut = "";
  var l_lPrecision = p_lPrecision;
  var l_strNewValue = toLocalFloatString(p_fInput,p_lPrecision,p_bFormat,g_strDecimalSymbol,g_strDecimalGroupingSymbol);
  if(!l_strNewValue) {
    l_strOut = "0";
    if(l_lPrecision && l_lPrecision > 0) {
      l_strOut  = l_strOut + g_strDecimalSymbol + correctDecs("",p_lPrecision);
    }
    return l_strOut;
  } else {
    return l_strNewValue;
  }
}

//****************************************************
// toLocalFloatString(p_fInput,p_lPrecision, p_bFormat, p_strDecSymbol, p_strGroupSymbol)
// Wandelt Float in Formatierten HTML Output
//****************************************************
function toLocalFloatString(p_fInput,p_lPrecision, p_bFormat, p_strDecSymbol, p_strGroupSymbol) {
  if(isNaN(parseFloat(p_fInput))) {
    return false;
  }
  var l_bShowGroupingSymbol = p_bFormat;
  var l_lPrecision = p_lPrecision;
  var l_strDecSymbol = p_strDecSymbol;
  var l_strGroupSymbol = p_strGroupSymbol;
  var isCorrect = true; 
  var l_strPreDec = "";
  var l_strPostDec = "";
  var l_strNewValue = "";
  
  // in String wandeln
  var l_strValue = p_fInput.toString();
  // in Bestandteile vor und nach Komma splitten
  if(l_strValue.indexOf(".")>-1) {
    l_strPreDec  = l_strValue.substr(0, l_strValue.indexOf('.'));
    l_strPostDec = l_strValue.substring(l_strValue.indexOf('.') + 1,l_strValue.length);
  } else {
    l_strPreDec  = l_strValue;
    l_strPostDec  = "";
  }
  l_strPreDec = correctGroupingSymbol(l_strPreDec,l_strGroupSymbol,l_bShowGroupingSymbol);  
  l_strPostDec = correctDecs(l_strPostDec,l_lPrecision);
  if(!l_strPreDec || !l_strPostDec) {
    isCorrect = false;
  }
  // String zusammenbauen
  if(isCorrect) {
    l_strNewValue = l_strPreDec;
    if(l_lPrecision && l_lPrecision > 0) {
      l_strNewValue = l_strNewValue + l_strDecSymbol + l_strPostDec;
    }
    return l_strNewValue;
  } else {
    return false;
  }
}

//****************************************************
// Anpassung Nachkommastellen für Float und Currency Controls
//****************************************************
function correctDecs(p_strValue,p_lPrecision) {
  var l_strValue = p_strValue;
  var l_lPrecision = p_lPrecision;

  // Leerstring
  if(!l_strValue || l_strValue.length == 0 ) {
    return getLastZeros(l_lPrecision);
  }

  if(l_strValue.length > l_lPrecision) {
    return l_strValue.substr(0,l_lPrecision);
  } else {
    return l_strValue + this.getLastZeros(l_lPrecision - l_strValue.length);
  }
}

//****************************************************
//  if Blur Validation of Numeric Controls result false
//****************************************************
function handleBlurValidationError(oControl, value) {
  alert(l_strValBlurAlert + ":\n" + value);
  return false;
}

//****************************************************
//  Validation of Float Controls 
//  invoked by 'onBlur()'
//****************************************************
function ValidateFloat(oFloat, p_lPrecision, p_bShowGroupingSymbol) {
  var l_lPrecision = p_lPrecision;
  var l_bShowGroupingSymbol = p_bShowGroupingSymbol;
  var isCorrect = true;
  var l_strOldValue = oFloat.value;
  var l_strNewValue = "";
  var l_fNewValue = 0;
  l_fNewValue = toFloat(l_strOldValue,"UPFloat");
  if( isNaN(l_fNewValue) ) {
    isCorrect = false;
  }
  if( isCorrect ) {
    l_strNewValue = toLocalFloatString(l_fNewValue, l_lPrecision, l_bShowGroupingSymbol, g_strDecimalSymbol, g_strDecimalGroupingSymbol);
  }
  if( ! l_strNewValue ) {
    isCorrect = false;
  }
  if( isCorrect ) {
    oFloat.value = l_strNewValue;
    return true;
  } else {
    return handleBlurValidationError(oFloat, l_strOldValue);
  }
}

//****************************************************
// Validation of Integer Control
// invoked by 'onBlur()'
//****************************************************
function ValidateInteger(oInt,p_bShowGroupingSymbol) {
  var l_bShowGroupingSymbol = p_bShowGroupingSymbol;
  var isCorrect = true;
  var l_strOldValue = oInt.value;
  var l_strNewValue = "";
  var l_lNewValue = 0;

  l_lNewValue = toInteger(l_strOldValue);
  if( isNaN(l_lNewValue) ) isCorrect = false;
  if( isCorrect ) l_strNewValue = toLocalIntegerString(l_lNewValue, l_bShowGroupingSymbol ,g_strDecimalGroupingSymbol);
  if( ! l_strNewValue ) isCorrect = false;
  if( isCorrect ) {
    oInt.value = l_strNewValue;
    return true;
  } else {
    return handleBlurValidationError(oInt, l_strOldValue);
  }
}


//****************************************************
// Validation of Currency Controls 
// invoked by 'onBlur()'
//****************************************************
// mit variabler Anzahl Nachkommastellen
function ValidateCurrency(oCurrency,l_lPrecision,  p_bShowGroupingSymbol) {
  ValidateCurrencyDo(oCurrency,l_lPrecision,p_bShowGroupingSymbol);
}

function ValidateCurrencyDo(oCurrency,p_lPrecision,p_bShowGroupingSymbol) {
  var l_lPrecision = p_lPrecision;
  var l_bShowGroupingSymbol = p_bShowGroupingSymbol;
  var isCorrect = true;
  var l_strOldValue = oCurrency.value;
  var l_strNewValue = "";
  var l_fNewValue = 0;
  
  l_fNewValue = toFloat(l_strOldValue,"UPCurrency");
  if(isNaN(l_fNewValue)) isCorrect = false;
  if(isCorrect) l_strNewValue = toLocalFloatString(l_fNewValue,l_lPrecision,l_bShowGroupingSymbol,g_strMonetaryDecimalSymbol,g_strMonetaryDecimalGroupingSymbol);
  if(!l_strNewValue) isCorrect = false;
  if(isCorrect) {
    oCurrency.value = l_strNewValue;
    return true;
  } else {
    return handleBlurValidationError(oCurrency,l_strOldValue);
  }
}

function IsINTInRange(strC) {
  l_lIntValue = parseInt(strC);
  if(isNaN(l_lIntValue)) return false;
  l_lIntValue = Math.abs(l_lIntValue);
  if(l_lIntValue > MAXINT) return false;
  return true;
}

function IsFLOATInRange(strC,p_strUPtype) {
  strC = toFloat(strC,p_strUPtype);
  l_fFloatValue = parseFloat(strC);
  if(isNaN(l_fFloatValue)) return false;
  l_fFloatValue = Math.abs(l_fFloatValue);
  if(l_fFloatValue > MAXFLOAT) return false;
  return true;
}

//****************************************************
// CheckDate(p_strDate) - Überprüfung ob Datum gültig ist
//****************************************************
function CheckDate(p_strDate) {
  l_bBuildDate = false;
  var l_iDay,l_iMonth,l_iYear,l_strSeperator;
  var l_dtCurrDate = new Date();
  var l_strInput   = new String(p_strDate);
  var l_strSeperator = new String();

  if ( isNaN(l_LCID) ) l_LCID = 1031;

  switch (l_LCID) {
    case 1088:
      l_strFormat = "d.m.yy";
    break;

    case 1031: case 1044: case 1048: case 1049: case 1055: case 1058: case 1059: case 1061:
    case 1067: case 1068: case 1071: case 1079: case 1087: case 1095: case 2055: case 2064:
    case 2068: case 2092: case 2115: case 3079: case 4103: case 4108: case 5127:
      l_strFormat = "dd.mm.yyyy";
    break;

    case 1050: case 1026: case 1029: case 1035: case 1039: case 1060: case 2074: case 2077:
    case 3098:
      l_strFormat = "d.m.yyyy";
    break;

    case 1051:
      l_strFormat = "d. m. yyyy";
    break;

    case 1104:
      l_strFormat = "yy.mm.dd";
    break;

    case 1038:
      l_strFormat = "yyyy. mm. dd.";
    break;

    case 1062:
      l_strFormat = "yyyy.mm.dd.";
    break;

    case 1063:
      l_strFormat = "yyyy.mm.dd";
    break;

    case 1043:
      l_strFormat = "d-m-yyyy";
    break;

    case 1094: case 1095: case 1098: case 1099:
      l_strFormat = "dd-mm-yy";
    break;

    case 1030: case 1080: case 1081: case 1102: case 1103: case 1111: case 2070: case 5121:
    case 6145: case 7168:
    case 13322:
      l_strFormat = "dd-mm-yyyy";
    break;

    case 2052:
      l_strFormat = "yyyy-m-d";
    break;

    case 1045: case 1042: case 1052: case 1053: case 3084:
      l_strFormat = "yyyy-mm-dd";
    break;

    case 1032: case 1046: case 1054: case 3076: case 4100: case 5124:
      l_strFormat = "d/m/yyyy";
    break;

    case 1110: case 1125:
      l_strFormat = "dd/mm/yy";
    break;

    case 1091:
      l_strFormat = "dd/mm yyyy";
    break;

    case 1033: case 1089: case 12297:
    case 13321:
      l_strFormat = "m/d/yyyy";
    break;

    case 6154: case 9225:
      l_strFormat = "mm/dd/yyyy";
    break;

    case 1028: case 1041: case 1065: case 1069: case 1078: case 7177:
      l_strFormat = "yyyy/mm/dd";
    break;

    default:
      l_strFormat = "dd/mm/yyyy";
    break;
  }

  l_Format = /^([ymd]+)([^ymd]*)([ymd]+)([^ymd]*)([ymd]+)([^ymd]*)$/i;
  l_Format = l_strFormat.match(l_Format);
  l_Sep1 = l_Format[2];
  l_Sep2 = l_Format[4];
  l_Sep3 = l_Format[6];

  switch (l_Format[1]) {
    case "yy":
      l_bFullYear = false;
      l_Re1  = "^(\\d{2})(\\D*)";
    break;

    case "yyyy":
      l_bFullYear = true;
      l_Re1  = "^(\\d{1,4})(\\D*)";
    break;

    case "m":
      l_Re1  = "^(\\d{1,2})(\\D*)";
    break;

    case "mm":
      l_Re1  = "^(\\d{1,2})(\\D*)";
    break;

    case "d":
      l_bFill = false;
      l_Re1  = "^(\\d{1,2})(\\D*)";
    break;

    case "dd":
      l_bFill = true;
      l_Re1  = "^(\\d{1,2})(\\D*)";
    break;
  }

  switch (l_Format[3]) {
    case "yy":
      l_bFullYear = false;
      l_Re2  = "(\\d{2})(\\D*)";
    break;

    case "yyyy":
      l_bFullYear = true;
      l_Re2  = "(\\d{1,4})(\\D*)";
    break;

    case "m":
      l_Re2  = "(\\d{1,2})(\\D*)";
    break;

    case "mm":
      l_Re2  = "(\\d{1,2})(\\D*)";
    break;

    case "d":
      l_bFill = false;
      l_Re2  = "(\\d{1,2})(\\D*)";
    break;

    case "dd":
      l_bFill = true;
      l_Re2  = "(\\d{1,2})(\\D*)";
    break;
  }

  switch (l_Format[5]) {
    case "yy":
      l_bFullYear = false;
      l_Re3  = "(\\d{2})(\\D*)";
    break;

    case "yyyy":
      l_bFullYear = true;
      l_Re3  = "(\\d{1,4})(\\D*)";
    break;

    case "m":
      l_Re3  = "(\\d{1,2})(\\D*)";
    break;

    case "mm":
      l_Re3  = "(\\d{1,2})(\\D*)";
    break;

    case "d":
      l_bFill = false;
      l_Re3  = "(\\d{1,2})(\\D*)";
    break;

    case "dd":
      l_bFill = true;
      l_Re3  = "(\\d{1,2})(\\D*)";
    break;
  }

  var l_iDay;
  var l_iMonth;
  var l_iYear;

  var l_re = new RegExp(l_Re1+l_Re2+l_Re3);
  var l_result = l_re.test(l_strInput);

  if ( l_result ) {
    // populate
    if ( l_Format[1] == "yyyy" || l_Format[1] == "yy" ) { l_iYear  = parseInt(trim(RegExp.$1),10); }
    if ( l_Format[3] == "yyyy" || l_Format[3] == "yy" ) { l_iYear  = parseInt(trim(RegExp.$3),10); }
    if ( l_Format[5] == "yyyy" || l_Format[5] == "yy" ) { l_iYear  = parseInt(trim(RegExp.$5),10); }

    if ( l_Format[1] == "m" || l_Format[1] == "mm" ) { l_iMonth  = parseInt(trim(RegExp.$1),10); }
    if ( l_Format[3] == "m" || l_Format[3] == "mm" ) { l_iMonth  = parseInt(trim(RegExp.$3),10); }
    if ( l_Format[5] == "m" || l_Format[5] == "mm" ) { l_iMonth  = parseInt(trim(RegExp.$5),10); }

    if ( l_Format[1] == "d" || l_Format[1] == "dd" ) { l_iDay  = parseInt(trim(RegExp.$1),10); }
    if ( l_Format[3] == "d" || l_Format[3] == "dd" ) { l_iDay  = parseInt(trim(RegExp.$3),10); }
    if ( l_Format[5] == "d" || l_Format[5] == "dd" ) { l_iDay  = parseInt(trim(RegExp.$5),10); }
  }

  if(isNaN(l_iMonth) || !isMonth(l_iMonth))
    l_iMonth = l_dtCurrDate.getMonth() + 1;

  if (isNaN(l_iDay) || l_iDay > daysInMonth[l_iMonth] || l_iDay < 1) 
    l_iDay = l_dtCurrDate.getDate();
  if (isNaN(l_iYear) || l_iYear > 9999)
    l_iYear = l_dtCurrDate.getFullYear();
 
  if (l_iYear < 100 && l_iYear > 30 )
    l_iYear = 1900 + l_iYear;

  if(l_iYear <= 30 && l_bFullYear)
    l_iYear = 2000 + l_iYear;

  // check february
  if ( (l_iMonth == 2 ) && ( l_iDay > daysInFebruary(l_iYear) ) )
    l_iDay = daysInFebruary(l_iYear);

  // insert leading 0 if needed
  if ( l_bFill ) { l_iDay = FillLeading(l_iDay); l_iMonth = FillLeading(l_iMonth); }
  if ( !l_bFullYear ) { l_iYear =  FillLeading(l_iYear); }

  // determine order
  if ( l_Format[1] == "yyyy" || l_Format[1] == "yy" ) { l_Pos1 = l_iYear; }
  if ( l_Format[3] == "yyyy" || l_Format[3] == "yy" ) { l_Pos2 = l_iYear; }
  if ( l_Format[5] == "yyyy" || l_Format[5] == "yy" ) { l_Pos3 = l_iYear; }

  if ( l_Format[1] == "m" || l_Format[1] == "mm" ) { l_Pos1 = l_iMonth; }
  if ( l_Format[3] == "m" || l_Format[3] == "mm" ) { l_Pos2 = l_iMonth; }
  if ( l_Format[5] == "m" || l_Format[5] == "mm" ) { l_Pos3 = l_iMonth; }

  if ( l_Format[1] == "d" || l_Format[1] == "dd" ) { l_Pos1 = l_iDay; }
  if ( l_Format[3] == "d" || l_Format[3] == "dd" ) { l_Pos2 = l_iDay; }
  if ( l_Format[5] == "d" || l_Format[5] == "dd" ) { l_Pos3 = l_iDay; }

  return l_Pos1 + l_Sep1 + l_Pos2 + l_Sep2 + l_Pos3 + l_Sep3;
}


//****************************************************
// CheckTime(p_strTime) - Überprüfung ob Zeit gültig ist
//****************************************************
function CheckTime(p_strTime) {
  l_bBuildDate = false;
  var l_dtCurrDate = new Date();
  var l_strInput   = new String(p_strTime);
  var l_strSep     = ":";
  var l_strAM      = "";
  var l_strPM      = "";
  var l_b24hours   = true;
  var l_bSeconds   = false;
  var l_bFill      = true;
  var l_bPM        = false;

  if ( isNaN(l_LCID))
    l_LCID = 1031;

  switch (l_LCID) {
    case 1040: case 1080:
      l_strSep = ".";
      l_bSeconds = true;
    break;

    case 1052:
      l_b24hours = false;
      l_bFill = false;
      l_strAM = "PD";
      l_strPM = "MD";
    break;

    case 1033: case 1089: case 3081: case 4105: case 9225:
    case 12297: case 13321:
      l_b24hours = false;
      l_bFill = false;
      l_strAM = "AM";
      l_strPM = "PM";
    break;

    case 7177: case 8201:
    case 10249: case 11273:
      l_b24hours = false;
      l_strAM = "AM";
      l_strPM = "PM";
    break;

    case 5129:
      l_b24hours = false;
      l_bFill = false;
      l_strAM = "a.m.";
      l_strPM = "p.m.";
    break;

    case 2058: case 4106: case 5130: case 6154: case 7178: case 8202: case 9226:
    case 10250: case 11274: case 14346: case 15370: case 16394: case 17418: case 18442:
    case 19466: case 20490:
      l_b24hours = false;
      l_strAM = "a.m.";
      l_strPM = "p.m.";
    break;

    default:
    break;
  }

  l_re = /(?:\D*)?(\d{1,2})\:?\.?(\d{2})\:?\.?(\d{1,2})?(\D*)?$/;
  var l_result = l_re.test(l_strInput);

  l_iHour        = parseInt(trim(RegExp.$1),10);
  l_iMinutes     = parseInt(trim(RegExp.$2),10);
  l_iSeconds     = parseInt(trim(RegExp.$3),10);
  l_strIndicator = trim(RegExp.$4);

  if ( isNaN(l_iHour) || !isIntegerInRange(l_iHour,0,23) )
    l_iHour = l_dtCurrDate.getHours();

  if ( !l_b24hours ) {
    if ( l_iHour > 12 ) {
      l_iHour = l_iHour-12;
      l_bPM = true;
    } else if ( l_iHour < 12 && l_strIndicator == "" ) {
      l_bPM = false;
    }
    if ( l_strIndicator == "PM" || l_strIndicator.toUpperCase() == l_strPM.toUpperCase() )
      l_bPM = true;
  }

  if (isNaN(l_iMinutes) || !isIntegerInRange(l_iHour,0,59) ) l_iMinutes = "00";
  if (isNaN(l_iSeconds) || !isIntegerInRange(l_iSeconds,0,59) ) l_iSeconds = "00";

  if ( !l_b24hours ) {
    if ( l_strIndicator.toUpperCase() == l_strAM.toUpperCase() || l_strIndicator.toUpperCase() == "AM" || !l_bPM)
      l_strIndicator = " " + l_strAM;
    if ( l_strIndicator.toUpperCase() == l_strPM.toUpperCase() || l_strIndicator.toUpperCase() == "PM" || l_bPM )
      l_strIndicator = " " + l_strPM;
  } else {
    l_strIndicator = "";
  }

  if ( l_bFill ) l_iHour = FillLeading(l_iHour);

  l_iMinutes = FillLeading(l_iMinutes);
  l_iSeconds = FillLeading(l_iSeconds);

  if ( l_bSeconds ) {
    return l_iHour + l_strSep + l_iMinutes + l_strSep + l_iSeconds + l_strIndicator;
  } else {
    return l_iHour + l_strSep + l_iMinutes + l_strIndicator;
  }
}

//****************************************************
// calls CheckDate() and CheckTime() eventually joins both
//****************************************************
function ValidateDateTime(obDateTime) {
  var l_strInput = new String(obDateTime.value);
  if ( l_strInput.length == 0 ) return;
  var l_strDate = CheckDate(l_strInput);
  var l_strTime = CheckTime(l_strInput);
  obDateTime.value = l_strDate + " " + l_strTime;
}

//****************************************************
// invoked by 'onBlur()'
//****************************************************
function ValidateDate(obDate) {
  strC = obDate.value;
  if(strC.length==0) return;
  obDate.value = CheckDate(strC);
}

//****************************************************
// invoked by 'onBlur()'
//****************************************************
function ValidateTime(obTime) {
  strC = obTime.value;
  if(strC.length==0) return;
  obTime.value = CheckTime(strC);
}

//****************************************************
// Input Handler for Integer Control
// invoked by 'onkeypress'
// Accepts: '-' 
// Numbers
//****************************************************
function validateIntegerInput(strItemValue, cKey, lUnSigned, l_bShowGroupSep) {
  if (cKey=="-") {
    if (!lUnSigned) return canInput(strItemValue, '-', 1);
  }
  if (cKey==g_strDecimalGroupingSymbol) {
    // = Tausender Trennzeichen ; darf mehrmals vorhanden sein; falls für dies Control erwünscht
    if (l_bShowGroupSep)
      return true;
    else
      return false;
  }
  if (isDigit(cKey)) {
    NewVal = strItemValue + cKey;
    return IsINTInRange(NewVal);
  }
  return false;
}

//****************************************************
// Input Handler for Currency Control
// invoked by 'onkeypress'
//****************************************************
function validateCurrencyInput(strItemValue, cKey, l_bShowGroupSep) {
  if (cKey==g_strMonetaryDecimalSymbol) {
    // = Dezimal Trennzeichen ; darf nur einmal vorhanden sein
    if (strItemValue.indexOf(g_strMonetaryDecimalSymbol) > -1) return false;
    return true;
  }
  if (cKey==g_strMonetaryDecimalGroupingSymbol) {
    // = Tausender Trennzeichen ; darf mehrmals vorhanden sein; falls für dies Control erwünscht
    if(l_bShowGroupSep)
      return true;
    else
      return false;
  }
  if (cKey=="-")
    return canInput(strItemValue, '-', 1);
  if (isDigit(cKey)) {
    NewVal =  strItemValue + cKey;
    return IsFLOATInRange(NewVal,"UPCurrency");
  }
  return false;
}

//****************************************************
// Input Handler for float Control
// invoked by 'onkeypress'
// Accepts: 
// '.' 
// Numbers
//****************************************************
function validateFloatInput(strItemValue, cKey, l_bShowGroupSep) {
  if (cKey==g_strDecimalSymbol) {
    // = Dezimal Trennzeichen ; darf nur einmal vorhanden sein
    if (strItemValue.indexOf(g_strDecimalSymbol) > -1) return false;
    return true;
  }
  if (cKey == g_strDecimalGroupingSymbol) {
    // = Tausender Trennzeichen ; darf mehrmals vorhanden sein; falls für dies Control erwünscht
    if(l_bShowGroupSep)
      return true;
    else
      return false;
  }
  if (cKey=="-") return canInput(strItemValue, '-', 1);
  if (isDigit(cKey)) {
    NewVal =  strItemValue + cKey;
    return IsFLOATInRange(NewVal, "UPFloat");
  }
  return false;
}

//****************************************************
// Input Handler for Date Control
// invoked by 'onkeypress'
// Accepts: '.'
// Numbers
//****************************************************
function validateDateInput(strItemValue, cKey) {
  switch (cKey) {
    case('.'):
      return canInput(strItemValue,'.',2);
      break;
    case('/'):
      return true;
      break;
    default:
      return isDigit(cKey);
  }
  return true;
}

//****************************************************
// Input Handler for DateTime Control
// invoked by 'onkeypress'
// Accepts: '.' but only two of them
// Numbers
// ':'
//****************************************************
function validateDateTimeInput(strItemValue, cKey) {
  switch (cKey) {
    case('.'):
      return canInput(strItemValue,'.',2);
    case(' '):
      return canInput(strItemValue,' ',2);
    case(':'):
      return canInput(strItemValue,':',2);
    case('/'):
    case('a'):
    case('A'):
    case('p'):
    case('P'):
    case('m'):
    case('M'):
      return true;
    default:
      return isDigit(cKey);
  }
  return true;
}

//****************************************************
// Input Handler for Time Control
// invoked by 'onkeypress'
// Accepts: ':'
// Numbers
//****************************************************
function validateTimeInput(strItemValue, cKey) {
  switch(cKey) {
    case(' '):
      return canInput(strItemValue,' ',1);
    case(':'):
      return canInput(strItemValue,':',1);
    case('a'):
    case('A'):
    case('p'):
    case('P'):
    case('m'):
    case('M'):
      return true;
    default:
      return isDigit(cKey);
  }
  return true;
}

//****************************************************
// Input Handler Control
// invoked by 'onkeypress'
//****************************************************
function processValidation(strItemValue, cKey, lControl, l_bShowGroupSep) {
  var bValidated;
  switch (lControl) {
    case(1):
      bValidated = validateCurrencyInput(strItemValue, cKey, l_bShowGroupSep);
      break;
    case(2):
      bValidated = validateDateInput(strItemValue, cKey);
      break;
    case(3):
      bValidated = validateTimeInput(strItemValue, cKey);
      break;
    case(4):
      bValidated = validateIntegerInput(strItemValue, cKey,0, l_bShowGroupSep);
      break;
    case(5):
      bValidated = validateIntegerInput(strItemValue, cKey,1, l_bShowGroupSep);
      break;
    case(6):
      bValidated = validateFloatInput(strItemValue, cKey, l_bShowGroupSep);
      break;
    case(7):
      bValidated = validateDateTimeInput(strItemValue, cKey);
      break;
  }
  return bValidated;
}

//****************************************************
// Input Handler Control
// invoked by 'onkeypress'
//****************************************************
function validKey1(event, that) {
  /*IE only*/
  if ( ! document.all ) return true;
  if ( window.event ) {
    event = window.event;
  }

  lWhichASC = event.keyCode;
  cWhichKey       = String.fromCharCode(lWhichASC).toLowerCase();
  strItemName     = that.name;
  strItemValue    = that.value;

  if( that.getAttribute('ixGrouping') == "1" ) {
    l_bShowGroupSep = true;
  } else {
    l_bShowGroupSep = false;
  }

  switch(that.getAttribute('ixType')) {
    case("UPCurrency"):
      lControl = 1;
    break;
    case("UPDate"):
      lControl = 2;
    break;
    case("UPTime"):
      lControl = 3;
    break;
    case("UPSignedInteger"):
      lControl = 4;
    break;
    case("UPUnsignedInteger"):
      lControl = 5;
    break;
    case("UPFloat"):
      lControl = 6;
    break;
    case("UPDateTime"):
      lControl = 7;
    break;
    default:
      lControl = 0;
    break;
  }

  if( lControl > 0 ) {
    if ( lWhichASC == 0 || lWhichASC == 8 ) return true;
    bValidated      = processValidation(strItemValue, cWhichKey, lControl, l_bShowGroupSep);
    if ( bValidated == false ) {
      event.returnValue = false;
      event.keyCode = 0;
      return false;
    }
  }
}

function validKey2(event, that) {
  /*reserved*/
  return true;
}

//****************************************************
// Input Handler Control
// invoked by 'onkeypress'
//****************************************************
function processKey(e) {
  var lControl;
  if (NS4 || W3C) {
    oItemObj = e.target;
  } else {
    oItemObj = e;
  }

  if(oItemObj.bShowGroupSep) {
    l_bShowGroupSep = oItemObj.bShowGroupSep; 
  } else {
    l_bShowGroupSep = false;
  }

  switch(oItemObj.UPtype) {
    case("UPCurrency"):
      lControl = 1;
    break;
    case("UPDate"):
      lControl = 2;
    break;
    case("UPTime"):
      lControl = 3;
    break;
    case("UPSignedInteger"):
      lControl = 4;
    break;
    case("UPUnsignedInteger"):
      lControl = 5;
    break;
    case("UPFloat"):
      lControl = 6;
    break;
    case("UPDateTime"):
      lControl = 7;
    break;
    default:
      lControl = 0;
    break;
  }

  if(lControl) {
    if (NS4 || W3C) {
      lWhichASC = e.which;
    } else {
      lWhichASC = event.keyCode;
    }

    if(lWhichASC == 0) return true;
    if(lWhichASC == 8) return true;

    cWhichKey       = String.fromCharCode(lWhichASC).toLowerCase();
    strItemName     = (NS4 || W3C) ? e.target.name : e.name;
    strItemValue    = (NS4 || W3C) ? e.target.value : e.value;
    bValidated      = processValidation(strItemValue,cWhichKey,lControl,l_bShowGroupSep);

    if(NS4 || W3C) {
      if (W3C && !bValidated) {
        e.preventDefault();
        e.stopPropagation();
      }
      return bValidated;
    } else {
      if(bValidated)
        return event.returnValue= lWhichASC;
      else
        return event.returnValue=false;
    }
  } else {
   return true;
  }
}

function GetParam(p_strIn, p_strParam) {
  l_strIn    = p_strIn;
  l_strParam = p_strParam;

  if (typeof l_strIn == 'undefined') return "-1";

  l_strIn.toUpperCase();
  l_strParam.toUpperCase();

  lFound  = l_strIn.indexOf(l_strParam + '=');
  lFound2 = l_strIn.indexOf('&',lFound);

  if (lFound == -1) return "-1";
  lFound += l_strParam.length + 1;
  l_strReturn =l_strIn.substring(lFound,lFound2);

  if(isNaN(parseInt(l_strReturn))) l_strReturn = "-1";
  return l_strReturn;
}


//****************************************************
// ValidateFields(l_oForm) - Überprüfung ob Eingabe in Pflichtfelder erfolgt ist
//****************************************************
function ValidateFields(l_oForm) {
  var l_aFormElements = l_aValFieldNames;
  var l_aFormNames    = l_aValFieldTitles;
  var l_bFCheck       = true;
  var l_strReturn     = "\n"+ l_strValAlert +"\n\n\t";
  var l_strFieldFocus = "";
  var l_strValue    = "";
  var l_oField    = null;

  if( GetParam(l_oForm.action,"rq_lSenderId") == "-1") return true;

  for(var l_lCount=0; l_lCount < l_aFormElements.length; l_lCount++) {
    l_oField = l_oForm.elements[l_aFormElements[l_lCount]];
    // Wert für SELECT Controls behandeln
    if(l_oField.type.substr(0,6)=="select") {
      // bei Listenfeldern (size>1) ist beim Aufbau der Seite selectedIndex=-1 
      if(l_oField.selectedIndex < 0) l_oField.selectedIndex = 0;
      if(l_oField.selectedIndex > -1) {
        l_strValue = l_oField[l_oField.selectedIndex].text;
      } else {
        l_strValue = "";
      }
    } else {
      l_strValue = l_oField.value;
    }

    if ((l_strValue == "") || (l_strValue == " ")) {
      if (l_strFieldFocus == "") {
        l_strFieldFocus = l_oField.name;
        l_strReturn += l_aFormNames[l_lCount] + "\n\t";
        l_bFCheck = false;
      }
    }
  }

  if (l_bFCheck == true) {
    return true;
  } else {
    l_oFieldFocus = eval("l_oForm." + l_strFieldFocus);
    alert(l_strReturn);
    if ( l_oFieldFocus.style.display != 'none' ) l_oFieldFocus.focus();
    return false;
  }
}

//****************************************************
// UpDelete() - Bestätigung zum Löschen einholen
//****************************************************
function UpDelete() {
  Check = confirm(l_strDelAlert);
  return Check;
}

//****************************************************
// ListId2Value(p_strFK) - Datapicker  - Wert über die Id holen
//****************************************************
function ListId2Value(p_strFK) {
  l_strFK=p_strFK
  l_strInd=eval("window.document.__UpForm."+l_strFK+".selectedIndex");
  if(typeof l_strInd == 'undefined') return;
  if (l_strInd > -1) {
    l_strVar=eval("window.document.__UpForm."+l_strFK+".options["+l_strInd+"]");
    l_strVar.value=eval("window.document.__UpForm."+l_strFK+".options[window.document.__UpForm."+l_strFK+".selectedIndex].text");
  }
}

//****************************************************
// FetchFKFields(p_strFK,p_strTabPK) - Datapicker  - Werte holen
//****************************************************
function FetchFKFields(p_strFK,p_strTabPK,p_bActDir) {
  if (top.name=="wndInsert") {
    alert(l_strFuncNotAvailable);
    return;
  }
  var l_strFK = p_strFK;
  var l_strTabPK = p_strTabPK;
  var l_obSelect = null;
  var l_strDir;
  if(p_bActDir) {
    l_strDir = "./";
    if(parent && parent.UpAppMain) {
      l_obSelect = eval("parent.UpAppMain.document.__UpForm."+l_strFK);
    } else {
      return;
    }
  } else {
    l_strDir = "../../../_UpInclude/script/";
    l_obSelect = eval("window.document.__UpForm."+l_strFK);
  }
  if(l_obSelect && l_obSelect.options && l_obSelect.options.length > 0 && l_obSelect.selectedIndex > -1) {
    l_lid = l_obSelect.options[l_obSelect.selectedIndex].value;
    l_strPageToOpen = l_strDir + "UpFillCrossRef.asp?rq_strFk="+l_strFK+"&rq_lid="+l_lid+"&rq_TabPK="+l_strTabPK;
    if (parent.UpAppTransfer) parent.UpAppTransfer.location.href=l_strPageToOpen;
  }
}

//****************************************************
// FetchFields(p_strFk,p_strTable,p_strForeignField,p_strType) - Datapicker  - Werte holen
//****************************************************
function FetchFields(p_strFk,p_strTable,p_strForeignField,p_strType,p_lPrecision) {
  if (top.name=="wndInsert") {
    alert(l_strFuncNotAvailable);
    return;
  }
  l_strFK             = p_strFk;
  l_strForeignTable   = p_strTable;
  l_strForeignField   = p_strForeignField;
  l_strForeignType    = p_strType;

  if(p_lPrecision && p_lPrecision!="") {
    l_lPrecision    = p_lPrecision;
  } else {
    l_lPrecision    = "0";
  }

  l_lPrecision    = p_lPrecision;
  l_lSelValue     = eval("window.document.__UpForm." + l_strFK + ".value");
  l_lSelValue     = HexEncodeString(l_lSelValue);
  l_strPageToOpen="../../../_UpInclude/script/UpFillRef.asp?rq_Type=" + l_strForeignType + "&rq_strFk="+l_strFK+"&rq_strValue="+l_lSelValue+"&rq_strForeignField="+l_strForeignField+"&rq_strTable="+l_strForeignTable+"&rq_strPrecision="+l_lPrecision;
  if (parent.UpAppTransfer) parent.UpAppTransfer.location.href=l_strPageToOpen;
}

//****************************************************
// SubmitHandlerCrossRref() - Datapicker
//****************************************************
function SubmitHandlerCrossRref() {
  if(typeof g_arrFK != 'undefined') {
    for (i = 0; i < g_arrFK.length; i++) {
      if(typeof g_arrFK[i] != 'undefined') ListId2Value(g_arrFK[i]);
    }
  }
  l_retVal = ValidateFields(window.document.__UpForm);
  return l_retVal;
}

//****************************************************
// SubmitHandlerMail() - Datapicker
//****************************************************
function SubmitHandlerMail() {
  l_retVal = ValidateFields(window.document.__UpForm);
  if (l_retVal) {
    PromptMailRcpt('');
    return true;
  } else {
    return false;
  }
}

//****************************************************
// Validate_Email(p_strVal) - eMail Adresse prüfen
//****************************************************
function Validate_Email(p_strVal) {
  if (!p_strVal.match(/^.+\@(\[?)[a-zA-Z0-9\-\.]+\.([a-zA-Z]{2,3}|[0-9]{1,3})(\]?)$/g) || p_strVal.search(/(@.*@)|(\.\.)|(@\.)|(\.@)|(^\.)/g) != -1) {
    alert(p_strVal + l_strValidMail);
    return false;
  }
  return true;
}

//****************************************************
// PromptforMail(p_strPromptedDefault) - Nach eMail Adresse fragen
//****************************************************
function PromptforMail(p_strPromptedDefault) {
  l_strPrompted = prompt(l_strPromptMail,p_strPromptedDefault);
  if (l_strPrompted == null) return "";
  if (!l_strPrompted || l_strPrompted=="") {
    alert(l_strNoMail);
    PromptforMail(p_strPromptedDefault);
  }
  if (l_strPrompted != null) {
    l_strPrompted = l_strPrompted.replace(/^ +/g, "");
    l_strPrompted = l_strPrompted.replace(/ +$/g, "");
    l_strPrompted=l_strPrompted.replace(/,+/,";");
    l_strPrompted=l_strPrompted.replace(/ +/,";");
    return l_strPrompted;
  }
  return "";
}

//****************************************************
// PromptMailRcpt(p_strPromptedDefault) 
//****************************************************
function PromptMailRcpt(p_strPromptedDefault) {
  l_strPrompted=PromptforMail(p_strPromptedDefault);
  l_arrPrompted=l_strPrompted.split(";");
  l_strPromptedSendTo="";

  for (i=0;i<l_arrPrompted.length;i++) {
    if ((l_arrPrompted[i]=="") || (l_arrPrompted[i]==" ")) {
      continue;
    } else if (!Validate_Email(l_arrPrompted[i])) {
      PromptMailRcpt(l_strPrompted);
    } else {
      l_strPromptedSendTo=l_strPromptedSendTo + l_arrPrompted[i];
    }
    if (i<l_arrPrompted.length-1) l_strPromptedSendTo=l_strPromptedSendTo + ";"
  }
  l_strPromptedSendTo=l_strPromptedSendTo.replace(/;{2,}/,";");
  l_strPromptedSendTo=l_strPromptedSendTo.replace(/;$/,"");
  document.__UpForm.fr_strMailSendTo.value=l_strPromptedSendTo; 
}

//--------------------------------------------------
function makeOption(p_obSelect,p_strText,p_strValue) {
//--------------------------------------------------
  if(!p_obSelect) return false;
  var l_obNewOption = new Option(p_strText,p_strValue);
  p_obSelect.options[p_obSelect.options.length] = l_obNewOption;
  return true;
}

//--------------------------------------------------
function closeWnd() {
//--------------------------------------------------
  if (top.UpNavigate) {
    if(top.UpNavigate.wndShowUser && !top.UpNavigate.wndShowUser.closed) top.UpNavigate.wndShowUser.close();
    if(top.UpNavigate.SearchWin && !top.UpNavigate.SearchWin.closed) top.UpNavigate.SearchWin.close();
    if(top.UpNavigate.wndWait && !top.UpNavigate.wndWait.closed) top.UpNavigate.wndWait.close();
    if(top.wndPicker && !top.wndPicker.closed) top.wndPicker.close();
    if(top.wndPopUp && !top.wndPopUp.closed) top.wndPopUp.close();
  }
}

//--------------------------------------------------
function ShowSessionTimeOutWarning() {
//--------------------------------------------------
  var wX, wY, oX, oY, wW,sMode;
  var l_strURL = '../../../_UpMisc/login/SessTimeOut.asp';
  wX=420,wY=270;
  oX=(screen.availWidth/2)-(wX/2);
  oY=(screen.availHeight/2)-(wY/2);
  sMode = "dependent=yes,resizable=yes,width="+wX+",height="+wY+",left=" + oX + ",top="+ oY
  wndSess = window.open(l_strURL,"wndSess",sMode);
}

//--------------------------------------------------
function ResetTimeout() {
//--------------------------------------------------
  if(l_lTimeOutVar) {
    window.clearTimeout(l_lTimeOutVar);
    l_lTimeOutVar  = setTimeout('SessionTimeOut()',l_lTimeOut);
  }
  if(l_lTimeOutVar2) {
    window.clearTimeout(l_lTimeOutVar2);
    l_lTimeOutVar2 = setTimeout("ShowSessionTimeOutWarning()",l_lTimeOut2);
  }
}

