<!--
  /*
    *************************************************************************************
    * Datei:              functionlib.js                                                *
    * Erstellt am:        03.06.2003                                                    *
    * Letzte Änderung am: 03.03.2004                                                    *
    * Zweck:              Sammlung nützlicher Funktionen zum Abprüfen von               *
    *                     Formulareingaben                                              *
    *                                                                                   *
    * Alle Funktionen im Überblick:                                                     *
    *  - bool IsBlank (mixed val)                                                       *
    *  - bool IsNumeric (mixed val [, string dezimal])                                  *
    *  - bool IsInteger (mixed val)                                                     *
    *  - bool IsDate (mixed val)                                                        *
    *  - bool IsTime (mixed val)                                                        *
    *  - bool IsDateTime (mixed val)                                                    *
    *  - bool IsEmail (mixed val)                                                       *
    *  - bool IsEAN (mixed val)                                                         *
    *  - bool IsIMEI (mixed val)                                                        *
    *  - mixed ElementValue (mixed strForm, mixed strElement)                           *
    *  - double RoundUp (double val [, int precision])                                  *
    *  - void FormatDate (mixed val)                                                    *
    *  - void FormatTime (mixed val)                                                    *
    *  - void FormatDateTime (mixed val)                                                *
    *  - void clickRadio(object objElement, myRadioButton objRadioButton)               *
    *  - void replaceSelection(string strElement, string strTagBegin, string strTagEnd) *
    *************************************************************************************
  */


  // Funktion prüft, ob die übergebene Zeichenkette leer ist.
  // -------------------------------------------------------------------------
  function IsBlank(val) {
    if(val == null) {
      return(true);
    }
    else if(val == "") {
      return(true);
    }
    else {
      return(false);
    }
  }


  // Funktion prüft, ob die übergebene Zeichenkette numerisch ist.
  // Für die Variable dezimal sind die Werte Punkt oder Komma erlaubt, 
  // fehlt die Angabe, wird der Punkt verwendet.
  // -------------------------------------------------------------------------
  function IsNumeric(val,dezimal) {
    if(IsBlank(val)) {
      return(true);
    }
    else {
      switch(dezimal) {
        case ".":
          var strPaddern = /^\d+([.]\d+)?$/;
        break;
        case ",":
          var strPaddern = /^\d+([,]\d+)?$/;
        break;
        default:
          var strPaddern = /^\d+([.]\d+)?$/;
        break;
      }
      return(strPaddern.test(val));
    }
  }


  // Funktion prüft, ob die übergebene Zeichenkette vom Typ integer ist.
  // -------------------------------------------------------------------------
  function IsInteger(val) {
    if(IsBlank(val)) {
      return(true);
    }
    else {
      var strPaddern = /^\d+$/;
      return(strPaddern.test(val));
    }
  }


  // Funktion prüft, ob die übergebene Zeichenkette ein Datum im Format
  // TAG.MONAT.JAHR ist. Folgende Formate sind gültig:
  //   - TAG   (T oder TT) 
  //   - MONAT (M oder MM)
  //   - JAHR  (JJJJ)
  // -------------------------------------------------------------------------
  function IsDate(val) {
    if(IsBlank(val)) {
      return(true);
    }
    else {
      if(val.length <= 10) {
        var result = val.search(/^(\d{1,2})\.(\d{1,2})\.(\d{2}|\d{4})$/);
        if(result != -1) {
          var d = parseInt(RegExp.$1,10);
          var m = parseInt(RegExp.$2,10)-1; // Monatszahl beginnt bei 0 in Javascript
          var y = parseInt(RegExp.$3,10);
          if(y < 100) y = (y < 30)?2000+y:1900+y; // bei 2-stelliger Jahreszahl wird der Bereich 1930 - 2029 verwendet
          var myDate = new Date(y,m,d);
          if((d == myDate.getDate()) && (m == myDate.getMonth()) && (y == myDate.getFullYear())) {
            return(true);
          }
          else {
            return(false);
          }
        }
        else {
          return(false);
        }
      }
      else {
        return(false);
      }
    }
  }
  

  // Funktion prüft, ob die übergebene Zeichenkette eine Zeitangabe im Format
  // STUNDE:MINUTE:SEKUNDE ist. Folgende Formate sind gültig:
  //   - STUNDE  (h oder hh) 
  //   - MINUTE  (m oder mm)
  //   - SEKUNDE (s oder ss)
  // -------------------------------------------------------------------------
  function IsTime(val) {
    if(IsBlank(val)) {
      return(true);
    }
    else {
      if(val.length <= 8) {
        var result = val.search(/^(\d{1,2})[:](\d{1,2})[:](\d{1,2})$/);
        if(result != -1) {
          var h = parseInt(RegExp.$1,10);
          var m = parseInt(RegExp.$2,10);
          var s = parseInt(RegExp.$3,10);
          if((h >= 0) && (h <= 23) && (m >= 0) && (m <= 59) && (s >= 0) && (s <= 59)) {
            return(true);
          }
          else {
            return(false);
          }
        }
        else {
          return(false);
        }
      }
      else {
        return(false);
      }
    }
  }
  
  // Funktion prüft, ob die übergebene Zeichenkette eine Datum- und Zeitangabe
  // im Format TAG.MONAT.JAHR STUNDE:MINUTE:SEKUNDE ist.
  // -------------------------------------------------------------------------
  function IsDateTime(val) {
    if(IsBlank(val)) {
      return(true);
    }
    else {
      if(val.length <= 19) {
        var result = val.search(/^(\d{1,2})\.(\d{1,2})\.(\d{2}|\d{4})\s(\d{1,2})[:](\d{1,2})[:](\d{1,2})$/);
        if(result != -1) {
          var aryDateTime = val.split(" ");
          if(IsDate(aryDateTime[0]) && IsTime(aryDateTime[1])) {
            return(true);
          }
          else {
            return(false);
          }
        }
        else {
          return(false);
        }
      }
      else {
        return(false);
      }
    }
  }


  // Funktion prüft, ob die übergebene Zeichenkette eine E-Mail-Adresse ist.
  // -------------------------------------------------------------------------
  function IsEmail(val) {
    if(IsBlank(val)) {
      return(true);
    }
    else {
      var strPaddern = /^([0-9a-zA-Z_-]+\.)*[0-9a-zA-Z_-]+@([0-9a-zA-Z_-]+\.)*[0-9a-zA-Z_-]+\.[a-zA-Z]{2,4}$/;
      return(strPaddern.test(val));
    }
  }


  // Funktion prüft, ob die übergebene Zeichenkette eine EAN-Nummer ist.
  // -------------------------------------------------------------------------
  function IsEAN(value) {
    if(IsBlank(value)) {
      return(true);
    }
    else {
      var strPaddern = /^[0-9]{13}$/;
      if(strPaddern.test(value)) {
        var pz = value.substr(12,1);
        var multi = 3, sum = 0;
        for(var i=11;i>=0;i--) {
          sum += value.substr(i,1) * multi;
          multi = -multi+4;
        }
        var result = 10-sum%10;
        if(pz == result) {
          return(true)
        }
        else {
          return(false)
        }
      }
      else {
        return(false);
      }
    }
  }

  // Funktion prüft, ob die übergebene Zeichenkette eine IMEI-Nummer ist.
  // -------------------------------------------------------------------------
  function IsIMEI(val) {
    if(IsBlank(val)) {
      return(true);
    }
    else {
      var strPaddern = /^([0-9]{15}|[0-9]{17})$/;
      if(strPaddern.test(val)) {
        if(val.length == 17) {
          val = val.substr(0,15);
        }
        if(val == 0) {
          return(false);
        }
        var pz = val.substr(14,1);
        var multi = 2, summe = 0, sum, prod;
        for(var i=13;i>=0;i--) {
          prod = val.substr(i,1) * multi;
          prod = prod.toString();
          sum = 0;
          for(var j=0;j<prod.length;j++) {
            sum += parseInt(prod.substr(j,1));
          }
          summe += sum;
          multi = -multi+3;
        }
        var result = 10-summe%10;
        result = (result == 10)?0:result;
        if(pz == result) {
          return(true);
        }
        else {
          return(false);
        }
      }
      else {
        return(false);
      }
    }
  }


  // Funktion gibt den aktuellen Wert eines Formularfelds zurück.
  // -------------------------------------------------------------------------
  function ElementValue(strForm,strElement) {
    var strValue = "";
    
    // Name des Formulars und des Formularfelds prüfen
    if(IsBlank(strForm) || IsBlank(strElement)) {
      return(undefined);
    }
    else if(typeof(document.forms[strForm]) == "undefined") {
      return(undefined);
    }
    else if(typeof(document.forms[strForm].elements[strElement]) == "undefined") {
      return(undefined);
    }
    
    // Existenz des Formularfelds prüfen
    var blnMultiple = false;
    if(typeof(document.forms[strForm].elements[strElement].name) == "undefined") {
      if(typeof(document.forms[strForm].elements[strElement][0].name) == "undefined") {
        return(undefined);
      }
      else {
        blnMultiple = true;
      }
    }
    var objElement = document.forms[strForm].elements[strElement];
    
    // Type des Formularfelds ermitteln
    if(blnMultiple) {
      var strType = objElement[0].type;
    }
    else {
      var strType = objElement.type;
    }

    // Anzahl der gruppierten Elemente des Formularfelds ermitteln
    var intCount = objElement.length;
    if(typeof(intCount) == "undefined") {
      intCount = 1;
    }
    
    // Wert des Formularfelds abhängig vom Typ ermitteln
    var i;
    if((strType == "hidden") || (strType == "text") || (strType == "textarea") || (strType == "password")) {
      // wenn Formularfeld vom Typ hidden, text, textarea, password
      if(intCount > 1) {
        for(i=0;i<intCount;i++) {
          if(strValue != "") {
            strValue += ", ";
          }
          strValue += objElement[i].value;
        }
      }
      else {
        strValue = objElement.value;
      }
    }
    else {
      switch(strType) {
        // wenn Formularfeld vom Typ radio
        case "radio":
          for(i=0;i<intCount;i++) {
            if(objElement[i].checked) {
              strValue = objElement[i].value;
            }
          }
        break;
        // wenn Formularfeld vom Typ checkbox
        case "checkbox":
          if(intCount > 1) {
            for(i=0;i<intCount;i++) {
              if(objElement[i].checked) {
                if(strValue != "") {
                  strValue += ", ";
                }
                strValue += objElement[i].value;
              }
            }
          }
          else {
            if(objElement.checked) {
              strValue = objElement.value;
            }
          }
        break;
        // wenn Formularfeld vom Typ select-one
        case "select-one":
          strValue = objElement.options[objElement.selectedIndex].value;
        break;
        // wenn Formularfeld vom Typ select-multiple
        case "select-multiple":
          for(i=0;i<intCount;i++) {
            if(objElement[i].selected) {
              if(strValue != "") {
                strValue += ", ";
              }
              strValue += objElement[i].value;
            }
          }
        break;
      }
    }
    return(strValue);
  }


  // Funktion rundet den Eingabewert val auf precision Stellen nach 
  // dem Komma auf. Fehlt precision, wird auf die nächte ganze Zahl 
  // aufgerundet.
	function RoundUp(val,precision) {
	  if(IsBlank(val)) {
	    return(undefined);
	  }
	  else if(isNaN(val)) {
	    return(NaN);
	  }
	  else {
      if(IsBlank(precision)) {
        return(Math.ceil(val));
      }
      else if(isNaN(precision)) {
        return(NaN);
      }
      else {
        return(Math.ceil(val*Math.pow(10,precision))/Math.pow(10,precision));
      }
  	}
	}


  // Funktion formatiert ein gültiges Datum lt. Funktion IsDate() in das 
  // Format TT.MM.JJJJ
  // -------------------------------------------------------------------------
  function FormatDate(val) {
    if(IsBlank(val)) {
      return(undefined);
    }
    else if(IsDate(val)) {
      var fldDate = val.split(".");
      var d = (fldDate[0].length<2)?("0"+fldDate[0]):fldDate[0];
      var m = (fldDate[1].length<2)?("0"+fldDate[1]):fldDate[1];
      var y = parseInt(fldDate[2],10);
      if(y < 100) y = (y < 30)?2000+y:1900+y; // bei 2-stelliger Jahreszahl wird der Bereich 1930 - 2029 verwendet
      return(d + "." + m + "." + y);
    }
    else {
      return(undefined);
    }
  }
  

  // Funktion formatiert eine gültige Zeitangabe lt. Funktion IsTime() in das 
  // Format hh:mm:ss
  // -------------------------------------------------------------------------
  function FormatTime(val) {
    if(IsBlank(val)) {
      return(undefined);
    }
    else if(IsTime(val)) {
      var fldDate = val.split(":");
      var h = (fldDate[0].length<2)?("0"+fldDate[0]):fldDate[0];
      var m = (fldDate[1].length<2)?("0"+fldDate[1]):fldDate[1];
      var s = (fldDate[2].length<2)?("0"+fldDate[2]):fldDate[2];
      return(h + ":" + m + ":" + s);
    }
    else {
      return(undefined);
    }
  }
  
  function FormatDateTime(val) {
    if(IsBlank(val)) {
      return(undefined);
    }
    else if(IsDateTime(val)) {
      var aryDateTime = val.split(" ");
      return(FormatDate(aryDateTime[0]) + " " + FormatTime(aryDateTime[1]));
    }
    else {
      return(undefined);
    }
  }
  
  // Funktion clickRadio dient zum dekativieren von Radiobuttons.
  // -------------------------------------------------------------------------
  function clickRadio(objElement,objRadioButton) {
    var i, intIndex, intCount;
    intCount = document.forms[objElement.form.name].elements[objElement.name].length;
    for(i=0;i<intCount;i++) {
      if(document.forms[objElement.form.name].elements[objElement.name][i].value == objElement.value) {
        intIndex = i;
      }
    }
    if((intIndex == objRadioButton.getIndex()) && objRadioButton.getChecked()) {
      objElement.checked = false;
    }
    objRadioButton.setIndex(intIndex);
    objRadioButton.setChecked(objElement.checked);
  }
  

  // Objekt myRadiobutton dient zum dekativieren von Radiobuttons.
  // -------------------------------------------------------------------------
  function myRadioButton() {
  	var intIndex = -1;
  	var blnChecked = false;
  	
    this.getIndex = getIndex;
    this.setIndex = setIndex;
    this.getChecked = getChecked;
    this.setChecked = setChecked;

    function getIndex() {
      return(intIndex);
    }
    function setIndex(parameter) {
      intIndex = parameter;
    }
    function getChecked() {
      return(blnChecked);
    }
    function setChecked(parameter) {
      blnChecked = parameter;
    }
  }
  
  // Funktion replaceSelection ersetzt einen selektieren Text in einem Formularfeld
  // -------------------------------------------------------------------------
  function replaceSelection(strElement,strTagBegin,strTagEnd) {
    if(document.selection) {
      if(document.selection.createRange().text != "") {
        if(document.selection.createRange().parentElement().name == strElement) {
          document.selection.createRange().text = strTagBegin + document.selection.createRange().text + strTagEnd;
        }
        else {
          alert("Die Textformatierung im Feld \"" + document.selection.createRange().parentElement().name + "\" ist nicht möglich!");
        }
      }
      else {
        alert("Kein Text markiert!");
      }
    }
  }

  // Funktion öffnet ein JS-Fenster
  // -------------------------------------------------------------------------
  function ow(sURL,iWidth,iHeight) {
    var strURL = sURL;
    var intWidth = iWidth;
    var intHeight = iHeight;
    var objWin = window.open(strURL,"Fenster","width=" + intWidth + ",height=" + intHeight + ",scrollbars=1,menubar=1").focus();
  }
//-->