/*
 * debug.js
 *
 * Version 0.2 20040107
 *
 * (c) Top 21 GmbH
 *
 * Debug-Funktionen
 *
 */
/**
 * Erzeugt ein solseitXMLObject zur Protokollierung
 *
 * @argument user  name des angemeldeten Users
 * @return (Object solseitXMLObject)	neues solseitXMLObject log
 *
 *
 * @author andi r.
 * @version 20040107
 */
editor.prototype.createLogObj = function()
{
   var dateObj = new Date();
   var xmlString = "<logfile>";
   xmlString += "<metadata><user>" + session.user + "</user><editStart>" + dateObj.formatDate('dd.MM.yyyy') + "</editStart><editEnd/></metadata>";
   xmlString += "<log/>";
   xmlString += "</logfile>";
   return this.createXMLObjectFromString(xmlString);
}
/**
 * Erzeugt einen Logfileeintrag
 *
 * @argument fkt name der Funktion
 * @argument txt Text der geschrieben wird
 *
 *
 * @author andi r.
 * @version 20040601
 */

function writeLogLine(fkt, txt)
{
   var now = new Date();
   var logLineTxt = '<edit time="' + now.formatDate('dd.MM.yyyy') + '" function="' + fkt + '">' + txt + '</edit>';
   var logLineObj = editor.createXMLObjectFromString(logLineTxt);
   editor.logObj.addElementByXPath('/logfile/log', logLineObj);
   return false;
}
/**
 * Erzeugt einen Error-Eintrag im logObj
 *
 *
 * @author andi r.
 * @version 20040601
 */

function writeLogError(fct, ecd)
{
   try
   {
      var Log = logObj.getXPathElement('/logfile/log');
      var errorElement = logObj.internalDomObject.createElement('error');
      var now = new Date();
      errorElement.setAttribute('time', now.formatDate('dd.MM.yyyy'));
      errorElement.setAttribute('function', fct);
      errorElement.setAttribute('errorcode', code);
      errorElement.setAttribute('datei', doc);
      try
      {
         var errorTextNode = logObj.internalDomObject.createTextNode(errorMsg[ecd]);
      }
      catch(e)
      {
         var errorTextNode = logObj.internalDomObject.createTextNode(errorMsg['_00000']);
      }
      errorElement.appendChild(errorTextNode);
      Log.internalDomObject.appendChild(errorElement);
   }
   catch(e)
   {
   }
}
/*
 * function debugOutput
 *
 * @argument error Fehlerstring, der ausgegeben werden soll
 * @argument dsp Art der Darstellung
 *
 */

function debugOutput(str, dsp)
{
   switch(dsp)
   {
      case 'alert' : alert(str);
         // als alert ausgeben
         break;
      case 'throw' : // fehler ausgeben
         throw new Error(str);
         break;
      default : // wenn nix passt - alert
         alert(str);
   }
}
/*
 * function showInlineHtml
 *
 * zeigt mit Hilfe der fkt. showInlineTree eine Code-Ansicht im Browser an
 *
 */

function showInlineHtml(xmlObj, xslObj)
{
   var tmp = Sarissa.getDomDocument();
   xmlObj.transformNodeToObject(xslObj, tmp);
   tmpObj = new solseitXMLObject(tmp);
   return tmpObj.showInlineTree();
}
/*
 * function createXmlTree
 *
 * Funktion baut aus einem Node eine Ansicht, die im Internet-Explorer-Stil dargestellt wird
 *
 * @argument node Object, das IE-like dargestellt werden soll
 * @argument indent Einrücken des Ergebnisbaumes
 *
 */

function createXmlTree(node, indent)
{
   if(node == null)
   return "";
   var str = "";
   switch(node.nodeType)
   {
      case 1 : // Element
         {
            str += "<div class='element'>&lt;<span class='elementname'>" + node.nodeName + "</span>";
            var attrs = node.attributes;
            for(var i = 0; i < attrs.length; i++) str += createXmlAttribute(attrs[i]);
            if(!node.hasChildNodes())
            return str + "/&gt;</div>";
            str += "&gt;<br />";
            var cs = node.childNodes;
            for(var i = 0; i < cs.length; i++) str += createXmlTree(cs[i], indent + 3);
            str += "&lt;/<span class='elementname'>" + node.nodeName + "</span>&gt;</div>";
            break;
         }
      case 9 : // Document
         {
            var cs = node.childNodes;
            for(var i = 0; i < cs.length; i++) str += createXmlTree(cs[i], indent);
            break;
         }
      case 3 : // Text
         {
            if(!/^\s*$/.test(node.nodeValue)) str += "<span class='text'>" + node.nodeValue + "</span><br />";
            break;
         }
      case 7 : // ProcessInstruction
         {
            str += "&lt;?" + node.nodeName;
            var attrs = node.attributes;
            for(var i = 0; i < attrs.length; i++) str += createXmlAttribute(attrs[i]);
            str += "?&gt;<br />"
            break;
         }
      case 4 : // CDATA
         {
            str = "<div class='cdata'>&lt;![CDATA[<span class='cdata-content'>" + node.nodeValue + "</span>]" + "]></div>";
            break;
         }
      case 8 : // Comment
         {
            str = "<div class='comment'>&lt;!--<span class='comment-content'>" + node.nodeValue + "</span>--></div>";
            break;
         }
      case 10 : str = "<div class='doctype'>&lt;!DOCTYPE " + node.name;
         {
            if(node.publicId)
            {
               str += " PUBLIC \"" + node.publicId + "\"";
               if(node.systemId) str += " \"" + node.systemId + "\"";
            }
            else if(node.systemId)
            {
               str += " SYSTEM \"" + node.systemId + "\"";
            }
            str += "&gt;</div>";
            // TODO: Handle custom DOCTYPE declarations (ELEMENT, ATTRIBUTE, ENTITY)
            break;
         }
      default : //alert(node.nodeType + "\n" + node.nodeValue);
         {
            inspect(node);
         }
   }
   return str;
}

function createXmlAttribute(a)
{
   return " <span class='attribname'>" + a.nodeName + "</span><span class='attribvalue'>=\"" + a.nodeValue + "\"</span>";
}

function inspect(obj)
{
   var str = "";
   for(var k in obj) str += "obj." + k + " = " + obj[k] + "\n";
   window.alert(str);
}

/**
 * private Class solseitError
 *
 * @argument errorOrigin (string methodname)
 * @argument errorCode (int)
 * @argument fileName (string pathname);
 * @argument originalErrorMessage (string errormessage);
 *
 * @author andi r
 * @version 20040712
 *
 */
function solseitError(errorOrigin, errorCode, fileName, originalErrorMessage)
{
   this.errorOrigin = errorOrigin || "Unbekannte(s) Funktion/Objekt";
   this.errorCode = errorCode || new Number();
   this.fileName = fileName || new String();
   this.originalErrorMessage = originalErrorMessage || new String();
   this.message = lang.I18N.error[errorCode];
   /* errorLevel:	1 unterdrueckt Fehler
                  2 gibt Fehler als new Error()
                  3 gibt Fehler als Alert aus */
   this.errorLevel = config.errorLevel || 2;
   /* logLevel:	1 es wird nicht geloggt
                  2 es werden nur Aenderungen geloggt
                  3 es werden Aenderungen und Fehler geloggt */
   this.logLevel = config.logLevel || 3;
   this.handleError();
   this.handleLogger();
}
/**
 * private void solseitError.handleError
 *
 * @author andi r
 * @version 20040712
 *
 */

solseitError.prototype.handleError = function()
{
      var errorStr = new String('Fehler['+this.errorCode+'] in Funktion:' + this.errorOrigin+'():\n'+this.message);
      if(this.originalErrorMessage.length)
      {
         errorStr += '\nFehlermeldung des Parsers: \n['+this.originalErrorMessage+']';
      }
      errorStr += '\nin Datei: "'+this.fileName+'"';
      switch(this.errorLevel)
      {
         case 1 :
            {
               break;
            }
         case 2 :
            {
               throw errorStr;
               break;
            }
         case 3 :
            {
               alert(errorStr);
               break;
            }
      }

}
/**
 * private void solseitError.handleLogger
 *
 * @author andi r
 * @version 20040712
 *
 */

solseitError.prototype.handleLogger = function()
{

}