/*
 * Copyright 2007 Alex Bell
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Author: AlexBell (latest modification by $Author: ganeshpuri $)
 * Version: $Revision: 1.20 $ $Date: 2008/06/26 06:26:31 $
 *
 */
  /************************************* COMMON ****************************************************/
    var jsfKeywords = ["jsf_sequence", "jsf_tree_64", "jsf_viewid", "jsf_state_64", "javax.faces.ViewState"]
  /******************************** Namespace ******************************************************/
    if(!window.org) window.org = {};
    if(!org.j4fry) org.j4fry = {};
    if(!org.j4fry.common) org.j4fry.common = {};
  /*********************************** Class Array ***************************************************/
    /*
     * Durchsucht eine Array nach einem String
     * param {String} string_name - String nach dem in Array gesucht werden soll
     */
    Array.prototype.contains = function(string_name) {
      for(var i=0; i<this.length; i++) {
        if(this[i] == string_name) {
          return true;
        }
      }
      return false;
    };

    /*
     * Wandelt ein Array in einen String
     * @param {String} delimiter - Delimiter mit dem die Array-Elemente voneinander getrennt werden
     */
    Array.prototype.toString = function(delimiter) {
      var result = "";
      for(var i=0; i<this.length; i++) {
        result += ((delimiter == null) ? ("[" + i + "] ") : "") + this[i];
        if(i != this.length-1) result += (delimiter == null) ? "\n" : delimiter;
      }
      return result;
    };

  /********************************* Class String *****************************************************/
    /*
     * Nimmt vor und hinter dem String die Leerzeichen weg
     */
    String.prototype.trim = function() {
      var i=0; var x=this.length-1;
      for(; this.charAt(i) == " "; i++) {}
      for(; this.charAt(x) == " "; x--) {}
      return this.substring(i,x+1);
    };
    
    /*
     * Splittet ein Array anhand von Delimiter und gibt letztes Element zurück
     */
    String.prototype.splitAndGetLast = function(delimiter) {
	  var arr = this.split(delimiter);
	  return arr[arr.length-1];	
    }; 
  /*************************************************************************************************/

  /**************************** Class Exception ************************************************/
  org.j4fry.common.Exception = function(sourceClass, threshold) {
    this.m_class = sourceClass
    this.m_threshold = threshold
  };

  org.j4fry.common.Exception.prototype.throwError = function(func, exception) {
    if(this.m_threshold == "ERROR") {
   	 alert("[J4Fry ERROR]\n\n" +
      		 "Affected Class: " + this.m_class + "\n" +
            "Affected Method: " + func + "\n" +
      		 "Error name: " + exception.name + "\n" +
            "Error message: " + exception.message + "\n" +
            "Error description: " + exception.description + "\n" +
            "Error number: " + exception.number + "\n" +
            "Error line number: " + exception.lineNumber +
            "\n\nIf the error occurs many times, \nplease contact one of the J4Fry members on http://www.j4fry.org");
    }
    this.destroy();
  };

  org.j4fry.common.Exception.prototype.throwWarning = function(func, message) {
    if(this.m_threshold == "WARNING" || this.m_threshold == "ERROR") {
       alert("[J4Fry WARNING]\n[" + this.m_class + "::" + func + "]\n\n" + message);
    }
    this.destroy();
  };

  org.j4fry.common.Exception.prototype.destroy = function() {
  	if(requestQueue != null) {
    		// clear RequestQueue when an exception occurs
    		requestQueue.clearQueue();
     }
  };
  /*************************************************************************************************/

  /******************************** Class Page *****************************************************/
    org.j4fry.common.Page = function(alarmThreshold) {
      // speichert onClick-Event von Links und disable-Zustand von Buttons falls diese gesetzt sind
      this.m_componentAttributeCache = new Array();
      // speichert alle Components die gedisabled wurden
      this.m_componentCache = new Array();
      // Flag das bestimmt ob bestimmte Elemente gedisabled werden sollen (anhand ID)
      this.m_certainElementFlag = false;
      // Exception Objekt
      this.alarmThreshold = alarmThreshold;
      this.PARTIAL_PREFIX = "_j4fry_partial_submit_";
      this.m_exception = new org.j4fry.common.Exception("Page", this.alarmThreshold);
    };
    
    /*
     * Dupliziert ein Element und erstellt dafür einen Platzhalter
     * @param {HTML Element} item - Elements für das ein Platzhalter erstelle werden soll
     * @param {String} backgroundColor - Hintergrundfarbe für den Platzhalter
     * @param {String} borderStyle - Rahmen für den Platzhalter
     */
    org.j4fry.common.Page.prototype.createPlaceholder = function(item, backgroundColor, borderStyle) {
      try {
          // höhe und breite ermitteln
      	  var placeholderWidth, placeholderHeight = 0;
      	  if(item.clientWidth && item.clientHeight) {
      	  	placeholderWidth = item.clientWidth;
      	  	placeholderHeight = item.clientHeight;
      	  }
      	  if(item.scrollWidth && item.scrollHeight) {
      	  	placeholderWidth = item.scrollWidth;
      	  	placeholderHeight = item.scrollHeight;
      	  }
      	  
          // placeholder erstellen
		  var placeholder = document.createElement("p");
		  placeholder.style.height = placeholderHeight;
		  placeholder.style.width = placeholderWidth;          
          placeholder.style.backgroundColor = backgroundColor;
          placeholder.style.border = borderStyle;
          placeholder.style.padding = "0";
          placeholder.style.margin = "0";

          // parentItem und nachgelagertes Item (auf der gleichen DOM-Ebene) ermitteln
          var parentItem = item.parentNode;
          var nextItem = item.nextSibling;

          // hinzufuegen des neuen Items
          if(nextItem != null) {
            // Item teilt sich mit anderen seinen parent
            parentItem.insertBefore(placeholder, nextItem);
          } else {
            // parent entaehlt nur ein Item -> appendChild
            parentItem.appendChild(placeholder);
          }
      } catch(e) {
      	this.m_exception.throwError("createPlaceholder", e);
      }    	
    };

    /*
     * Ersetzt HTML Elemente durch andere
     * @param {String} itemIdToReplace - ID des Elements das ersetzt werden soll
     * @param {String} newTag - das neue Tag
     * @param {HTML Element} form - Form-Element das zu dem Element gehort das den Request ausgeloest hat
     *                              -> nur Elemente innerhalb dieser Form updaten
     */
    org.j4fry.common.Page.prototype.replaceHTMLItem = function(itemIdToReplace, newTag, form) {
    	 //JAVA:alert('ItemID: ' + itemIdToReplace + '\\nnewTag: ' + newTag + '\\nForm:' + form.name);
      try {
			var item = this.getElementFromForm(itemIdToReplace, form);
			if(item == null) {
			  this.m_exception.throwWarning("replaceHTMLItem", "Unknown Html-Component-ID: " + itemIdToReplace);
			  return;
			}

			if (typeof window.Range != 'undefined' && typeof Range.prototype.createContextualFragment == 'function') {
				try {
					var range = document.createRange();
					range.setStartBefore(item);
					var fragment = range.createContextualFragment(newTag);
				} catch(t) {
					// facelets deliver html entity names with xhtml causing AJAX failure in firefox -> replace with entitiy numbers
					var fragment = range.createContextualFragment(this.faceletsXHTMLHack(newTag));
				} 
				item.parentNode.insertBefore(fragment, item);
			} else {
				item.insertAdjacentHTML('beforeBegin', newTag);
			}				
			item.parentNode.removeChild(item);
      } catch(e) {
      	this.m_exception.throwError("replaceHTMLItem", e);
      }
    };

    /*
     * Holt anhand einer ID eines HTML-Elements das gesamte Element das in der angegebenen Form liegt
     * -> es ist moeglich das zwei Elemente die gleiche ID haben aber in unterschiedlichen Forms liegen
     * -> MyFaces 1.1.4 zwei Forms -> 2x Input-Hidden-Fields mit ID jsf_tree_64 & jsf_state_64
     * -> http://www.arcknowledge.com/gmane.comp.jakarta.myfaces.devel/2005-09/msg01269.html
     * @param {String} itemId - ID des HTML Elements
     * @param {Html-Element} form - Form Element das das Element beinhalten soll
     * @return {Html-Element} - wird das Element gefunden wird es zuruck gegeben ansonsten null
     */
    org.j4fry.common.Page.prototype.getElementFromForm = function(itemId, form) {
    	try {
          var fLen = form.elements.length;
          for(var f=0; f<fLen; f++) {
            var element = form.elements[f];
            if(element.id != null && element.id == itemId) {
              return element;
            }
          }
          // Element in der Form nicht gefunden -> Normalen getElementById absetzen (kann ggf. null sein wenn es das Element nicht gibt)
          return document.getElementById(itemId);
    	} catch(e) {
      	this.m_exception.throwError("getElementFromForm", e);
      }
    };

    /*
     * Holt zu einem Item seinen Parent mit bestimmten Tag-Namen
     * @param {HtmlElement} item - Kindelement
     * @param {String} parentName - TagName des Elternelements
     */
    org.j4fry.common.Page.prototype.getParent = function(item, parentName) {
    	try {
          // parent tag parentName suchen
          var parentItem = item.parentNode;
          while(parentItem != null && parentItem.tagName.toLowerCase() != parentName) {
            parentItem = parentItem.parentNode;
          }
          if(parentItem != null) {
            return parentItem;
          } else {
            this.m_exception.throwWarning("getParent", "The item has no parent with type <" + parentName + ">");
            return null;
          }
      } catch(e) {
      	this.m_exception.throwError("getParent", e);
      }
    };

    /*
     * Holt zu einem Item ein Child
     * @param {HtmlElement} item - Elternelement
     * @param {String} childName - TagName des Kindelements
     * @param {String} itemName - name-Attribut das das Kindelement haben kann (kann null sein)
     */
    org.j4fry.common.Page.prototype.getChild = function (item, childName, itemName) {
         var childItems = item.childNodes;
         for(var c=0, cLen=childItems.length; c<cLen; c++) {
           if(childItems[c].tagName != null && childItems[c].tagName.toLowerCase() == childName &&
               (itemName == null || (itemName != null && itemName == childItems[c].getAttribute("name") ))) {
             return childItems[c];
           }
         }
         return  null;
    }

    /*
     * Ermittelt zu einer Form alle Input-Felder und disabled diese anschliessend + weitere Felder
     * @param {HtmlElement} item - Item das in der jeweiligen Form genested ist und event ausgeloest hat
     * @param {Boolean} disableFlag - gibt an ob ueberhaupt Elemente gedisabled werden sollen
     * @param {String} disableTypes - Element-Typen die gedisabled werden sollen
     *    Angabe von: all (Alle Elemente), button, submit, reset, text, radio, checkbox, select, textarea, a (Links, hier wird nur das "onClick"-Event entfernt und nach der Response wieder zurueckgesetzt)
     * @param {Array} disableElementsArr - wird nur beachtet wenn es auch ein Array von bestimmten Elementen ist ansonsten nicht
     * @param {HtmlElement} parentItem - Form-Element in das das item genested ist
     * @param {Array} partialIds - Angabe von bestimmten Ids von Elementen die verarbeitet werden sollen
     */
    org.j4fry.common.Page.prototype.processUserEntries = function(item, disableFlag, 
    								disableTypesArr, disableElementsArr, parentItem, partialIds) {
    	try {
          var form = parentItem;
		  
          if(form == null) {
            this.m_exception.throwWarning("processUserEntries", "Html-Component is not nested in a Form-Tag");
            return null;
          }

          // initialisieren des Component-Caches und initialisieren des m_certainElementFlag Attributs
          this.m_componentAttributeCache = new Array();
          this.m_componentCache = new Array();
          this.m_certainElementFlag = false;

          // behandeln von einzelnen Elementen falls angegeben und Flag m_certainElementFlag setzen
          // (= true wenn bestimmte Elemente angegeben wurden)
          if(disableFlag == true) {
            this.disableCertainElement(disableElementsArr, disableTypesArr)
          }

          // form-Namen an String haengen (form.id + "=" + form.id + "&")
          var stringBuffer = new Array();
          stringBuffer[stringBuffer.length] = form.id;
          stringBuffer[stringBuffer.length] = "=";
          stringBuffer[stringBuffer.length] = form.id;
          stringBuffer[stringBuffer.length] = "&";

          if(partialIds != null && partialIds.length > 0) {
          	 // Knoten rekursiv prüfen und ggf. einfügen (ohne die Dummyzeile läßt der IE6 den Aufruf weg)
             var dummy = 'x'; 
          	 this.addNodes(form, false, partialIds, disableFlag, disableTypesArr, stringBuffer);
          } else { 
          	 // alle Knoten einfügen (ohne die Dummyzeile läßt der IE6 die Zuweisung weg)
             var dummy = 'x'; 
	         var eLen = form.elements.length;
	         for(var e=0; e<eLen; e++) {
	           this.addField(form.elements[e], stringBuffer);
		       // nur disablen wenn keine bestimmten Elemente in "elementArr"
		       if(disableFlag == true && this.m_certainElementFlag == false) {
		         // Disablen der Elemente (noch keine Behandlung von Links)
		         this.disableElement(form.elements[e], disableTypesArr);
		       }
	         } // end of for (formElements)
          }  
 		 
          // Falls ausloesendes Element ein Button ist diese auch mitschicken
          if(item.type != null && item.type.toLowerCase() == "submit"){
            stringBuffer[stringBuffer.length] = encodeURIComponent(item.name);
            stringBuffer[stringBuffer.length] = "=";
            stringBuffer[stringBuffer.length] = encodeURIComponent("YES");
            stringBuffer[stringBuffer.length] = "&";
          }

          // nur Links behandeln (disablen) falls keine bestimmten Elemente angegeben wurden
          if(disableFlag == true && this.m_certainElementFlag == false) {
            // Links behandeln
            var links = document.getElementsByTagName("a");
            if(disableTypesArr.contains("a") || disableTypesArr.contains("all")) {
              var lLen = links.length;
              for(var l=0; l<lLen; l++) {
                this.disableElement(links[l], disableTypesArr);
              }
            }
          }
          return stringBuffer.join("");
      } catch(e) {
      alert(e);
      	this.m_exception.throwError("processUserEntries", e);
      }
    };
    
    // Prüft für alle Knoten rekursiv, ob sie für Partial Submit benötigt werden
    org.j4fry.common.Page.prototype.addNodes = function(node, insideSubmittedPart, partialIds, disableFlag, disableTypesArr, stringBuffer) {
    	if (node != null && node.childNodes != null) {
            var nLen = node.childNodes.length;
            for(var i=0; i<nLen; i++) {
              var child = node.childNodes[i];
              var id = child.id;
              var elementName = child.name;
              if (child.nodeType == 1) {
                  var isPartialSubmitContainer = ((id != null) && partialIds.contains(id.splitAndGetLast(":")));
 	          	  if (insideSubmittedPart || isPartialSubmitContainer || 
	          	  (elementName != null && jsfKeywords.contains(elementName))) {
                      // Id für Partial submit mitschicken, wenn es sich um den äußersten submitteten Container handelt 
                      if(isPartialSubmitContainer) {
                      	stringBuffer[stringBuffer.length] = this.PARTIAL_PREFIX;
                      	stringBuffer[stringBuffer.length] = encodeURIComponent(id);
                      	stringBuffer[stringBuffer.length] = "=&";
                      }
	          	      // Knoten für Partial submit benötigt
	                  this.addField(child, stringBuffer);
	                  if (insideSubmittedPart || isPartialSubmitContainer) {
		                  // Auf weitere Kinder Prüfen (ohne die Dummyzeile läßt der IE6 den Aufruf weg)
		                  var dummy = id;
			              this.addNodes(child, true, partialIds, disableFlag, disableTypesArr, stringBuffer);
			          }
	              } else {
		                  // Auf weitere Kinder Prüfen (ohne die Dummyzeile läßt der IE6 den Aufruf weg)
	                  var dummy = id;
		              this.addNodes(child, false, partialIds, disableFlag, disableTypesArr, stringBuffer);
		          }
		          // nur disablen wenn keine bestimmten Elemente in "elementArr"
		          if(disableFlag == true && this.m_certainElementFlag == false 
		          && (child.nodeName == null || child.nodeName.toLowerCase() != 'a')) {
		            // Disablen der Elemente (noch keine Behandlung von Links)
		            this.disableElement(child, disableTypesArr);
		          }
	           }
            }
        }
    }
    
    // Diese Methode fügt dem Request ein einzelnes Feld hinzu
    org.j4fry.common.Page.prototype.addField = function(element, stringBuffer) {
           var elementName = element.name;
           var elementTagName = element.tagName.toLowerCase();
           var elementType = element.type;
           if(elementType != null) { elementType = elementType.toLowerCase(); }
           
           // Routine fuer alle Form-Elemente
           // Regeln:
           //    - Nur Inputs, Textareas und Selects behandeln
           //    - Elemente muessen das Attribute "name" besitzen
           //    - Elemente duerfen nicht gedisabled sein
           if(((elementTagName == "input" || elementTagName == "textarea" || elementTagName == "select") &&
              (elementName != null && elementName != "")) && element.disabled == false) {
              
              // Routine fuer Select-Elemente
              // Regeln:
              //    - wenn select-one und value-Attribute vorhanden "name=value"
              //      (auch wenn value leer is dann "name=")
              //    - wenn select-one und value-Attribute nicht vorhanden "name=AnzeigeValue"
              //    - wenn select-multi und mehrere ausgewaehlt "name=value1&name=value2"
              //    - wenn select und selectedIndex=-1 dann nicht submitten
              if(elementTagName == "select") {
                // selectedIndex muss groesser/gleich 0 sein um submittet zu werden
                if(element.selectedIndex >= 0) {
                  var uLen = element.options.length;
                  for(var u=0; u<uLen; u++) {
                    // alle ausgewaehlten Options suchen
                    if(element.options[u].selected == true) {
                      var elementOption = element.options[u];
                      stringBuffer[stringBuffer.length] = encodeURIComponent(elementName);
                      stringBuffer[stringBuffer.length] = "=";
                      if(elementOption.getAttribute("value") != null) {
                        stringBuffer[stringBuffer.length] = encodeURIComponent(elementOption.value);
                      } else {
                        stringBuffer[stringBuffer.length] = encodeURIComponent(elementOption.text);
                      }
                      stringBuffer[stringBuffer.length] = "&";
                    }
                  }
                }
              }

              // Routine fuer restliche Elemente
              // Regeln:
              //    - keine Selects (weil oben behandelt), Buttons, Reset-Buttons, Submit-Buttson submitten
              //    - checkboxen oder radio-Inputs nur submitten wenn sie auch angewaehlt sind
              if((elementTagName != "select" && elementType != "button" &&
                 elementType != "reset" && elementType != "submit" && elementType != "image") &&
                ((elementType != "checkbox" && elementType != "radio") || element.checked)) {
                stringBuffer[stringBuffer.length] = encodeURIComponent(elementName);
                stringBuffer[stringBuffer.length] = "=";
                stringBuffer[stringBuffer.length] = encodeURIComponent(element.value);
                stringBuffer[stringBuffer.length] = "&";
              }
              
        } // end of if (element)
      }

    /*
     * Disabled ein bestimmtes bzw. mehrere bestimmte Elemente
     * @param {HtmlElement} element - Element das gedisabled werden soll (kann ggf. auch eine Array sein mit Einzel-Elementen)
     * @param {Array} disableTypesArr - enthaelt die zulaessigen disableTyes (hier immer "all")
     */
    org.j4fry.common.Page.prototype.disableCertainElement = function(element, disableTypesArr) {
    	try {
          if(this.m_certainElementFlag == false && Array.prototype.isPrototypeOf(element)) {
            // Routine falls element = Array von bestimmten Elementen, die gedisabled werden sollen
            var iLen = element.length;
            for(var i=0; i<iLen; i++) {
              if(element[i] != null) {
                this.disableElement(element[i], disableTypesArr);
              } else {
                this.m_exception.throwWarning("disableCertainElement", "There is a unknown element that cannot be disabled because it's not on the page.");
              }
            }
            this.m_certainElementFlag = true;
          }
      } catch(e) {
      	this.m_exception.throwError("disableCertainElement", e);
      }
    };

    /*
     * Disabled oder Enabled ein Element falls es bestimmten Anforderungen entspricht
     * @param {HtmlElement} element - Element das gedisabled oder geenabled werden soll
     * @param {String} disableTypes - Element-Typen die gedisabled werden sollen
     *    Angabe von: all (Alle Elemente), button, submit, reset, text, radio, checkbox, select, textarea, a (Links, hier wird nur das "onClick"-Event entfernt und nach der Response wieder zurueckgesetzt)
     * @param {String} mode - Zustand, den das Element annimmt, entweder 'disable' oder 'enable'
     */
    org.j4fry.common.Page.prototype.disableElement = function(element, disableTypesArr) {
    	try {
          var elementTagName = element.tagName.toLowerCase();
          if((elementTagName == "input" || elementTagName == "select" 
          || elementTagName == "textarea" || elementTagName == "a") 
          	&& this.validateElement(element, disableTypesArr)) {
            if(elementTagName == "a" && element.getAttribute("onclick") != null) {
              // Routine fuer Links
              this.m_componentAttributeCache.push(element.getAttribute("onclick"));
              element.setAttribute("onclick", "");
            } else {
              // Routine fuer Input-Elemente
              this.m_componentAttributeCache.push(element.getAttribute("disabled"));
              // Komponente disablen
              element.setAttribute("disabled", "disabled");
            }
            // merken der gedisableten Elemente
            this.m_componentCache.push(element);
          }
      } catch(e) {
      	this.m_exception.throwError("disableElement", e);
      }
    };

    /*
     * Prueft ob ein Element gedisabled werden soll (anhand der Angabe in disableTypes)
     * @param {HtmlElement} element - Element das gedisables/geenabled werden soll
     * @param {String} disableTypes - Angabe der Typen fuer die die Aktion des Elements aufgerufen werden soll
     */
    org.j4fry.common.Page.prototype.validateElement = function (element, disableTypesArr) {
    	try {
          if(disableTypesArr.contains("all") ||
             (element.tagName.toLowerCase() == "input" && disableTypesArr.contains(element.getAttribute("type").toLowerCase())) || disableTypesArr.contains(element.tagName.toLowerCase()) ) {
            return true;
          }
          return false;
    	} catch(e) {
        this.m_exception.throwError("validateElement", e);
      }
    };

    /*
     * Enabled alle Elemente die zuvor gedisabled wurden und sich dadurch im m_componentCache befinden
     * @param {Arrray} disableTypesArr - enthaelt die disableTypen z.B. all, button, etc.
     * @param {String} element - HTML-Maintag das rekusiv durchlaufen wird
     */
    org.j4fry.common.Page.prototype.enableElementsFromCache = function(disableTypesArr) {
    	try {
          var iLen = this.m_componentCache.length;
          for(var i=0; i<iLen; i++) {
            var element = this.m_componentCache[i];
              // pruefen ob Komponente im ComponentCache enthalten und ggf. disable-Zustand wiederherstellen
              if(this.m_componentAttributeCache[i] == null || this.m_componentAttributeCache[i] == "undefined") {
                // Standardroutine fuer Input-Elemente -> disable entfernen
                element.removeAttribute("disabled");
              } else {
                if(element.tagName.toLowerCase() == "a") {
                  // Routine fuer Links enabeln d.h. urspruengliches "onclick"-Attribut wiederherstellen
                  element.setAttribute("onclick", this.m_componentAttributeCache[i]);
                } else {
                  // disable-Zustand der Komponente wiederherstellen
                  element.setAttribute("disabled", this.m_componentAttributeCache[i]);
                }
              }
          }
      } catch(e) {
      	this.m_exception.throwError("enableElementsFromCache", e);
      }
    };
    
    /*
     * Ermittelt die Position (left/top) eines Elements
     * @param {HTMLElement} item - Item für das die Position ermittelt werden soll
     */
    org.j4fry.common.Page.prototype.calculatePosition = function(item) {
		var curleft = curtop = 0;
		if (item.offsetParent) {
			do {
				curleft += item.offsetLeft;
				curtop += item.offsetTop;
			} while (item = item.offsetParent);
		}
		return [curleft,curtop];
    };
    
    /*
     * Ersetzt den HMTL entity name durch die in XHTML valide entity number
     * Facelets wollen XHTML rendern, kriegen vom JSF jedoch HTML entity names
     * Wenn beim AJAX das ersetzen fehlschlägt, kommt dieser Hack zum Tragen
     * @param {String} faceletsString - Der XHTML String mit HTML entity names, den Facelets liefert
     */
    org.j4fry.common.Page.prototype.faceletsXHTMLHack = function(faceletsString) {
    	return faceletsString
			.replace(/&quot;/g, "&#34;")
			.replace(/&apos;/g, "&#39;")
			.replace(/&amp;/g, "&#38;")
			.replace(/&lt;/g, "&#60;")
			.replace(/&gt;/g, "&#62;")
			.replace(/&iexcl;/g, "&#161;")
			.replace(/&cent;/g, "&#162;")
			.replace(/&pound;/g, "&#163;")
			.replace(/&curren;/g, "&#164;")
			.replace(/&yen;/g, "&#165;")
			.replace(/&brvbar;/g, "&#166;")
			.replace(/&sect;/g, "&#167;")
			.replace(/&uml;/g, "&#168;")
			.replace(/&copy;/g, "&#169;")
			.replace(/&ordf;/g, "&#170;")
			.replace(/&laquo;/g, "&#171;")
			.replace(/&not;/g, "&#172;")
			.replace(/&shy;/g, "&#173;")
			.replace(/&reg;/g, "&#174;")
			.replace(/&macr;/g, "&#175;")
			.replace(/&deg;/g, "&#176;")
			.replace(/&plusmn;/g, "&#177;")
			.replace(/&sup2;/g, "&#178;")
			.replace(/&sup3;/g, "&#179;")
			.replace(/&acute;/g, "&#180;")
			.replace(/&micro;/g, "&#181;")
			.replace(/&para;/g, "&#182;")
			.replace(/&middot;/g, "&#183;")
			.replace(/&cedil;/g, "&#184;")
			.replace(/&sup1;/g, "&#185;")
			.replace(/&ordm;/g, "&#186;")
			.replace(/&raquo;/g, "&#187;")
			.replace(/&frac14;/g, "&#188;")
			.replace(/&frac12;/g, "&#189;")
			.replace(/&frac34;/g, "&#190;")
			.replace(/&iquest;/g, "&#191;")
			.replace(/&times;/g, "&#215;")
			.replace(/&divide;/g, "&#247;")
			.replace(/&Agrave;/g, "&#192;")
			.replace(/&Aacute;/g, "&#193;")
			.replace(/&Acirc;/g, "&#194;")
			.replace(/&Atilde;/g, "&#195;")
			.replace(/&Auml;/g, "&#196;")
			.replace(/&Aring;/g, "&#197;")
			.replace(/&AElig;/g, "&#198;")
			.replace(/&Ccedil;/g, "&#199;")
			.replace(/&Egrave;/g, "&#200;")
			.replace(/&Eacute;/g, "&#201;")
			.replace(/&Ecirc;/g, "&#202;")
			.replace(/&Euml;/g, "&#203;")
			.replace(/&Igrave;/g, "&#204;")
			.replace(/&Iacute;/g, "&#205;")
			.replace(/&Icirc;/g, "&#206;")
			.replace(/&Iuml;/g, "&#207;")
			.replace(/&ETH;/g, "&#208;")
			.replace(/&Ntilde;/g, "&#209;")
			.replace(/&Ograve;/g, "&#210;")
			.replace(/&Oacute;/g, "&#211;")
			.replace(/&Ocirc;/g, "&#212;")
			.replace(/&Otilde;/g, "&#213;")
			.replace(/&Ouml;/g, "&#214;")
			.replace(/&Oslash;/g, "&#216;")
			.replace(/&Ugrave;/g, "&#217;")
			.replace(/&Uacute;/g, "&#218;")
			.replace(/&Ucirc;/g, "&#219;")
			.replace(/&Uuml;/g, "&#220;")
			.replace(/&Yacute;/g, "&#221;")
			.replace(/&THORN;/g, "&#222;")
			.replace(/&szlig;/g, "&#223;")
			.replace(/&agrave;/g, "&#224;")
			.replace(/&aacute;/g, "&#225;")
			.replace(/&acirc;/g, "&#226;")
			.replace(/&atilde;/g, "&#227;")
			.replace(/&auml;/g, "&#228;")
			.replace(/&aring;/g, "&#229;")
			.replace(/&aelig;/g, "&#230;")
			.replace(/&ccedil;/g, "&#231;")
			.replace(/&egrave;/g, "&#232;")
			.replace(/&eacute;/g, "&#233;")
			.replace(/&ecirc;/g, "&#234;")
			.replace(/&euml;/g, "&#235;")
			.replace(/&igrave;/g, "&#236;")
			.replace(/&iacute;/g, "&#237;")
			.replace(/&icirc;/g, "&#238;")
			.replace(/&iuml;/g, "&#239;")
			.replace(/&eth;/g, "&#240;")
			.replace(/&ntilde;/g, "&#241;")
			.replace(/&ograve;/g, "&#242;")
			.replace(/&oacute;/g, "&#243;")
			.replace(/&ocirc;/g, "&#244;")
			.replace(/&otilde;/g, "&#245;")
			.replace(/&ouml;/g, "&#246;")
			.replace(/&oslash;/g, "&#248;")
			.replace(/&ugrave;/g, "&#249;")
			.replace(/&uacute;/g, "&#250;")
			.replace(/&ucirc;/g, "&#251;")
			.replace(/&uuml;/g, "&#252;")
			.replace(/&yacute;/g, "&#253;")
			.replace(/&thorn;/g, "&#254;")
			.replace(/&yuml;/g, "&#255;");
	};