//------------------------------------------------
//  Initialize function
//  Browser Detection
//  Language: German locale
//------------------------------------------------
IE4      = (document.all) ? true:false;
W3C      = (document.documentElement && !document.all) ? true:false;
MAXINT   = Math.pow(2,31);
MAXFLOAT = Math.pow(2,63);

//------------------------------------------------
// Initialize function: Detect if we are in an popup or not
// Generating a new Parameter
//------------------------------------------------
try {
  if(parent.window.name == "UpPopup") {
    l_strIsPopup = "&rq_bIsPopup=1";
  } else {
    l_strIsPopup = "";
  }
} catch(e) {
  l_strIsPopup = "";
}

try { 
  top.informerFullScreen==true ? top.setFullScreen(document.getElementById('ResizeSecndLvLButton')) : top.unsetFullScreen(document.getElementById('ResizeSecndLvLButton'))
} catch(e) { 
  void(0);
};

//------------------------------------------------
//  Initialize function
//  Event capturing for Netscape
//------------------------------------------------
if (W3C) {
  document.addEventListener("keypress",processKey,true);
}

//------------------------------------------------
function AppLogout(p_sLOReferer) {
//------------------------------------------------
  if (!l_bAno) {
    var l_objTarget = top;
    if (opener) l_objTarget = opener.top;
    if (parent.opener) l_objTarget = parent.opener.top;
    try {
      l_objTarget.l_strLOQuery = 'dashboard/script/login/logout_refresh.asp?rq_strReferer=' + p_sLOReferer;
      l_objTarget.ResetTimeout();
    } catch(e) { void(0); }
  }
}

//------------------------------------------------
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));
        if ( parseInt(Calculations[i].Target.ixPrecision) >0 ) l_lTemp = Math.round(l_lTemp* Math.pow(10, parseInt(Calculations[i].Target.ixPrecision))) / Math.pow(10, parseInt(Calculations[i].Target.ixPrecision));
        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));
        if ( parseInt(Calculations[i].Target.ixPrecision) >0 ) l_lTemp = Math.round(l_lTemp* Math.pow(10, parseInt(Calculations[i].Target.ixPrecision))) / Math.pow(10, parseInt(Calculations[i].Target.ixPrecision));
        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));
        if ( parseInt(Calculations[i].Target.ixPrecision) >0 ) l_lTemp = Math.round(l_lTemp* Math.pow(10, parseInt(Calculations[i].Target.ixPrecision))) / Math.pow(10, parseInt(Calculations[i].Target.ixPrecision));
        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));
        if ( parseInt(Calculations[i].Target.ixPrecision) >0 ) l_lTemp = Math.round(l_lTemp* Math.pow(10, parseInt(Calculations[i].Target.ixPrecision))) / Math.pow(10, parseInt(Calculations[i].Target.ixPrecision));
        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 prepareDatePicker(withTime) {
  try {
    DATEPICKER.dialog.destroy();
  } catch(e) {}

  DATEPICKER = {withTime:withTime};

  DATEPICKER.datepicker = new Ext.DatePicker({
    startDay:1
  });

  DATEPICKER.hourfield = new Ext.ux.form.SpinnerField({
    minValue:0,
    maxValue:23,
    allowDecimals:false,
    accelerate:true,
    width:42
  });

  DATEPICKER.minutefield = new Ext.ux.form.SpinnerField({
    minValue:0,
    maxValue:59,
    allowDecimals:false,
    accelerate:true,
    width:42
  });

  DATEPICKER.fieldname = new Ext.form.Hidden({});

  DATEPICKER.update = function() {
    var field = document.getElementsByName(DATEPICKER.fieldname.getValue())[0];
    var date = DATEPICKER.datepicker.getValue();
    date.setHours(DATEPICKER.hourfield.getValue());
    date.setMinutes(DATEPICKER.minutefield.getValue());
    DATEPICKER.dialog.hide(field);
    return field.value = DATEPICKER.withTime ? CheckDate(date)+' '+CheckTime(date) : CheckDate(date);
  }

  if (withTime) {
    var panelItems = [
      { border:false, hideLabels:true, columnWidth: .25, layout: 'form', html:'&nbsp;' },
      { border:false, hideLabels:true, columnWidth: .25, layout: 'form', items: [DATEPICKER.fieldname, DATEPICKER.hourfield] },
      { border:false, hideLabels:true, columnWidth: .25, layout: 'form', items: [DATEPICKER.minutefield] },
      { border:false, hideLabels:true, columnWidth: .25, layout: 'form', html:'&nbsp;' }
    ]
  } else {
    var panelItems = []
  }

  DATEPICKER.formpanel = new Ext.form.FormPanel({
    bodyBorder:false,
    border:false,
    bodyStyle:'background:none; border:none',
    hideLabels:true,
    ctCls:'x-no-column-body',
    buttonAlign:'center',
    items: [{
         layout: 'column',
         extraCls:'datetime',
         items: panelItems
    }],
    buttons: [{id: "btnOK", text: "OK", handler:DATEPICKER.update, scope:DATEPICKER }]
  });

  var items = [];
  if (withTime) {
    items = [DATEPICKER.datepicker, DATEPICKER.formpanel];
  } else {
    items = [DATEPICKER.fieldname, DATEPICKER.datepicker, DATEPICKER.formpanel];
  }

  DATEPICKER.dialog = new Ext.Window({
    title:'',
    bodyBorder:false,
    width:192,
    resizable:false,
    items:items
  });
  DATEPICKER.dialog.show();
  DATEPICKER.dialog.hide();

  return DATEPICKER;
}

//------------------------------------------------
function GetDatepickerWindow(p_strFieldname,p_strType,p_strPath) {
//------------------------------------------------
  var field = document.getElementsByName(p_strFieldname)[0];
  var dp = prepareDatePicker(p_strType == "datetime");
  dp.fieldname.setValue(p_strFieldname);

  var currentDate = CheckDate(field.value);
  if (p_strType == "datetime") {
    var currentTime = CheckTime(field.value);
  } else {
    var currentTime = null;
  }

  try {
    var dt = CheckDate(field.value, true);
    var date =  dt[2];
    var month = dt[1];
    var year =  dt[0];
    if (dp.withTime) {
      var tm = CheckTime(field.value, true);
      var hours = tm[0];
      var minutes = tm[1];
    } else {
      var hours = 0;
      var minutes =0;
    }
  } catch(e) {
    var now = new Date();
    var date = now.getDate();
    var month = now.getMonth();
    var year = now.getFullYear();
    var hours = now.getHours();
    var minutes = now.getMinutes();
  }

  var tempDate = new Date();
  tempDate.setDate(date);
  tempDate.setMonth(month-1);
  tempDate.setYear(year);
  tempDate.setHours(hours);
  tempDate.setMinutes(minutes);

  dp.datepicker.setValue(tempDate);
  dp.hourfield.setValue(hours);
  dp.minutefield.setValue(minutes);

  dp.dialog.hide();
  dp.fieldname.setValue(p_strFieldname);
  dp.dialog.alignTo(field, "br?", [5, 5]);
  dp.dialog.show(field);

  return true;
}

//------------------------------------------------
// Function to decide to Popup or not
//------------------------------------------------
function ButtonAction(p_strLink,p_bNewWindow) {
//------------------------------------------------
  if ( p_bNewWindow && window.name != "UpPopup" ) {
    //sepcial case to save regular record
    //and then open a popup window with another page
    if ( /[\?\&]rq_lTargetIdEx/.test(p_strLink) ) {
      window.document.forms[0].action = p_strLink;
      document.forms[0].onsubmit();
      document.forms[0].submit();
      formFreeze(document.forms[0], false);
    } else {
      loadPopup(p_strLink);
    }
  } else {
    window.document.forms[0].action = p_strLink;
    if ( typeof g_arrFK != "undefined" ) {
      if ( SubmitHandlerCrossRref() ) {
        document.forms[0].onsubmit(); // htmlArea3
        document.forms[0].submit();
        formFreeze(document.forms[0], false);
      }
    } else {
      if ( !/[\?\&]rq_bDelete=1/.test(p_strLink) ) {
        if ( ValidateFields(window.document.forms[0]) ) {
          document.forms[0].onsubmit();
          document.forms[0].submit();
          formFreeze(document.forms[0], false);
        }
      } else {
        document.forms[0].onsubmit();
        document.forms[0].submit();
        formFreeze(document.forms[0], false);
      }
    }
  }
  return;
}

//------------------------------------------------
function loadPopup(p_strLink, p_lWindowWidth, p_lWindowHeight) {
//------------------------------------------------
  var oWindow;
  if ( loadPopup.arguments.length == 1 ) {
    var l_lWindowWidth = 380;
    var l_lWindowHeight = 250;
  } else {
    var l_lWindowWidth = p_lWindowWidth;
    var l_lWindowHeight = p_lWindowHeight;
  }
  if (parent.opener && l_bPopUpCustom) {
    oWindow = parent.opener.top.wndPopUpPopUp = window.open("../../../upapplications/upappglobal/popup/popupframeset.asp?rq_strUrl=" + HexEncodeString(p_strLink),"UpPopupPopUp","resizable=yes,width="+l_lWindowWidth+",height="+l_lWindowHeight+"");
    oWindow.focus();
    if(parent.opener.window.name != "UpPopupPopUp") ResetTimeout();
  } else {
    oWindow = top.wndPopUp = window.open("../../../upapplications/upappglobal/popup/popupframeset.asp?rq_strUrl=" + HexEncodeString(p_strLink),"UpPopup","resizable=yes,width="+l_lWindowWidth+",height="+l_lWindowHeight+"");
    oWindow.focus();
    if(window.name != "UpPopup") ResetTimeout();
  }
  //return oWindow;
  // erzeugt bei Nutzung im href eine Umleitung auf [object], daher auskommentiert
}

//------------------------------------------------
function PopUpResizeByContent() {
//------------------------------------------------
  if ( parent.window.name != "UpPopup" && parent.window.name != "UpPopupPopUp" && window.name != "winConfig" ) return;
  if ( /[\?\&]rq_bResizeByContent=false/.test(window.location.search.substring(1)) ) return;

  var doc = this.document;
  if (this.parent) {
    var WinToResize = this.parent;
  } else {
    var WinToResize = this;
  }

  if ( typeof l_lWindowWidth != 'undefined' && typeof l_lWindowHeight != 'undefined' ) {
    WinToResize.resizeTo(l_lWindowWidth,l_lWindowHeight);
  } else {
    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);
}

//------------------------------------------------
// put datas in two boxes add left add right ,clear list and set init values 
 //------------------------------------------------
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)].style.backgroundColor = l_spOld.style.backgroundColor;
        that.options[(j+1)] = new Option(l_spNew.text,l_spNew.value);
        that.options[(j+1)].style.backgroundColor = l_spNew.style.backgroundColor;
        try { that.options[(j+1)].selected = true; } 
        catch(e) { that.options[(j)].selected = true; }
      }
    }
    if ( OptionJuggler.arguments.length == 5 ) RefreshValue(p_strRight,p_strName);
  }

  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)].style.backgroundColor = l_spOld.style.backgroundColor;
        that.options[(i-1)] = new Option(l_spNew.text,l_spNew.value);
        that.options[(i-1)].style.backgroundColor = l_spNew.style.backgroundColor;
        try { that.options[(i-1)].selected = true; }
        catch(e) { that.options[(i)].selected = true; }
      }
    }
    if ( OptionJuggler.arguments.length == 5 ) RefreshValue(p_strRight,p_strName);
  }
}

//------------------------------------------------
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_oRight.options[l_oRight.length-1].style.backgroundColor = l_oLeft.options[l_lSelected].style.backgroundColor;
    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_oLeft.options[l_oLeft.length-1].style.backgroundColor = l_oRight.options[l_lSelected].style.backgroundColor;
    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");
  }
  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");
    } else {
      top.wndInsert = open(l_strPath,"wndInsert","menubar=no,toolbar=no,dependent=yes,resizable=yes,scrollbars=yes,width=600,height=400");
      top.wndInsert.focus();
    }
  }
  return;
}

//------------------------------------------------
//  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
  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, p_bReturnArray) {
//------------------------------------------------
  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;

  if (p_strDate.constructor == Date) {
    // no parsing required, already a JS date
    l_iYear = p_strDate.getFullYear();
    l_iMonth = p_strDate.getMonth()+1;
    l_iDay = p_strDate.getDate();
  } else {
    // date in text format
    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);

  if (p_bReturnArray == true) {
    return new Array(parseInt(l_iYear),parseInt(l_iMonth),parseInt(l_iDay))
  }
  else {
    // 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, p_bReturnArray) {
//------------------------------------------------
  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;
  }

  if (p_strTime.constructor == Date) {
    l_iHour        = p_strTime.getHours();
    l_iMinutes     = p_strTime.getMinutes();
    l_iSeconds     = p_strTime.getSeconds();
  } else {
    l_re = /(?:\D*)(\d{1,2})[\:\.]?(\d{2})?[\:\.]?(\d{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 ( l_iHour == 24 ) { l_iHour = 0; }

  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_iMinutes,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 (p_bReturnArray == true) {
    if ( !l_b24hours && !l_bPM && l_iHour == 12 ) l_iHour = 0;
    if ( !l_b24hours && l_bPM ) l_iHour += 12;
    return new Array(parseInt(l_iHour),parseInt(l_iMinutes),parseInt(l_iSeconds))
  }
  else {
    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 (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 (W3C) {
      lWhichASC = e.which;
    } else {
      lWhichASC = event.keyCode;
    }

    if(lWhichASC == 0) return true;
    if(lWhichASC == 8) return true;

    cWhichKey       = String.fromCharCode(lWhichASC).toLowerCase();
    strItemName     = (W3C) ? e.target.name : e.name;
    strItemValue    = (W3C) ? e.target.value : e.value;
    bValidated      = processValidation(strItemValue,cWhichKey,lControl,l_bShowGroupSep);

    if(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.forms[0]."+l_strFK+".selectedIndex");
  if(typeof l_strInd == 'undefined') return;
  if (l_strInd > -1) {
    l_strVar=eval("window.document.forms[0]."+l_strFK+".options["+l_strInd+"]");
    l_strVar.value=eval("window.document.forms[0]."+l_strFK+".options[window.document.forms[0]."+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.forms[0]."+l_strFK);
    } else {
      return;
    }
  } else {
    l_strDir = "../../../_UpInclude/script/";
    l_obSelect = eval("window.document.forms[0]."+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.forms[0]." + 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.forms[0]);
  return l_retVal;
}

//------------------------------------------------
// SubmitHandlerMail() - Datapicker
//------------------------------------------------
function SubmitHandlerMail() {
//------------------------------------------------
  l_retVal = ValidateFields(window.document.forms[0]);
  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 E-Mail 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.forms[0].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(self.wndShowPic && !self.wndShowPic.closed) self.wndShowPic.close();
    if(self.wndPrint && !self.wndPrint.closed) self.wndPrint.close();
    if(self.wndHelp && !self.wndHelp.closed) self.wndHelp.close();
    if(top.wndPicker && !top.wndPicker.closed) top.wndPicker.close();
    if(top.wndPopUp && !top.wndPopUp.closed) top.wndPopUp.close();
    if(top.wndPopUpPopUp && !top.wndPopUpPopUp.closed) top.wndPopUpPopUp.close();
  }
}

//------------------------------------------------
function ResetTimeout() {
//------------------------------------------------
  try {
    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);
    }
  } catch(e) {
    void(0);
  }
}

//--------------------------------------------------
function skipWriteProtectedElement(name) {
//--------------------------------------------------
  form_length = document.forms[0].elements.length;
  form = document.forms[0];
  for (i=0;i<form_length;i++) {
    if (form.elements[i].type!=null) { // <= das verhindert Probleme mit fieldset
      if (name == form.elements[i].name) {
        //letztes Element
        if (i+1>=form_length) {
          start=0;
        } else {
          start=i+1;
        }
        for(j=start;j<form_length;j++) {
          if (form.elements[j].type!=null) { // <= das verhindert Probleme mit fieldset
            ele_type = form.elements[j].type;
            ele_style = document.forms[0].elements[i].style;  // <= das verhindert Probleme mit ausgeblendeten Layern
            if(ele_style != "hidden" && ele_type != "hidden" && form.elements[j].name.substr(0,6) != "SetRow") {
              form.elements[j].focus();
              return;
            }
          }
        }
        //Element(e) nach schreibgeschütztem Feld sind Hidden
        return;
      }
    }
  }
}

//--------------------------------------------------
function executeOnKeyCode(event, keycode, action) {
//--------------------------------------------------
  try{
    window.event ? event=window.event : void(0);
    parseInt(keycode)==event.keyCode ? void(eval(action)) : void(0);
  }catch(e){alert(e)}
  return true;
}