//**********************************************************************
function jtec_isIE6()
//**********************************************************************
// ueber prueft ob der aktuelle Browser der InternetExplorer 6 ist
// wenn ja wird true zurueckgeliefert ansonsten false
  {
  return document.getElementById && document.all && (navigator.appVersion.indexOf("MSIE 6.")!=-1);
  }
 
 
//**********************************************************************
function jtec_stringToInt(p_s)
//**********************************************************************
// interpretiert einen string als dezimalzahl
// indem fuehrende Leerzeichen und Nullen entfernt werden und dann ein parseint
// durchgefuehrt wird
// wenn keine konvertierung in eine zahl moeglich ist, wird 0 zurueckgegeben
  {
  //Status getestet
  p_s = jtec_trim(p_s);
  while (p_s.substr(0,1) == "0")
     p_s = p_s.substr(1,p_s.length);
  var antwort = parseInt(p_s);
  if (isNaN(antwort))
     antwort = 0;
  return antwort;
  }
  
//**********************************************************************
function jtec_getArbeitsbereichGroesse()
//**********************************************************************
// gibt einen array mit den werten height und width zurueck, der die hoehe und breite des zur verfuegung stehenden
// Arbeitsbereichs im Browser angibt
  {                         
  var xy = Array();                     
  if (window.innerHeight)
     {
     xy.height = window.innerHeight;
     xy.width  = window.innerWidth;
     }
  else if (document.body.offsetHeight)
     {
     xy.height = document.body.offsetHeight;
     xy.width  = document.body.offsetWidth;
     }
  return(xy);
  }  
  
//#############################################################################
//#############################################################################
// datumsfunktionen
//#############################################################################
//#############################################################################

//*****************************************************************************
function jtec_convertDateSchnell(p_datestring, p_format, p_restrictions)
//*****************************************************************************
// Diese funktion sollte nur aufgerufen werden, wenn klar ist, das bei der 
// formatierung des uebergebenen DatumsZeitStrings kein Fehler auftreten wird, 
// bzw. es egal ist. Sollte eine Formatierung nicht moeglich sein, wird einfach der
// uebergebene Wert zurueckgegeben
  {
  var error = new c_jtec_error();
  var neu = jtec_convertDate(p_datestring, error, p_format, p_restrictions);
  if (error.errorAufgetreten())
     return(p_datestring);
  return(neu);
  }

//*****************************************************************************
function jtec_convertDate(p_datestring, p_error, p_format, p_restrictions)
//*****************************************************************************
// konvertiert ein datum in ein gewuenschtes format ggf. mit angegebenen
// einschraenkungen
// @param string datestring datum welches umformatiert werden soll
// @param string format das gewuenschte zielformat
//                      'internet'  = nach YYYY-MM-DD
//                      'european'  = nach DD.MM.YYYY
//                      'british'   = nach MM/DD/YYYY
// @param array array mit den einschraenkungen (kann auch einfach leer sein)
//          'datemin' => gibt mindestdatum an oder ''
//                       bsp: '11.10.2005' fruehst moeglichstes datum ist der 11.10.2005 ||
//                            '10/11/2005' gleiches datum wie oben, nur anderes format
//          'datemax' => gibt maximaldatum an oder ''
//                       bsp: '23.08.2007' datum darf nicht weiter in der zukunft liegen als der 23.08.2007
//                            '2007-08-23' gleiches ergebniss wie oben nur andere schreibweise
//          'diffmin' => mindestdifferenz in Sekunden zum jetzigen Zeitpunkt oder ''
//          'diffmax' => maximaldifferenz in Sekunden zum jetzigen Zeitpunkt oder ''
// in p_error muss ein Errorobjekt uebergeben werden, in dem eventuelle Fehler 
// zurueck uebergeben werden koennen
// liefert entwerder ein konvertiertes datum oder false
  { 
  // wenn kein datumsstring angegeben wurde wird funktion gleich abgebrochen
  if (p_datestring.length == 0)
     {
     p_error.setError("NoDateInDatestring," + p_datestring);
     return false;
     }
  // format auf korrektheit checken
  if (!(p_format == "internet" || p_format == "european" || p_format == "british"))
     {
     p_error.setError("DatumsformatangebeFalsch," + p_datestring);
     return false;
     }
  var string = jtec_eliminateWasteWhitespaces(p_datestring);
  var parts = string.split(' ');
  // datum in array sortieren
  var date  = new Array();
  date = jtec_sort_date(p_datestring);
  if (!date)
     {
     p_error.setError("IncorrectDate1," + p_datestring);
     return false;
     }
  if (date['year'] == '')
     {
     var jetzt = new Date();
     date['year'] = jetzt.getFullYear();
     }
  date['year'] = jtec_voranstellendeZeichenEntfernen(date['year'], '0');
  if ((parseInt(date['year']) < 100) && (date['year'].length < 3))
     {
     date['year'] = parseInt(date['year']) + 2000;
     date['year'] = date['year'].toString();
     }
  // testen, ob es sich um ein realexistierendes Datum handelt
  if (!jtec_checkdate(date['month'],date['day'],date['year']))
     {
     p_error.setError("IncorrectDate2,"+p_datestring);
     return false;
     }
  // einschraenkungen beachten
  if (p_restrictions)
     {
     // timestamp aus angegebenem datum machen
     date_timestamp = jtec_mktime(0,0,0,date['month'],date['day'],date['year']);

     var diffmin_timestamp = '';
     var diffmax_timestamp = '';
     var min_timestamp = '';
     var max_timestamp = '';
     // minimaldifferenz
     if (p_restrictions['diffmin'])
        diffmin_timestamp = jtec_mktime() + Number(p_restrictions['diffmin']);

     // maximaldifferenz
     if (p_restrictions['diffmax'])
        diffmax_timestamp = jtec_mktime() + Number(p_restrictions['diffmax']);

     // min_date
     if (p_restrictions['datemin'])
        {
        min_date = jtec_sort_date(p_restrictions['datemin']);
        min_timestamp = jtec_mktime(0,0,0,min_date['month'], min_date['day'], min_date['year']);
        }

      // max_date
     if (p_restrictions['datemax'])
        {
        max_date = jtec_sort_date(p_restrictions['datemax']);
        max_timestamp = jtec_mktime(0,0,0,max_date['month'], max_date['day'], max_date['year']);
        }

     if (((min_timestamp != '') && (min_timestamp > date_timestamp)) ||
        ((max_timestamp != '') && (max_timestamp < date_timestamp)))
        {
        // die angegebene Zeit liegt nicht im Vorgegebenen Zeitbereich von z.B. 09:00 - 17:30
        if ((min_timestamp != '') && (max_timestamp != ''))
           p_error.setError("WrongDateslot,"+p_restrictions['datemin']+","+p_restrictions['datemax']);
        else if (min_timestamp != '')
           p_error.setError("WrongDateMin,"+p_restrictions['datemin']);
        else
           p_error.setError("WrongDateMax,"+p_restrictions['datemax']);
        return false;
        }
     if ((diffmin_timestamp != '') && (diffmin_timestamp > date_timestamp))
        {
        // das angegebene Datum ist kleiner als das surch die Datumsdifferenz angegebene Datum Mindestdatum
        p_error.setError("WrongDateMin," /*+date("Y-m-d",diffmin_timestamp)*/);
        return false;
        }

     if ((diffmax_timestamp != '') && (diffmax_timestamp < date_timestamp))
        {
        // das angegebene Datum ist groesser als das surch die Datumsdifferenz angegebene Datum Maximaldatum
        p_error.setError("WrongDateMax,"/*+ date("Y-m-d",diffmax_timestamp)*/);
        return false;
        }
     }
    // Datum gegebenen Falls mit nullen auffuellen
  if (date['day'].length == 1 )
     date['day'] = '0' + date['day'];
  if (date['month'].length == 1 )
     date['month'] = '0' + date['month'];
  
  //noch unklar!!!
 // if (date['year'].length == 2 )
   //  date['year'] = '20' + date['year'];
  //date['day'] = str_pad(date['day'], 2, "0", STR_PAD_LEFT);
  //date['month'] = str_pad(date['month'], 2, "0", STR_PAD_LEFT);
  //date['year'] = str_pad(date['year'], 2, "0", STR_PAD_LEFT);
   
  // datum umformatierten
  if (p_format == "internet")
     p_datestring = date['year'] + "-" + date['month'] +"-"+ date['day'];
  else if (p_format == "european")
     p_datestring = date['day'] +"."+ date['month'] +"."+ date['year'];
  else if  (p_format == "british")
     p_datestring = date['month'] +"/"+ date['day'] +"/"+ date['year'];
  // wenn bis hier alles gut gegangen ist, return true
  return p_datestring;
  }

//*****************************************************************************
function jtec_sort_date(p_datestring)
//*****************************************************************************
 {
 // Status geprueft
 // wenn kein datumsstring angegeben wurde wird funktion gleich abgebrochen
 if(!p_datestring)
   return false;

 // sucht den seperator raus (zum splitten des datums)
 if (p_datestring.indexOf(".") != -1 )
    seperator = ".";
 else if (p_datestring.indexOf("-") != -1)
    seperator = "-";
 else if (p_datestring.indexOf("/") != -1)
    seperator = "/";
 // kann keiner von den seperatoren gefunden werden ist datum ungueltig
 else
   return false;

 // datum in array splitten
 date_split = p_datestring.split(seperator);

 // checken ob date wirklich aus 3 teilen besteht
 if(date_split.length != 3)
   return false;
var date = new Array();
 // datum in array sortieren
 if (seperator == ".")
   {
   date['day']    = date_split[0];
   date['month']  = date_split[1];
   date['year']   = date_split[2];
   }
 else if (seperator == "-")
   {
   date['day']    = date_split[2];
   date['month']  = date_split[1];
   date['year']   = date_split[0];
   }
 else if (seperator == "/")
   {
   date['day']    = date_split[1];
   date['month']  = date_split[0];
   date['year']   = date_split[2];
   }

 // sortiertes array returnen
 //alert(date['day']);
 //alert(jtec_checkdate(date['month'],date['day'],date['year']));
 return date;
 }
 
//*****************************************************************************
function jtec_checkdate(p_month,p_day,p_year)
//*****************************************************************************
  {
  // Status getestet
  //Prueft ob ein Datum ein korrektes Datum is
  //rueckgabe true/false 
  p_year = jtec_stringToInt(p_year);
  p_month = jtec_stringToInt(p_month);
  p_day = jtec_stringToInt(p_day);
  var monthLength = new Array(31,28,31,30,31,30,31,31,30,31,30,31);
  if (p_year/4 == parseInt(p_year/4))
		monthLength[1] = 29;
  if (isNaN(p_day) || isNaN(p_month) || isNaN(p_year))
		return false;
  if (p_year < 1 || p_year > 32767)
      return false;
  if (p_month < 1 || p_month > 12)
      return false;
  if (p_day > monthLength[p_month-1] || p_day < 1)
	  return false;
  else
      return true;  
  }
  
//*****************************************************************************
function jtec_mktime(p_hours,p_minutes,p_seconds,p_month,p_day,p_year)
//*****************************************************************************
  {
  //gibt UTC Zeitstempel "Seconds after 1.1.1970" zurueck
  //wenn keine paramter uebergeben werden aktuellen zeitstempel zurueckgeben!?
  // alert(Date.UTC(1997,0,1,0,0,0)/1000 - 3600); Beispiel
  //alles nach mktimeschema in php
  //alert((Date.UTC(p_year,p_month-1,p_day,p_hours,p_minutes,p_seconds))/1000-3600);
  return (Date.UTC(p_year,p_month-1,p_day,p_hours,p_minutes,p_seconds))/1000-3600;
  }
  
//*****************************************************************************
function jtec_getVorangegangenenWochentag(p_datestring, p_wochentag, p_zielformat, p_genauigkeit, p_error)
//*****************************************************************************
// sucht zu dem in p_datestring angegeben Datum den den in p_wochentag
// angegebenen vorhergegangenen wochentag, falls der aktuelle Wochentag nicht selbst
// bereits der gesuche Wochentag ist
// gueltige Werte fuer p_wochentag sind
//   Mo, Di, Mi, Do, Fr, Sa, So sowie
//   Mo, Tu, We, Th, Fr, Sa, Su
// p_zielformat gibt dabei an, wie formatiert werden soll
//   'internet' = '2007-10-31 20:00:00'
//   'european' = '31.10.2007 20:00:00'
//   'british'  = '10/31/2007 20:00:00'
// p_genauigkeit gibt an, was zurueckgeliefertr werden soll moeglich ist
//     'all' o. '' = die gesamte zeitangabe vom jahr bis zur sekunde
//     'all-low'   = die gesamte zeitangabe vom jahr bis zur sekunde stunden, minuten und sekunden, wenn nicht angegeben mit 00 ersetzen
//     'all-high'  = die gesamte zeitangabe vom jahr bis zur sekunde stunden, minuten und sekunden, wenn nicht angegeben mit 23 bzw. 59 ersetzen
//     'date'      = es soll nur das Datum zurueckgeliefert werden
//     'min'       = es soll alles bis zur Minute zurueckgeliefert werden
// Beispiel: der 2.2.2007 14:00:00 ist ein Freitag und wird zusammen mit 'Mo' und 'european' uebergeben
//   dann liefert die funktion als antwort 29.01.2007 14:00:00 weil dies der Montag vor dem 
//   02.02.2007 14:00:00 war (die Zeit speilt natuerlich eigentlich keine Rolle aber der allgemeingueltigkeit wegen ist sie mit dabei)
  {
  var tage = {Mo:1, Di:2, Tu:2, Mi:3, We:3, Do:4, Th:4, Fr:5, Sa:6, So:0, Su:0 };
  if (!func_isset(tage[p_wochentag]))
     {
     func_debugoutput('An die Funktion jtec_getVorangegangenenWochentag wurde ein unbekannter Wochentag uebergeben [p_wochentag:'+p_wochentag+']');
     return(false);
     }
  
  // feststellen, ob es sich ueberhaupt um ein ordentliches datum handelt und dieses datum formatieren
  var neuererror = new c_ims_error();
  p_datestring = jtec_convertDateAndTime(p_datestring, neuererror, 'internet', p_genauigkeit, '');
  if (neuererror.errorAufgetreten())
     {
     p_error.kopiereErrors(neuererror);
     return false;
     }
  
  var parts = p_datestring.split(' ');
  if (!func_isset(parts[1]))
     parts[1] = '';
  var datumparts = parts[0].split('-');
  var datum = new Date(jtec_stringToInt(datumparts[0]), jtec_stringToInt(datumparts[1])-1, jtec_stringToInt(datumparts[2]),0,0,0);
  // jetzt wird der vorhergehende gesuche Wochentag festgestellt
  var jetzt = datum.getTime();
  while (datum.getDay() != tage[p_wochentag])
     {
     jetzt -= 24*60*60*1000;
     datum.setTime(jetzt)
     }
  // neuen zeitstring zusammensetzen
  p_datetimestring = datum.getFullYear()+'-'+(datum.getMonth()+1)+'-'+datum.getDate()+parts[1];
  // jetzt nach den uebergebenen Vorgaben konvertieren
  p_datetimestring = jtec_convertDateAndTime(p_datetimestring, p_error, p_zielformat, p_genauigkeit, '');
  // und das ergebnis zurueckgeben
  return p_datetimestring;
  }

//*****************************************************************************
function jtec_getTimestamp(p_plus, p_zielformat, p_genauigkeit)
//*****************************************************************************
// gibt die aktuelle zeit plus dem in p_plus angegeben offset in sekunden als
// lesbaren string zurueck
// p_zielformat gibt dabei an, wie formatiert werden soll
//   'internet' = '2007-10-31 20:10:00'
//   'european' = '31.10.2007 20:10:00'
//   'british'  = '10/31/2007 20:10:00'
// p_genauigkeit gibt an, was zurueckgeliefertr werden soll moeglich ist
//     'all' o. '' = die gesamte zeitangabe vom jahr bis zur sekunde
//     'all-low'   = die gesamte zeitangabe vom jahr bis zur sekunde stunden, minuten und sekunden, wenn nicht angegeben mit 00 ersetzen
//     'all-high'  = die gesamte zeitangabe vom jahr bis zur sekunde stunden, minuten und sekunden, wenn nicht angegeben mit 23 bzw. 59 ersetzen
//     'date'      = es soll nur das Datum zurueckgeliefert werden
//     'min'       = es soll alles bis zur Minute zurueckgeliefert werden
  {
  var datum = new Date();
  var jetzt = datum.getTime();
  datum.setTime(jetzt+p_plus*1000);
  var datetimestring = datum.getFullYear()+'-'+(datum.getMonth()+1)+'-'+datum.getDate()+' '+datum.getHours()+':'+datum.getMinutes()+':'+datum.getSeconds();
  var error = new c_ims_error();
  return(jtec_convertDateAndTime(datetimestring, error, p_zielformat, p_genauigkeit, ''));
  }
  
//*****************************************************************************
function jtec_convertTimeSchnell(p_timestring, p_format, p_restrictions)
//*****************************************************************************
// Diese funktion sollte nur aufgerufen werden, wenn klar ist, das bei der 
// formatierung des uebergebenen DatumsZeitStrings kein Fehler auftreten wird, 
// bzw. es egal ist. Sollte eine Formatierung nicht moeglich sein, wird einfach der
// uebergebene Wert zurueckgegeben
  {
  var error = new c_jtec_error();
  var neu = jtec_convertTime(p_timestring, error, p_format, p_restrictions);
  if (error.errorAufgetreten())
     return(p_timestring);
  return(neu);
  }

//*****************************************************************************
function jtec_convertTime(p_timestring, p_error, p_format, p_restrictions)
//*****************************************************************************
// konvertiert eine angegebene uhrzeit in ein gewuenschtes format mit ggf.
// angegebenen einschraenkungen
// @param string timestring uhrzeit die umkonvertiert werden soll
// @param string format das gewuenschte zielformat
//                  all           : nur stunde, minute und sekunde zb 16:04:54
//                  min           : nur stunde und minute zb 16:04
//                  hour          : nur stunde
//                  all-low       : wenn stunde, minute und oder Sekunde nicht angegeben wurden, werden sie mit 00 ersetzt
//                  all-high      : wenn stunde, minute und oder Sekunde nicht angegeben wurden, werden sie mit 23 bzw. 59 ersetzt
//                  minute        : nur minute
//                  second        : nur sekunde
// @param array array mit den einschraenkungen (kann auch einfach leer sein)
//          timemin => fruehste uhrzeit
//          timemax => spaeteste uhrzeit 
//          dadurch kann man sagen Urzeiten duerfen nur z.B. zwischen 10:00 und 18:00 eingetragen werden
// in p_error muss ein Errorobjekt uebergeben werden, in dem eventuelle Fehler 
// zurueck uebergeben werden koennen
// liefert entwerder ein konvertierten timestring oder false
  {
 // wenn ueberhaupt kein uhrzeit angegeben wurde funktion gleich abbrechen
 if ((!p_timestring) &&  (p_format != 'all-low') && (p_format != 'all-high'))
    {
    p_error.setError("NoTimeInTimestring," + p_timestring);
    return false;
    }

 // uhrzeit in array splitten
 if (!p_timestring)
    var time = Array();
 else
    var time = p_timestring.split(":");

 // wenn array nicht aus entsprechend vielen feldern besteht ist die Zeitangabe zu kurz
 if (((p_format == "all") && (time.length < 3)) ||
     ((p_format == "") && (time.length < 3)) ||
     ((p_format == "min") && (time.length < 2)) ||
     ((p_format == "hour") && (time.length < 1)) ||
     ((p_format == "minute") && (time.length < 2)) ||
     ((p_format == "second") && (time.length < 3)))
    {
    p_error.setError("TimestringToShort," + p_timestring);
    return false;
    }
 if (p_format == 'all-low')
    {
    if (!time[0] || (jtec_trim(time[0]) == '')) time[0] = 0;
    if (!time[1] || (jtec_trim(time[1]) == '')) time[1] = 0;
    if (!time[2] || (jtec_trim(time[2]) == '')) time[2] = 0;
    }
 if (p_format == 'all-high')
    {
    if ((!time[0]) || (jtec_trim(time[0]) == '')) time[0] = 23;
    if ((!time[1]) || (jtec_trim(time[1]) == '')) time[1] = 59;
    if ((!time[2]) || (jtec_trim(time[2]) == '')) time[2] = 59;
    }

 // fuer den fall, dass die Zeitangaben fuer Sekunden und Minuten nicht notwendig sind und nicht angegeben wurden,
 // werden sie zur erleicherung der weiteren Verarbeitung auf 0 gesetzt
 if (!time[1]) time[1] = 0;
 if (!time[2]) time[2] = 0;

 time[0] = jtec_stringToInt(time[0]);
 time[1] = jtec_stringToInt(time[1]);
 time[2] = jtec_stringToInt(time[2]);

 //uhrzeit-elemente ggf. mit nullen auffuellen
 if(time[0] <= 9)
    time[0] = '0'+ time[0];
 if(time[1] <= 9)
    time[1] = '0'+ time[1];
 if(time[2] <= 9)
    time[2] = '0'+ time[2];

 // pruefen ob die einzelnen zeitelemente korrekt und logisch sind
 if ((time[0] > 24 || time[0] < 0) ||
     (time[1] > 59 || time[1] < 0) ||
     (time[2] > 59 || time[2] < 0))
    {
    // diese Urzeit kann nicht existieren
    p_error.setError("IncorrectTime," + p_timestring);
    return false;
    }

 // uhrzeit wird noch auf einschraenkungen gecheckt
 if(!p_restrictions)
   {
   var timegesamt = time[0]+":"+time[1]+":"+time[2];
   var min_time = '';
   var max_time = '';

   if (!p_restrictions['timemin'])
      min_time = p_restrictions['timemin'];

   if (!p_restrictions['timemax'])
      max_time = p_restrictions['timemax'];

   if (((min_time != '') && (min_time >= timegesamt)) ||
       ((max_time != '') && (max_time <= timegesamt)))
      {
      // die angegebene Zeit liegt nicht im Vorgegebenen Zeitbereich von z.B. 09:00 - 17:30
      if ((min_time != '') && (max_time != ''))
         p_error.setError("WrongTimeslot," + min_time + "," + max_time);
      else if (min_time != '')
         p_error.setError("WrongTimeMin,"+min_time);
      else
         p_error.setError("WrongTimeMax,"+max_time);
      return false;
      }
   }

 // uhrzeit in das gewuenschte format umwandeln
 if (p_format == "all")
    p_timestring = time[0]+":"+time[1]+":"+time[2];
 else if (p_format == "min")
    p_timestring = time[0]+":"+time[1];
 else if (p_format == "hour")
    p_timestring = time[0];
 else if (p_format == "minute")
    p_timestring = time[1];
 else if (p_format == "second")
    p_timestring = time[2];
 else
    p_timestring = time[0]+":"+time[1]+":"+time[2];

 // alles gut gegangen, dann TRUE returnen
 return p_timestring;
 }
//*****************************************************************************
function jtec_getLengthInSecond(p_datetimestring1,p_datetimestring2)
//*****************************************************************************
// die laenge zwischen zwei Zeitpunkten und gib diesen in Sekunden zurueck;
// sollten keine vernuenftigen datetimestrings uebergeben worden sein, wird
// 0 zurueckgegeben
  {
  var error = new c_ims_error();
  var timestring1 = jtec_convertDateAndTime(p_datetimestring1, error, 'internet', 'min','');
  var timestring2 = jtec_convertDateAndTime(p_datetimestring2, error, 'internet', 'min','');

  // wenn sich die Strings nicht formatieren lassen, wird 0 zurueckgegeben
  if (error.errorAufgetreten())
     return(0);

  // aufsplitten der ersten Zeit
  var datetime1 = timestring1.split(' ');
  var date1     = datetime1[0].split('-');
  var time1     = datetime1[1].split(':');

  // aufsplitten der zweiten Zeit
  var datetime2 = timestring2.split(' ');
  var date2     = datetime2[0].split('-');
  var time2     = datetime2[1].split(':');
  
  //jtec_mktime(p_hours,p_minutes,p_seconds,p_month,p_day,p_year)
  var timesec1 = jtec_mktime(time1[0],time1[1],0,date1[1],date1[2],date1[0]);
  var timesec2 = jtec_mktime(time2[0],time2[1],0,date2[1],date2[2],date2[0]);

  // rueckgabe der Differenz der beiden zeiten
  return parseInt(timesec2 -timesec1);
  }

//*****************************************************************************
function jtec_getLengthInSecondOfTime(p_timestring1,p_timestring2)
//*****************************************************************************
// die laenge zwischen zwei Zeitpunkten und gib diesen in Sekunden zurueck;
  {
  var error = new c_jtec_error();
  var timestring1 = jtec_convertTime(p_timestring1, error, 'internet', 'min','');
  var timestring2 = jtec_convertTime(p_timestring2, error, 'internet', 'min','');

  // aufsplitten der ersten Zeit
  var time1 = timestring1.split(':');

  // aufsplitten der zweiten Zeit
  var time2 = timestring2.split(':');

  //jtec_mktime(p_hours,p_minutes,p_seconds,p_month,p_day,p_year)
  // als datum für die Funktion jtec_mktime wird der 1.1.1970 genommen es wird davon ausgegangen 
  // das beide zeiten an einem Tag sind
  var timesec1 = jtec_mktime(time1[0],time1[1],0,1,1,1970);
  var timesec2 = jtec_mktime(time2[0],time2[1],0,1,1,1970);
  // rueckgabe der Differenz der beiden zeiten
  return parseInt(timesec2 -timesec1);
  }
 
//*****************************************************************************
function jtec_convertDateAndTimeSchnell(p_datetimestring, p_zielformat, p_genauigkeit, p_restrictions)
//*****************************************************************************
// Diese funktion sollte nur aufgerufen werden, wenn klar ist, das bei der 
// formatierung des uebergebenen DatumsZeitStrings kein Fehler auftreten wird, 
// bzw. es egal ist. Sollte eine Formatierung nicht moeglich sein, wird einfach der
// uebergebene Wert zurueckgegeben
  {
  var error = new c_jtec_error();
  var neu = jtec_convertDateAndTime(p_datetimestring, error, p_zielformat, p_genauigkeit, p_restrictions);
  if (error.errorAufgetreten())
     return(p_datetimestring);
  return(neu);
  }

//*****************************************************************************
function jtec_convertDateAndTime(p_datetimestring, p_error, p_zielformat, p_genauigkeit, p_restrictions)
//*****************************************************************************
// erwartet eine Zeitangabe besthend aus datum und eventuell einer Zeitangabe
// p_datetimestring hier wird der Datumszeitstring uebergeben
// p_zielformat kann sein
//     'internet'  = nach YYYY-MM-DD
//     'european'  = nach DD.MM.YYYY
//     'british'   = nach MM/DD/YYYY
//     p_genauigkeit gibt an, was zurueckgeliefert werden soll moeglich ist
//     'all' o. '' = die gesamte zeitangabe vom jahr bis zur sekunde
//     'all-low'   = die gesamte zeitangabe vom jahr bis zur sekunde stunden, minuten und sekunden, wenn nicht angegeben mit 00 ersetzen
//     'all-high'  = die gesamte zeitangabe vom jahr bis zur sekunde stunden, minuten und sekunden, wenn nicht angegeben mit 23 bzw. 59 ersetzen
//     'date'      = es soll nur das Datum zurueckgeliefert werden
//     'min'       = es soll alles bis zur Minute zurueckgeliefert werden
//     'day'       = es soll nur der aktuelle Wochentage zurueckgeliefert werden (im Javascriptstyle Sonntag = 0, Montag = 1 .....)
// p_restrictions
//          timemin => fruehste uhrzeit
//          timemax => spaeteste uhrzeit
//          datemin => gibt mindestdatum an oder ''
//                     bsp: '11.10.2005' fruehst moeglichstes datum ist der 11.10.2005 ||
//                          '10/11/2005' gleiches datum wie oben, nur anderes format
//          datemax => gibt maximaldatum an oder ''
//                     bsp: '23.08.2007' datum darf nicht weiter in der zukunft liegen als der 23.08.2007
//                          '2007-08-23' gleiches ergebniss wie oben nur andere schreibweise
//          diffmin => mindestdifferenz in Sekunden zum jetzigen Zeitpunkt oder ''
//          diffmax => maximaldifferenz in Sekunden zum jetzigen Zeitpunkt oder ''
// in p_error muss ein Errorobjekt uebergeben werden, in dem eventuelle Fehler 
// zurueck uebergeben werden koennen
// liefert entwerder ein konvertierten datetimestring oder false
  {
  var string = jtec_eliminateWasteWhitespaces(p_datetimestring);
  var parts = string.split(' ');

  if (((p_genauigkeit == 'all') ||
     (p_genauigkeit == 'min')) &&
     (!parts[1] ||
     (parts[1] == '')))
     {
     // es soll ein Zeitanteil zurueckgeliefert werden aber es ist kein Zeitanteil vorhanden
     p_error.setError("TimestringToShort," + p_datetimestring);
     return false;
     }
  
  // wenn die genauigkeite day ist soll nur der aktuelle Wochentag zurueckgegeben werden
  if (p_genauigkeit == 'day')
     {
     // erstmal basteln wird uns ein richtiges Datum im internetformat
     var tempdate = jtec_convertDate(parts[0], p_error, 'internet', p_restrictions);
     // dan teilen wir es damit wir daraus ein javascript Datumsobjekt erzeigen koennen
     tempdate = tempdate.split('-');
     var currentdate  = new Date(tempdate[0], parseInt(tempdate[1])-1, tempdate[2]); // Javasrcipt-Datumsobjekt
     return currentdate.getDay();
     }
  var ueberbrueckung = parts[1];
  parts[0] = jtec_convertDate(parts[0], p_error, p_zielformat, p_restrictions);
  if (p_error.errorAufgetreten())
     return false;
  parts[1] = ueberbrueckung;
     
  if (p_genauigkeit == 'date')
     {
     p_datetimestring = parts[0];
     return p_datetimestring;
     }

  // da die genauigkeit nicht Date ist, soll also ein Timeanteil zurueckgegeben werden
  var genau = 'all';
  if (p_genauigkeit == 'all-low')
     genau = 'all-low';
  if (p_genauigkeit == 'all-high')
     genau = 'all-high';
  if (p_genauigkeit == 'min')
     genau = 'min';
  parts[1] = jtec_convertTime(parts[1], p_error, genau, p_restrictions);
  if (p_error.errorAufgetreten())
     return false;

  p_datetimestring = parts[0] + ' ' + parts[1];
  return p_datetimestring;
  }

//*****************************************************************************
function jtec_addSecondsToDatetime(p_datetimestring, p_seconds, p_error, p_zielformat, p_genauigkeit, p_restrictions)
//*****************************************************************************
// erwartet eine datums- oder datumszeitangabe und eine sekundenangabe, die positiv oder negativ sein darf
// und addiert diese sekundenangabe auf das datum und gibt den neuen datumswert zurueck
  {
  var neuererror = new c_jtec_error();

  // zuerst wird getestet, ob es sich wirklich um eine datumsangabe handelt
  // fehlende stunden,Minuten und sekunden werden bei bedarf mit 00 ersetzt
  p_datetimestring = jtec_convertDateAndTime(p_datetimestring, neuererror, 'internet', 'all-low', '');
  if (neuererror.errorAufgetreten())
     {
     p_error.kopiereErrors(neuererror);
     return false;
     }
  
  // jetzt wird ein dateobjekt mit dem datum erzeugt
  // dazu werden zuerst duie einzelnen teile des datums aufgesplittet
  var parts = p_datetimestring.split(' ');
  var datumparts = parts[0].split('-');
  var zeitparts  = parts[1].split(':');
  // dann wird das date Objekt erzeugt (vom monat muss dabei 1 abgezogen werden weil die funktion bei den Monaten mit
  // 0 anfaengt zu rechnen und nicht mit 1
  var datum = new Date(jtec_stringToInt(datumparts[0]), jtec_stringToInt(datumparts[1])-1, jtec_stringToInt(datumparts[2]), 
                       jtec_stringToInt(zeitparts[0]),  jtec_stringToInt(zeitparts[1]),    jtec_stringToInt(zeitparts[2]));
  // feststellen des zeitwertes des datums in millisekunden sein 1970
  var jetzt = datum.getTime();
  // neue Zeit setzen, in dem die uebergebenen sekunden * 1000 aufaddiert werden
  datum.setTime(jetzt+jtec_stringToInt(p_seconds)*1000);
  // neuen zeitstring zusammensetzen
  p_datetimestring = datum.getFullYear()+'-'+(datum.getMonth()+1)+'-'+datum.getDate()+' '+datum.getHours()+':'+datum.getMinutes()+':'+datum.getSeconds();
  // jetzt nach den uebergebenen Vorgaben konvertieren
  p_datetimestring = jtec_convertDateAndTime(p_datetimestring, p_error, p_zielformat, p_genauigkeit, p_restrictions);
  // und das ergebnis zurueckgeben
  return p_datetimestring;
  }




//#############################################################################
//#############################################################################
// stringfunktionen
//#############################################################################
//#############################################################################

//*****************************************************************************
function jtec_stripWrongCharsFromString(p_string, p_incchars, p_excchars)
//*****************************************************************************
  {
  // entfert aus der in p_string uebergebenen Zeichenkette alle Zeichen, die nicht in
  // p_incchars explizit erlaubt wurden, p_incchars 1= '' ist
  // und entfernt alle Zeichen die in p_excchars explizit verboten sind, vorausgesetzt
  // p_excchars ist nicht '';
  // trivialer fall das (p_excchars && p_incchars) == '' könnte gesondert behandelt werden
  var newstring = '';
  var currentchar;
  for (var zlr = 0; zlr < p_string.length; zlr++)
     {
     currentchar = p_string.charAt(zlr);
     if ((p_incchars == '') || (p_incchars.indexOf(currentchar) != -1 ))
        {
        if ((p_excchars == '') || (p_excchars.indexOf(currentchar) ==-1))
            newstring = newstring.concat(currentchar);
        }  
      }
   return newstring;
  }

//*****************************************************************************
function jtec_countCharsInString(p_string, p_chars)
//*****************************************************************************
  {
  // Zaehlt, wie oft die Zeichen aus der Zeichenkette p_chars in dem String p_string
  // vorkommen und gibt den Wert zurueck
  var position = 0;
  var instring = 0;
  if (p_chars == '') 
      return 0; 
 for (var zlr = 0; zlr < p_string.length; zlr++)
     {
     if (p_chars.indexOf(p_string.charAt(zlr)) != -1)
        instring++;
     }
  return instring;
  }

//*****************************************************************************
function jtec_truncateStringExcludeChars(p_string, p_chars, p_size)
//*****************************************************************************
  {
  //Status getestet
  // kuerzt den string auf die in p_size angegeben laenge dabei werden die in
  // p_chars angegben Zeichen nicht mitgezaehlt jedoch werden sie mitabgeschnitten,
  // sobald die laenge von p_size erreicht wird
  // der aufruf ('123 456 789 012 345 678',' ',10) wuerde den String '123 456 789 0'
  // zurueckgeben
  var zlr = 0;
  var pos = 0;
  var currentchar;
  var rueckgabestring = '';
  while (zlr < p_size)    
    {
    currentchar = p_string.charAt(pos);
    rueckgabestring = rueckgabestring.concat(currentchar);
    pos++;
    if (currentchar.indexOf(p_chars) == -1)
      zlr++;
    }
  return rueckgabestring;
  }
  
//**********************************************************************
function jtec_trim(p_s)
//**********************************************************************
  {
  // Status getestet
  // Trimt einen Textstring und gibt diesen zurueck

  if (typeof(p_s) == "number")
     {
     p_s = p_s.toString();
     }
  // erst fuehrende dann abschliessende Whitespaces entfernen
  return p_s.replace (/^\s+/, '').replace (/\s+$/, '');
  }

//**********************************************************************
function jtec_eliminateWasteWhitespaces(p_value)
//**********************************************************************
  // entfernt alle sorten von leerraeumen und erstez sie jeweils durch ein Leerzeichen.
  // nur am Anfang und am ende wird der Leerraum vollstaendig entfernt
  {
  return(jtec_trim(p_value.replace("/\s+/", " ")));
  } 

//#############################################################################
//#############################################################################
// domfunktionen
//#############################################################################
//#############################################################################

//**********************************************************************
function jtec_getNodeById(p_domstruktur, p_tagname, p_id)
//**********************************************************************
// gibt die Referenz auf den in der uebergebenen p_domstruktur enthaltenen
// Knoten mit der uebergebenen Id  und dem uebergebenen p_tagname zurueck
// wird keine Knoten gefunden, wird false zurueckgegeben
  {
  // laedt alle Elemente eines bestimmten TagTypen in tags(numerisches Array)
  var tags = p_domstruktur.getElementsByTagName(p_tagname);
  
  // durchlaeuft das array 
  for (var zlr = 0; zlr < tags.length; zlr++)
      {
      // ueberprueft ob der aktuelle Tag die gesuchte id hat und gibt
      // wenn ja denn Tag zurueck
      if (tags[zlr].id == p_id || tags[zlr].name == p_id)
         return(tags[zlr]);
      }
  // falls kein Tag zu der Id p_id exisitiert wird false zurueckgeliefert
  return(false);
  }

//**********************************************************************
function jtec_getNodeByType(p_domstruktur, p_tagname, p_type)
//**********************************************************************
// gibt die Referenzen auf den in der uebergebenen p_domstruktur enthaltenen
// Knoten vom gewuenschten Type in einem numerischen Array zurueck
  {
  // laedt alle Elemente eines bestimmten TagTypen in tags(numerisches Array)
  var tags = p_domstruktur.getElementsByTagName(p_tagname);
  var retarr = Array();
  // durchlaeuft das array 
  for (var zlr = 0; zlr < tags.length; zlr++)
      {
      // ueberprueft ob der aktuelle Tag den gesuchten Type hat und speicher
      // wenn ja diesem im array
      if (tags[zlr].getAttribute('type') == p_type)
         retarr.push(tags[zlr]);
      }
  return retarr;
  }

//*****************************************************************************
function jtec_allInputFieldsInArray(p_arr,p_node)
//*****************************************************************************
// Laed alle Eingabefelder eines Knoten in ein Array
  {
  var child = p_node.firstChild;
  //for (var i = 0; i < p_node.childNodes.length; i++)
  while(child)
      {
      if (child.hasChildNodes())
          {
          jtec_allInputFieldsInArray(p_arr,child);
          }
      var nodename = child.nodeName;
      if (nodename == "INPUT" || nodename == "SELECT" || nodename == "TEXTAREA")
         {
         p_arr.push(child);
         }
      child = child.nextSibling;
      }
  }

//*****************************************************************************
function jtec_allChildesOfGroupInArray(p_grouparr,p_group,p_node)
//*****************************************************************************
// Hilfsfunktion fuer jtec_getData welche alle Knoten einer Gruppe p_group
// in das Array p_grouparray speichert
  {
  for (var i = 0; i < p_node.childNodes.length; i++)
    {
    if (p_node.childNodes[i].hasChildNodes())
       {
       jtec_allChildesOfGroupInArray(p_grouparr,p_group,p_node.childNodes[i]);
       }
    if (p_node.childNodes[i].nodeName != "#text" && p_node.childNodes[i].getAttribute('group') == p_group)
       {
       p_grouparr.push(p_node.childNodes[i]);
       }
    }
  }

//*****************************************************************************
function jtec_getData(p_group,p_fenster)
//*****************************************************************************
  { 
  // Liest die Formularelement einer bestimmten Gruppe p_group in einem Fenster 
  // p_fensterid , aus und gibt die Daten in einen Array ret zurueck. Auf die 
  // Felder kann dan mit ret[idimtemplat_i] drauf zurgeriffen werden,  wobei i 
  // die Position im Feld darstellt. Damit wird der Fall abgefangen das id_s 
  // doppeltvergeben sind was z.B bei dynamischen Tabellen autritt.
  // p_group   - kann eine Array mit den Elementen sein oder ein String welcher die Gruppe beschreibt
  // p_fenster - gibt im fall das p_group ein String ist die Schnittstelle an wo die Objekte geladen werden sollen
  var ret = new Array(); // RueckgabeArray
  var grouparr = new Array(); // Array in welche alle knoten vom typ p_group geladen werden
  var idarr = new Array(); // Iddarray haelt fest wieviel Knoten es zu einer bestimmt Id gibt (assoziertes Array)
  if (typeof(p_group) == 'object')
     var grouparr = p_group;
  else
     jtec_allChildesOfGroupInArray(grouparr,p_group,p_fenster); // laedt alle Knoten in das grouparray
  //Initialisierung des IdArrays idarr

  for (var j = 0; j < grouparr.length; j++)
     {
     if (!idarr[grouparr[j].name])
        {
        idarr[grouparr[j].name] = 0;
        ret[grouparr[j].name] = Array();
        }
     }
  // speichert die einzelenen werte der Knoten aus grouparrr in das rueckgabearray 
  for (var i = 0; i < grouparr.length; i++)
      {
       // Falls grouparr[i] ein Input-Object ist und den Type radio oder checkbox hat nehme die Sonderfaelle
       if (grouparr[i].nodeName == 'SELECT')
          {
          var options = grouparr[i].getElementsByTagName('option');
          for (var zlr = 0 ; zlr < options.length; zlr++)
              {
              if (options[zlr].selected)
                 {
                 ret[grouparr[i].name][idarr[grouparr[i].name]] = options[zlr].value;
                 idarr[grouparr[i].name]++;
                 }
              }
          }
       else
          {
          switch (grouparr[i].type)
            {
            // Sonderfall der Radiobuttons
            case 'radio':
            if (grouparr[i].checked)
               {
               ret[grouparr[i].name][idarr[grouparr[i].name]] = grouparr[i].value;
               idarr[grouparr[i].name]++;
               }
            break;
            // Sonderfall einer Checkbox
            case 'checkbox':
               if (grouparr[i].checked)
                  {
                  ret[grouparr[i].name][idarr[grouparr[i].name]] = grouparr[i].value;
                  idarr[grouparr[i].name]++;
                  }
            break;
            case 'file':
              if (grouparr[i].getAttribute('imsDateiId'))
                 {
                 ret[grouparr[i].name][idarr[grouparr[i].name]] = grouparr[i].getAttribute('imsDateiId');
                 idarr[grouparr[i].name]++;
                 }
              else
                 {
                 alert('Es wurde keine DateiIdentifikator gefunden:jtec_getData');
                 }
            break;
            // Standardfall, value des Feldes wird einfach uebergeben
            default:
               ret[grouparr[i].name][idarr[grouparr[i].name]] = grouparr[i].value;
               idarr[grouparr[i].name]++;
            break;
            }
          }
      }
  return ret; // RueckgabeArray
  }

//*****************************************************************************
function jtec_deleteInputFields(p_group,p_fenster)
//*****************************************************************************
// loescht den Inhalt aller Inputfelder (text oder Textarea) eine Gruppe p_group
// in einem Fenster p_fenster
  {
  var grouparr = new Array();
  jtec_allChildesOfGroupInArray(grouparr,p_group,p_fenster);
  for (var i = 0; i < grouparr.length; i++)
    {
    if (grouparr[i].type == "text" || grouparr[i].nodeName == "textarea")
       grouparr[i].value = "";
    }
  }
  
//*****************************************************************************
function jtec_getAlleKnotenDurchlaufen(p_node, p_knoten)
//*****************************************************************************
  {
  for (var zlr = 0, n = p_node.childNodes.length; zlr < n; zlr++)
      {
      jtec_getAlleKnotenDurchlaufen(p_node.childNodes[zlr], p_knoten);
      p_knoten.push(p_node.childNodes[zlr]);
      }
  }

//*****************************************************************************
function jtec_getAlleKnoten(p_node)
//*****************************************************************************
  {
  var knoten = Array();
  jtec_getAlleKnotenDurchlaufen(p_node, knoten);
  return knoten;
  }

  
//*****************************************************************************
function jtec_cloneNode(p_node)
//*****************************************************************************
// diese Funktion klont ein DOM objekt und faengt auhc einige Sonderfaelle ab.
// Quasi eine verbessert javascrip cloneNode -Funktion
  {
  var clone = p_node.cloneNode(true);
  var attr = '';

  var alleknoten = jtec_getAlleKnoten(p_node);
  var clonealleknoten = jtec_getAlleKnoten(clone);

  for (var zlr = 0, n = alleknoten.length; zlr < n; zlr++)
    {
    switch (alleknoten[zlr].nodeName)
      {
      case "TABLE":
        if (alleknoten[zlr].getAttribute('headerheight')) clonealleknoten[zlr].setAttribute('headerheight',alleknoten[zlr].getAttribute('headerheight')); 
      break;
      case "TD":
        if (alleknoten[zlr].parameter) clonealleknoten[zlr].parameter = alleknoten[zlr].parameter ; 
      break;
      case "TH":
        attr = alleknoten[zlr].getAttribute('index');                 if (attr) clonealleknoten[zlr].setAttribute('index',attr); 
        attr = alleknoten[zlr].getAttribute('multiindex');            if (attr) clonealleknoten[zlr].setAttribute('multiindex',attr); 
        attr = alleknoten[zlr].getAttribute('indentifikationsindex'); if (attr) clonealleknoten[zlr].setAttribute('indentifikationsindex',attr); 
        attr = alleknoten[zlr].getAttribute('sortable');              if (attr) clonealleknoten[zlr].setAttribute('sortable',attr); 
        attr = alleknoten[zlr].getAttribute('suchindex');             if (attr) clonealleknoten[zlr].setAttribute('suchindex',attr); 
        attr = alleknoten[zlr].getAttribute('sortname');              if (attr) clonealleknoten[zlr].setAttribute('sortname',attr); 
        attr = alleknoten[zlr].getAttribute('sortindex');             if (attr) clonealleknoten[zlr].setAttribute('sortindex',attr); 
        attr = alleknoten[zlr].getAttribute('spezialfunktion');       if (attr) clonealleknoten[zlr].setAttribute('spezialfunktion',attr); 
      break;
      case "SELECT":
        clonealleknoten[zlr].multiple = alleknoten[zlr].multiple;
      break;
      case "OPTION":
        clonealleknoten[zlr].selected = alleknoten[zlr].selected;
      break;
      case "DIV":
        attr = alleknoten[zlr].getAttribute('abkuerzung');            if (attr) clonealleknoten[zlr].setAttribute('abkuerzung',attr); 
        attr = alleknoten[zlr].getAttribute('alternativsuche');       if (attr) clonealleknoten[zlr].setAttribute('alternativsuche',attr); 
        attr = alleknoten[zlr].getAttribute('aktionen');              if (attr) clonealleknoten[zlr].setAttribute('aktionen',attr);
        attr = alleknoten[zlr].getAttribute('bezeichnung');           if (attr) clonealleknoten[zlr].setAttribute('bezeichnung',attr);
        attr = alleknoten[zlr].getAttribute('breaks');                if (attr) clonealleknoten[zlr].setAttribute('breaks',attr);
        attr = alleknoten[zlr].getAttribute('erlaubtestati');         if (attr) clonealleknoten[zlr].setAttribute('erlaubtestati',attr);
        attr = alleknoten[zlr].getAttribute('idspzn');                if (attr) clonealleknoten[zlr].setAttribute('idspzn',attr);
        attr = alleknoten[zlr].getAttribute('imsknoten');             if (attr) clonealleknoten[zlr].setAttribute('imsknoten','Y'); 
        attr = alleknoten[zlr].getAttribute('imstable');              if (attr) clonealleknoten[zlr].setAttribute('imstable',attr);
        attr = alleknoten[zlr].getAttribute('index');                 if (attr) clonealleknoten[zlr].setAttribute('index',attr);
        attr = alleknoten[zlr].getAttribute('label');                 if (attr) clonealleknoten[zlr].setAttribute('label',attr);
        attr = alleknoten[zlr].getAttribute('lines');                 if (attr) clonealleknoten[zlr].setAttribute('lines',attr);
        attr = alleknoten[zlr].getAttribute('nobr');                  if (attr) clonealleknoten[zlr].setAttribute('nobr',attr);
        attr = alleknoten[zlr].getAttribute('objekttyp');             if (attr) clonealleknoten[zlr].setAttribute('objekttyp',attr);
        attr = alleknoten[zlr].getAttribute('proseite');              if (attr) clonealleknoten[zlr].setAttribute('proseite',attr);
        attr = alleknoten[zlr].getAttribute('pflichtfeld');           if (attr) clonealleknoten[zlr].setAttribute('pflichtfeld',attr);
        attr = alleknoten[zlr].getAttribute('skalierbar');            if (attr) clonealleknoten[zlr].setAttribute('skalierbar',attr);
        attr = alleknoten[zlr].getAttribute('sortierspalte');         if (attr) clonealleknoten[zlr].setAttribute('sortierspalte',attr);
        attr = alleknoten[zlr].getAttribute('src');                   if (attr) clonealleknoten[zlr].setAttribute('src',attr);
        attr = alleknoten[zlr].getAttribute('suche');                 if (attr) clonealleknoten[zlr].setAttribute('suche',attr);
        attr = alleknoten[zlr].getAttribute('sucheigenschaften');     if (attr) clonealleknoten[zlr].setAttribute('sucheigenschaften',attr);
        attr = alleknoten[zlr].getAttribute('suchobjid');             if (attr) clonealleknoten[zlr].setAttribute('suchobjid',attr);
        attr = alleknoten[zlr].getAttribute('suchposition');          if (attr) clonealleknoten[zlr].setAttribute('suchobjekttyp',attr);
        attr = alleknoten[zlr].getAttribute('suchproseite');          if (attr) clonealleknoten[zlr].setAttribute('suchproseite',attr);
        attr = alleknoten[zlr].getAttribute('suchreltyp');            if (attr) clonealleknoten[zlr].setAttribute('suchreltyp',attr);
        attr = alleknoten[zlr].getAttribute('suchsortierrichtung');   if (attr) clonealleknoten[zlr].setAttribute('suchsortierrichtung',attr);
        attr = alleknoten[zlr].getAttribute('suchtabelle');           if (attr) clonealleknoten[zlr].setAttribute('suchtabelle',attr);
        attr = alleknoten[zlr].getAttribute('suchtyp');               if (attr) clonealleknoten[zlr].setAttribute('suchtyp',attr);
        attr = alleknoten[zlr].getAttribute('suchautoload');          if (attr) clonealleknoten[zlr].setAttribute('suchautoload',attr);
        attr = alleknoten[zlr].getAttribute('tabellenkapselung');     if (attr) clonealleknoten[zlr].setAttribute('tabellenkapselung',attr);
        attr = alleknoten[zlr].getAttribute('template');              if (attr) clonealleknoten[zlr].setAttribute('template',attr);
        attr = alleknoten[zlr].getAttribute('templateparameter');     if (attr) clonealleknoten[zlr].setAttribute('templateparameter',attr);
        attr = alleknoten[zlr].getAttribute('title');                 if (attr) clonealleknoten[zlr].setAttribute('title',attr);
        attr = alleknoten[zlr].getAttribute('type');                  if (attr) clonealleknoten[zlr].setAttribute('type',attr);
        attr = alleknoten[zlr].getAttribute('viewheight');            if (attr) clonealleknoten[zlr].setAttribute('viewheight',attr);
        attr = alleknoten[zlr].getAttribute('viewoptions');           if (attr) clonealleknoten[zlr].setAttribute('viewoptions',attr);
        attr = alleknoten[zlr].getAttribute('viewtype');              if (attr) clonealleknoten[zlr].setAttribute('viewtype',attr);
        attr = alleknoten[zlr].getAttribute('viewwidth');             if (attr) clonealleknoten[zlr].setAttribute('viewwidth',attr);
        attr = alleknoten[zlr].getAttribute('voreinstellung');        if (attr) clonealleknoten[zlr].setAttribute('voreinstellung',attr);
        attr = alleknoten[zlr].getAttribute('wertebereich');          if (attr) clonealleknoten[zlr].setAttribute('wertebereich',attr);
        attr = alleknoten[zlr].getAttribute('readonly');              if (attr) clonealleknoten[zlr].setAttribute('readonly',attr);
        attr = alleknoten[zlr].getAttribute('sortierspalte');         if (attr) clonealleknoten[zlr].setAttribute('sortierspalte',attr);
        attr = alleknoten[zlr].getAttribute('imsstyle');              if (attr) clonealleknoten[zlr].setAttribute('imsstyle',attr);
        attr = alleknoten[zlr].getAttribute('bildanzeigen');          if (attr) clonealleknoten[zlr].setAttribute('bildanzeigen',attr);
        attr = alleknoten[zlr].getAttribute('orginalgroesse');        if (attr) clonealleknoten[zlr].setAttribute('orginalgroesse',attr);
        attr = alleknoten[zlr].getAttribute('imgheight');             if (attr) clonealleknoten[zlr].setAttribute('imgheight',attr);
        attr = alleknoten[zlr].getAttribute('imgwidth');              if (attr) clonealleknoten[zlr].setAttribute('imgwidth',attr);
        attr = alleknoten[zlr].getAttribute('bildonhover');           if (attr) clonealleknoten[zlr].setAttribute('bildonhover',attr);
        attr = alleknoten[zlr].getAttribute('objektlinkmodus');       if (attr) clonealleknoten[zlr].setAttribute('objektlinkmodus',attr);
        attr = alleknoten[zlr].getAttribute('group');                 if (attr) clonealleknoten[zlr].setAttribute('group',attr);
        attr = alleknoten[zlr].getAttribute('einfachdatum');          if (attr) clonealleknoten[zlr].setAttribute('einfachdatum',attr);
        attr = alleknoten[zlr].getAttribute('relationstyp');          if (attr) clonealleknoten[zlr].setAttribute('relationstyp',attr);
        attr = alleknoten[zlr].getAttribute('spitzname');             if (attr) clonealleknoten[zlr].setAttribute('spitzname',attr);
        attr = alleknoten[zlr].getAttribute('position');              if (attr) clonealleknoten[zlr].setAttribute('position',attr);
        attr = alleknoten[zlr].getAttribute('multi');                 if (attr) clonealleknoten[zlr].setAttribute('multi',attr);
        attr = alleknoten[zlr].getAttribute('maxzeilenanzahl');       if (attr) clonealleknoten[zlr].setAttribute('maxzeilenanzahl',attr);
        attr = alleknoten[zlr].getAttribute('title');                 if (attr) clonealleknoten[zlr].setAttribute('title',attr);
        attr = alleknoten[zlr].getAttribute('valuefield');            if (attr) clonealleknoten[zlr].setAttribute('valuefield',attr);
        attr = alleknoten[zlr].getAttribute('suchparam');             if (attr) clonealleknoten[zlr].setAttribute('suchparam',attr);
        attr = alleknoten[zlr].getAttribute('relelems');              if (attr) clonealleknoten[zlr].setAttribute('relelems',attr);

        // hier folgen die ganzen DOJO Attribute
        attr = alleknoten[zlr].getAttribute('activeSizing');          if (attr) clonealleknoten[zlr].setAttribute('activeSizing',attr);
        attr = alleknoten[zlr].getAttribute('height');                if (attr) clonealleknoten[zlr].setAttribute('height',attr);
        attr = alleknoten[zlr].getAttribute('label');                 if (attr) clonealleknoten[zlr].setAttribute('label',attr);
        attr = alleknoten[zlr].getAttribute('labelPosition');         if (attr) clonealleknoten[zlr].setAttribute('labelPosition',attr);
        attr = alleknoten[zlr].getAttribute('layoutAlign');           if (attr) clonealleknoten[zlr].setAttribute('layoutAlign',attr);
        attr = alleknoten[zlr].getAttribute('layoutChildPriority');   if (attr) clonealleknoten[zlr].setAttribute('layoutChildPriority',attr);
        attr = alleknoten[zlr].getAttribute('orientation');           if (attr) clonealleknoten[zlr].setAttribute('orientation',attr);
        attr = alleknoten[zlr].getAttribute('sizeMin');               if (attr) clonealleknoten[zlr].setAttribute('sizeMin',attr);
        attr = alleknoten[zlr].getAttribute('sizerWidth');            if (attr) clonealleknoten[zlr].setAttribute('sizerWidth',attr);
        attr = alleknoten[zlr].getAttribute('sizeShare');             if (attr) clonealleknoten[zlr].setAttribute('sizeShare',attr);
        attr = alleknoten[zlr].getAttribute('width');                 if (attr) clonealleknoten[zlr].setAttribute('width',attr);
        attr = alleknoten[zlr].getAttribute('caption');               if (attr) clonealleknoten[zlr].setAttribute('caption',attr);
        attr = alleknoten[zlr].getAttribute('iconsrc');               if (attr) clonealleknoten[zlr].setAttribute('iconsrc',attr);
        attr = alleknoten[zlr].getAttribute('widgetid');              if (attr) clonealleknoten[zlr].setAttribute('widgetid',attr);
        attr = alleknoten[zlr].getAttribute('resizable');             if (attr) clonealleknoten[zlr].setAttribute('resizable',attr);
        attr = alleknoten[zlr].getAttribute('submenuid');             if (attr) clonealleknoten[zlr].setAttribute('submenuid',attr);
        attr = alleknoten[zlr].getAttribute('dojoclick');             if (attr) clonealleknoten[zlr].setAttribute('dojoclick',attr);
        attr = alleknoten[zlr].getAttribute('taskbarid');             if (attr) clonealleknoten[zlr].setAttribute('taskbarid',attr);
        attr = alleknoten[zlr].getAttribute('multiview');             if (attr) clonealleknoten[zlr].setAttribute('multiview',attr);
        if (alleknoten[zlr].xmlchild)                                 clonealleknoten[zlr].xmlchild = alleknoten[zlr].xmlchild; 
      break;
      }
    }

  return clone;
  } 
//*****************************************************************************
function jtec_ladeTextInInputfeld(p_input,p_text)
//*****************************************************************************
// schreibt einen beliebigen Text in ein Inputfeld
  {
  p_input.value = p_text;
  }  
  
//*****************************************************************************
function jtec_stringInParameterSplitten(p_value)
//*****************************************************************************
// wandelt einen uebergebenen String in key=value paare um und gibt alle zusammen in einem Array zurueck
// z.B. aus: index="1" type="input" wasauchimmer="1234"
//     wird: Array("index" => "1", "type" => "input", "wasauchimmer" => "1234");
  {
  var ret = Array();
  var split = jtec_splitAtQuotes(p_value);
  for (var zlr = 0, n = split.length; zlr < n; zlr += 2)
      {
      split[zlr] = split[zlr].replace(/\W/g, "");
      val = '';
      if (func_isset(split[zlr+1]))
         val = split[zlr+1]; 
      ret[split[zlr]] = val;
      }
  return ret;
  }

  
  
  
//*****************************************************************************
function jtec_splitAtQuotes(p_value)
//*****************************************************************************
// splittet eine Zeichenkett so auf, dass sich nicht in anfuehrungszeichen gestezte zeichenketten und
// in anfuehrungszeichen gestezte zeichenketten abwechseln. Dabei wird immer mit einer nicht in anfuehrungszeichen gesetzten Kette begonnen
// z.B. hallo = "1" ballo = '0'   : wird zu Array("hallo = ","1"," ballo = ","0");
// und  "alles Dito" aufm "kah'n" : wird zu Array("", "alles Dito"," aufm ","kah'n");
  {
  var ret = Array();                    
  p_value = " " + p_value;
  var letzteszeichen='';
  var klammer = '';
  var splitpunkte = Array();
  for (var zlr = 0, n = p_value.length; zlr < n; zlr++)
      {
      if ((klammer == '') && ((p_value.charAt(zlr) == "'") || (p_value.charAt(zlr) == '"')))
         {
         klammer = p_value.charAt(zlr);
         splitpunkte.push(zlr);
         }
      else if ((klammer != '') && (p_value.charAt(zlr) == klammer) && (letzteszeichen != "\\"))
         {
         klammer = '';
         splitpunkte.push(zlr);
         }        
      }
  splitstart = 0;
  splitende  = 0;
  split = Array();
  for (var zlr = 0, n = splitpunkte.length; zlr < n; zlr++)
      {
      splitende = splitpunkte[zlr];
      split.push(p_value.substr(splitstart,splitende-splitstart));
      splitstart = splitende+1;
      }
  if (splitstart < p_value.length)
     split.push(p_value.substr(splitstart,p_value.length));
  return(split);
  }
  
//*****************************************************************************
function jtec_copyArray(p_array)
//*****************************************************************************
// gibt eine Kopie eines mehrdimensionalen Arrays zurueck
// !!!! der Array darf in sich keine rekursionen enthalten
  {
  if (!func_is_array(p_array)) 
     return p_array;
  var kopie = Array();
  for (var key in p_array)
      kopie[key] = jtec_copyArray(p_array[key]);
  return (kopie);
  }
  
//*****************************************************************************
function jtec_formatierePreis(p_preis,p_rundungsart)
//*****************************************************************************
// formatiert eine zahl als preis der auf 2 stellen nach dem komma
// angegeben wird. Rueckgabewert ist ein string
// mit rundungsart kann angegeben werden, ob der preis kaufmaennisch oder
// abgerundet werden soll gueltige werte sind 'round','trunc'
  {
  if (p_rundungsart == 'trunc')
     { p_preis = (Math.floor(p_preis*100)/100); } // abrunden
  else
     { p_preis = (Math.round(p_preis*100)/100); } // runden
  
  if (p_preis >= 0)
     p_preis += 0.001;
  else
     p_preis -= 0.001;
  floorpreis = Math.floor(Math.abs(p_preis));
  p_preis = p_preis.toString();
  floorpreis = floorpreis.toString();
  if (p_preis >= 0)
     var s = p_preis.substr(0,floorpreis.length+3);
  else
     var s = p_preis.substr(0,floorpreis.length+4);  
  return(s); 
  }
//*****************************************************************************
function jtec_voranstellendeZeichenEntfernen(p_stri, p_zeichen)
//*****************************************************************************
// erwartet einen String $p_stri, dem das in p_zeichen übergebenen Zeichen solange vorangestellt werden soll,
// bis die Länge des Strings >= dem in $p_stellen angegebenen Wert ist
  {
  neuerstri = p_stri; 
  while (neuerstri[0] == p_zeichen)
     {
     neuerstri = neuerstri.slice(1,neuerstri.length);
     }
  return(neuerstri);
  }