// Bookmark zufügen
function AddToFavorites() {

 var title = "white - the maschine to machine SIMCard";

 var url = "http://www.dtag.de";

	if (window.sidebar)  // Mozilla Firefox Bookmark
		window.sidebar.addPanel(title, url, "");
	else if( window.external )  // IE Favorite
		window.external.AddFavorite(url, title);
	else if(window.opera && window.print) { // Opera
   var mbm = document.createElement('a');

   mbm.setAttribute('rel', 'sidebar');
   mbm.setAttribute('href', url);
   mbm.setAttribute('title', title);
   mbm.click();
 }
}


/* -----------------------------------------------------------------

   03.10.07
   Funktion zur Überprüfung der Belegung von Eingabefelder ( <input type='text|textarea'> )

   in:
      form (object):           Formular, dessen Felder geprüft werden sollen
      cssClassLabel (string):  CSS-Klasse, die dem Eingabefeld zugeordneten Beschriftungsfeld bei
                               fehlerhafter Validierung zugewiesen wird.
      cssClassInput (string):  CSS-Klasse, die dem Eingabefeld bei
                               fehlerhafter Validierung zugewiesen wird.

      [doAlert (bool)]:   true (default): es wird eine Messagebox mit einem Fehlertext ausgeben
      [msg (string)]:     allgemeiner Meldungstext für die Messagebox. Falls nicht gesetzt wird ein Standardtext
                          verwendet

   out:
      true:      alle Eingabefelder sind gültig validiert
      false:     mindestens ein Eingabefeld entspricht nicht der Vorgabe

   require:
      prototyp.js         siehe http://www.prototype.org

   Implementation:
   ---------------

   Die zu prüfenden Eingabefelder müssen ein zugehöriges Beschriftungsfeld <label> aufweisen.
   Die logische Verknüpfung zwischen <label> und <input> erfolgt gemäß HTML-Spezifikation mit dem Attribut for="..."
   innerhalb des <label>-Tags.

   Über ein geeignetes Attribut class="...", das dem Label zugewiesen ist, wird der Prüfungsmechanismus für das
   Eingabefeld definiert. Verwendet wird ein fixer Prefix 'mandatory'. Über ggf. angehangene Suffixe kann die
   Validierung vollkommen frei gestaltet werden.

   Folgende Modi werden unterstützt, class=
     "mandatory":      Das Eingabefeld muss wenigstens ein beliebiges Zeichen enthalten (typisches Pflichtfeld)
     "mantatoryEmail": Prüfung auf gültige Email-Adresse
     "mandatoryPhone": Prüfung auf gültige Telefonnummer, d.h [+-/] im String sind erlaubt
     "mandatory<rE>":  Als <rE> kann ein beliebiger regulärer Ausdruck angegeben werden.

   Bei fehlerhafter Validierung wenigstens eines Eingabefeldes:
     - für die zugehörge Beschriftungsfelder werden zusätzlich zu bereits vorhandenen Klassen
       die als Parameter übergebene Klasse 'cssClass' gesetzt.
     - je nach Übergabeparameter wird eine Alertbox ausgegeben.
     - der Focus wird auf das erste fehlerhaft gefüllte Eingabefeld gesetzt


   Beispiel:

   <style type="text/css">
      alert { color: red; font-weight: bold; }
   </style

   <form name="DataForm" method="post" action="#link#'>
     <label class="class123 mandatory/\S{5,} class456" for="ID">Benutzerkennung:</label>
     <input type="text" id="ID" name="UserId" />
   </form>

   Beim Absenden des Formulars wird geprüft, ob das Eingabefeld wenigstens 5 Zeichen enthält

------------------------------------------------------------------*/


function validateForm (form, cssAlertLabel, cssAlertInput, doAlert, msgAlert) {

 var rE_mandatory = /(^|\s+)mandatory($|\s+|(\/.*[^\/]\/|Email|Phone|Kto|Blz)($|\s+))/i;
 var rE_free = /(^|\s+)free($|\s+|(\/.*[^\/]\/|Email|Phone|Kto|Blz)($|\s+))/i;
 var blnDoAlert = (arguments.length >= 4 ? doAlert : true);
 var nIncorrect = 0;
 var alabel = form.getElementsByTagName("Label");   // Array aller <label>-Tags
 var blnValid, elem, label, cls, reg, aresult, errorDiv;

 for (var i = 0; i < alabel.length; i++) {

   label = alabel[i];
   $(label);      // IE benötigt explizite Konvertierung !

   /* Label und zugehöriges Input-Feld prüfen
      - Label benötigt "class="
      - Label benötigt "for="
      - "for="  muss auf ein vorhandenes Input-Feld verweisen
   */

   if ((cls = label.attributes["class"])
      && label.attributes["for"]
      && (elem = $(label.attributes["for"].value))
      && (elem.type == "text" || elem.type == "textarea" || elem.type == "checkbox" || elem.type == "select-one")) {

      if (aresult = rE_mandatory.exec(cls.value)
         || (elem.value.length && (aresult = rE_free.exec(cls.value)))) {                   // mit Validierungs-Deklaration

         /* Debug
         var msg = "";
         for (var j = 0; j < aresult.length; j++)
            msg += j + ": @" + aresult[j] + "@\n";

           alert (msg);
         */

         /* Achtung: bei rA in Strings sind ggf. Sondernzeichen wie \r, \s, etc. durch einen
                     zweiten Schrägstrich zu maskieren */
         switch (aresult[3]) {
            case "Email" :
               // gültige Email-Adresse gemäß RFC 2822 + RFC 1034/35
               reg = new RegExp ("^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]{1,64}@[a-zA-z0-9-]{1,63}\\.([a-zA-z0-9-]{1,63}\\.?)+$");
               break;

            case "Phone" :
               // gültige Telefonnummer
               reg = new RegExp ("^\\+?[0-9\\s()/-]{7,25}$");
               break;

            case "Kto" :
               // gültige Kontonummer (maximal 10 Ziffern)
               reg = new RegExp ("^([0-9]\\s*){1,10}$");
               break;

            case "Blz" :
               // gültige Bankleitzahl (mindestens 8 Ziffern)
               reg = new RegExp ("^([0-9]\\s*){8}$");
               break;

            case undefined :     // FF und Opera */
            case "" :            // IE liefert leere Zeichenkette zurück
               // Pflichtfeld ohne Vorgabe, mindestens ein sichtbares Zeichen am Anfang
               reg = new RegExp ("^\\S");
               break;

            default :
               // regulärer Ausdruck
               // Trennzeichen '/' am Anfang und Ende aus dem String entfernen
               reg = new RegExp (aresult[3].slice(1, aresult[3].length - 1));
         }

         // Div für Fehlermeldung identifizieren
         errorDiv = $("error" + (elem.id));

         switch (elem.type) {
           case "text" :
           case "textarea" :
           case "select-one" :
              blnValid = reg.exec (elem.value);
              break;

           case "checkbox" :
              blnValid = elem.checked;
              break;
         }

         if (blnValid) {
            // wenn Vorgabe erfüllt, dann Style zurücksetzen
            if (cssAlertLabel)
               label.removeClassName (cssAlertLabel);
            if (cssAlertInput)
               elem.removeClassName (cssAlertInput);

            if ( ! blnDoAlert && errorDiv)
               errorDiv.hide();

         } else {
            if (nIncorrect++ == 0)
               elem.focus();   // Fokus auf erstes fehlerhaft gefülltes Feld setzen

            if (cssAlertLabel)
               label.addClassName (cssAlertLabel);
            if (cssAlertInput)
               elem.addClassName (cssAlertInput);

            if ( ! blnDoAlert && errorDiv)
               errorDiv.show ("block");
         }
      }
   }
 }

 if (nIncorrect) {
    if (blnDoAlert) {
       msg = (msgAlert ? msgAlert :
	        (nIncorrect == 1 ? "Das markierte Eingabefeld ist" :
	          "Die markierten " + nIncorrect + " Eingabefelder sind") + " nicht vollständig oder korrekt ausgefüllt.");

	      alert (msg);
	   }

 } else if (form.postValidate)
    form.postValidate.value = "0";

 return (nIncorrect == 0);
}

function validatePW (pw1, pw2, doAlert, msgAlert) {

 // Div für Fehlermeldung identifizieren
 errorDiv = $("error" + (pw1.id) + (pw2.id));

 if (pw1.value !== pw2.value) {
    var blnDoAlert = (arguments.length >= 3 ? doAlert : true);

    if (blnDoAlert) {
       msg = (msgAlert ? msgAlert :
	         "Die eingegebenen Passwörter sind nicht identisch. Bitte wiederholen Sie die Eingabe.");

	      alert (msg);
    } else if (errorDiv)
       errorDiv.show ("block");

    pw2.focus();
    return false;
 }

 if (errorDiv)
    errorDiv.hide();

 return true;
}