//---------------------------------------------- 
// kaimaan.js
//---------------------------------------------- 
var KaimaanJs = new Object();

// trace-ausgaben
KaimaanJs.enableDebug=false;

KaimaanJs.traceIt = function(text)
{
    if(window.KaimaanJs.enableDebug)
    {
       if(typeof(Sys) !='undefined')
          Sys.Debug.trace(text);
    }
}

//---------------------------------------------- 
KaimaanJs.getElementById = function(nodeID)
{
    var node = document.getElementById(nodeID);
    if(!node)
       KaimaanJs.traceIt("Fehler: KaimaanJs.getElementById: nicht gefunden: " + nodeID);
    return node;
}

KaimaanJs.ElementsByClassName = function(className)
{
		var hasClassName = new RegExp("(?:^|\\s)" + className + "(?:$|\\s)");
		var allElements = document.getElementsByTagName("*");
		var results = [];

		var element;
		for (var i = 0; (element = allElements[i]) != null; i++) 
        {
			var elementClass = element.className;
			if (elementClass && elementClass.indexOf(className) != -1 && hasClassName.test(elementClass))
				results.push(element);
		}

		return results;
}

KaimaanJs.GetIdOfFirstElement = function (nodes)
{
    if(nodes)
    {
        if(nodes.length>0)
            return nodes[0].id;
    }
    return "";
}

// http://www.dustindiaz.com/getelementsbyclass
KaimaanJs.GetElementsByClassName = function(searchClass,node,tag) {
	var classElements = new Array();
	if ( node == null )
		node = document;
	if ( tag == null )
		tag = '*';
	var els = node.getElementsByTagName(tag);
	var elsLen = els.length;
	var pattern = new RegExp("(^|\\s)"+searchClass+"(\\s|$)");
	for (i = 0, j = 0; i < elsLen; i++) {
		if ( pattern.test(els[i].className) ) {
			classElements[j] = els[i];
			j++;
		}
	}
	return classElements;
}



//---------------------------------------------- 
// Bug in AJAX - Sys$CultureInfo$_getAbbrMonthIndex
// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=277646
// http://stackoverflow.com/questions/124457/-net-how-do-you-register-a-startup-script
// wr, 5.2.2009
//KaimaanJs.fixAjaxBug = function()
//{
//    Sys.CultureInfo.prototype._getAbbrMonthIndex = function(value)
//    //    function Sys$CultureInfo$_getAbbrMonthIndex(value)
//    {
//        if (!this._upperAbbrMonths) {
//            this._upperAbbrMonths = this._toUpperArray(this.dateTimeFormat.AbbreviatedMonthNames);
//        }
//        return Array.indexOf(this._upperAbbrMonths, this._toUpper(value));
//    }
//}
//Sys.Application.add_load(KaimaanJs.fixAjaxBug);
//---------------------------------------------- 
KaimaanJs.withResetScrollY=false;
KaimaanJs.actualScrollY=0;
KaimaanJs.idFieldScrollPos="idFieldScrollPos";
//---------------------------------------------- 
// set on server:
// Sys.Application.add_load(KaimaanJs.onLoad);

KaimaanJs.onLoad = function()
{
    if(KaimaanJs.withResetScrollY)
        KaimaanJs.resetScrollY();
    else
        KaimaanJs.scrollToLastY();

    // event-handler zum speichern der aktuellen y-position
    var element = document.body;
    if(element)
        $addHandler(element, "click", KaimaanJs.noticeActualScrollY);

    element = $get("tf_content_container");
    if(element)
        $addHandler(element, "click", KaimaanJs.noticeActualScrollY);
}

KaimaanJs.onUnload = function()
{
    var element = document.body;
    if(element)
        $removeHandler(element, "click", KaimaanJs.noticeActualScrollY);

    element = $get("tf_content_container");
    if(element)
        $clearHandlers(element);
}


KaimaanJs.scrollToLastY = function()
{
     var pos = KaimaanJs.getElementById(KaimaanJs.idFieldScrollPos).value;
     if(pos)
     {
         // WebForm_SetScrollY(pos);
         document.documentElement.scrollTop = pos;
     }
}

KaimaanJs.resetScrollY = function()
{
    window.scrollTo(0,0);
}

KaimaanJs.noticeActualScrollY = function(sender)
{   
    KaimaanJs.actualScrollY = WebForm_GetScrollY();
    KaimaanJs.getElementById(KaimaanJs.idFieldScrollPos).value = KaimaanJs.actualScrollY;
}

//---------------------------------------------- 
// aus Eric's weblog: Weird Thoughts From Eric's Head 
// http://radio.javaranch.com/pascarello/2005/01/09/1105293729000.html
function ScrollToElement(theElement, offsetX, offsetY)
{
  var selectedPosX = 0;
  var selectedPosY = 0;
  while(theElement != null)
  {
    selectedPosX += theElement.offsetLeft;
    selectedPosY += theElement.offsetTop;
    theElement = theElement.offsetParent;
  }

 if(offsetX)
   selectedPosX += offsetX;

 if(offsetY)
   selectedPosY += offsetY;
                        		      
 window.scrollTo(selectedPosX,selectedPosY);
}

//---------------------------------------------- 
KaimaanJs.enableDisableInput = function(enable, startnodeID)
{
    var startnode = KaimaanJs.getElementById(startnodeID);
    if(startnode)
    {
         var nodeType = 1
         KaimaanJs.visitChildren(startnode, nodeType, enable, KaimaanJs.enableDisableNode);
    }
    KaimaanJs.displayNode(startnodeID, enable)
}

//---------------------------------------------- 
KaimaanJs.visitChildren = function(parent, node_type, infos, doOnNode)
{
    if(parent.nodeType == node_type)
        doOnNode(parent, infos);

    for(var i = 0; i< parent.childNodes.length; i++)
    {
         var child = parent.childNodes[i];
         {
           KaimaanJs.visitChildren(child, node_type, infos, doOnNode)
         }
    }
}

//---------------------------------------------- 
KaimaanJs.enableDisableNode = function(node, enable)
{
     var s = node.nodeName + ', ' + node.nodeValue + ', ' + node.nodeType;
     KaimaanJs.traceIt(s);

     if(node.nodeType==1)
     {
         var name = node.nodeName.toLowerCase();
         if((name =='input') || (name =='textarea') || (name =='span') || (name =='label')|| (name =='table')|| (name =='div'))
              node.disabled = !enable;

         KaimaanJs.resetNodeValue(node, name)
     }
}

//---------------------------------------------- 
KaimaanJs.resetNodeValue = function(node, nodeName)
{
     if((name =='input') || (name =='textarea'))
     {
          if((node.type=='radio')||(node.type=='checkbox'))
              node.checked = false;
          else
              node.value = '';
     }
}

//---------------------------------------------- 
KaimaanJs.displayNode = function(nodeID, displayIt)
{
    var node = KaimaanJs.getElementById(nodeID);
    if(node)
    {
         if(displayIt)         
             node.style.display = "block";
         else
             node.style.display = "none";
     }
}

//---------------------------------------------- 
KaimaanJs.displayElement = function(node, displayIt)
{
    if(node)
    {
         if(displayIt)         
             node.style.display = "block";
         else
             node.style.display = "none";
     }
}

//---------------------------------------------- 
KaimaanJs.displayTableRow = function(node, displayIt)
{
    if(node)
    {
         if(displayIt)         
             node.style.display = "table-row";
         else
             node.style.display = "none";
     }
}

//---------------------------------------------- 
KaimaanJs.isNodeVisible = function(nodeID)
{
    var isVisible = true;

    var node = KaimaanJs.getElementById(nodeID);
    if(node)
    {
          if(node.currentStyle)
          {
               if(node.currentStyle.visibility=='hidden' || node.currentStyle.display=='none')
                  isVisible = false;
          }
          else 
          {
               // Firefox
              if(getComputedStyle)
                  if(getComputedStyle(node,'').getPropertyValue('visibility')=='hidden' || getComputedStyle(node,'').getPropertyValue('display')=='none' ) 
                      isVisible = false;
          }
     }
     return isVisible;
}
//---------------------------------------------- 
KaimaanJs.displayAllNodes = function(nodeIDs, displayIt)
{
    var nodeArray = nodeIDs.split(",");

    for(var i=0; i < nodeArray.length; i++) 
    {
        KaimaanJs.displayNode(nodeArray[i], displayIt);
    }
}
//---------------------------------------------- 
KaimaanJs.displayNodeSubset = function(allNodeIDs, nodeIDs)
{
    KaimaanJs.displayAllNodes(allNodeIDs, false);
    KaimaanJs.displayAllNodes(nodeIDs, true);
}

//---------------------------------------------- 
KaimaanJs.displayNodeWithValidators = function(nodeID, displayIt, validatorIDs)
{
    var node = KaimaanJs.getElementById(nodeID);
    if(node)
    {
         if(displayIt)         
             node.style.display = "block";
         else
             node.style.display = "none";

         KaimaanJs.enableValidators(validatorIDs, displayIt)
     }
}
//---------------------------------------------- 
KaimaanJs.removeNode = function(nodeID)
{
    var node = KaimaanJs.getElementById(nodeID);
    if(node)
    {
        node.parentNode.removeChild(node);
    }
}
//---------------------------------------------- 
KaimaanJs.enableValidators = function(validatorIDs, enable)
{
    var nodeArray = validatorIDs.split(",");

    for(var i=0; i < nodeArray.length; i++) 
    {
        KaimaanJs.enableValidator(nodeArray[i], enable);
    }
}

//---------------------------------------------- 
KaimaanJs.enableValidator = function(nodeID, enable)
{
    var validator = KaimaanJs.getElementById(nodeID);
    if(validator)
        ValidatorEnable(validator, enable);
}
//---------------------------------------------- 
KaimaanJs.toggleDisplayNode = function(nodeID)
{
    var node = KaimaanJs.getElementById(nodeID);
    if(node)
    {
         if(node.style.display == "none")         
             node.style.display = "block";
         else
             node.style.display = "none";
     }
}

//---------------------------------------------- 
KaimaanJs.setInnerHTML = function(nodeID, html)
{
    var node = KaimaanJs.getElementById(nodeID);
    if(node)
    {
       node.innerHTML=html;
    }
}
//---------------------------------------------- 
KaimaanJs.setText = function(nodeID, text)
{
    var node = KaimaanJs.getElementById(nodeID);
    if(node)
    {
       if(document.all)
           node.innerText=text;
       else
           node.textContent=text;
    }
}
//---------------------------------------------- 
KaimaanJs.getText = function(nodeID)
{
    var node = KaimaanJs.getElementById(nodeID);
    var result = "";
    if(node)
    {
       if(document.all)
           result = node.innerText;
       else
           result = node.textContent;
    }
    return result;
}
//---------------------------------------------- 
KaimaanJs.setButtonText = function(nodeID, text)
{
    var node = KaimaanJs.getElementById(nodeID);
    if(node)
    {
       if(document.all)
           node.innerText=text;
       else
           node.value=text;
    }
}
//---------------------------------------------- 
KaimaanJs.showWebRequestError = function(executor)
{
    KaimaanJs.traceIt("KaimaanJs.showWebRequestError: Status: [" + executor.get_statusCode() + " " + executor.get_statusText() + "]" );

    if (executor.get_timedOut())
    {
        alert("KaimaanJs.showWebRequestError: Timed Out");
        KaimaanJs.traceIt("KaimaanJs.showWebRequestError: Timed out");
    }
    else
        if (executor.get_aborted())
        {
            alert("KaimaanJs.showWebRequestError: Aborted");
            KaimaanJs.traceIt("KaimaanJs.showWebRequestError: Aborted");
        }
}
//---------------------------------------------- 
KaimaanJs.getDummyGuid = function()
{
    var d = new Date();
    return '' + d.valueOf();
}
//---------------------------------------------- 
KaimaanJs.addGuidArgument = function(url)
{
    return url + '&guid=' + KaimaanJs.getDummyGuid();
}
//---------------------------------------------- 
KaimaanJs.printContent = function(strid)
{
    var prtContent = document.getElementById(strid);
    var winPrint = window.open('','','letf=0,top=0,width=1,height=1,toolbar=0,scrollbars=0,status=0');
    winPrint.document.write(prtContent.innerHTML);
    winPrint.document.close();
    winPrint.focus();
    winPrint.print();
    winPrint.close();
}
//---------------------------------------------- 
KaimaanJs.printWindow = function(url)
{
    var args = "height=800px, width=800px, status=yes, resizable=yes, location=no, menubar=yes, toolbar=yes, top=50px, left=50px, scrollbars=yes";
    var winPrint = window.open(url,'',args);
    winPrint.focus();
}

//---------------------------------------------- 
// hilfe-popup für eine seite anzeigen
var PageHelp= new Object();

// parameter, die vom server gesetzt werden
PageHelp.url='';
PageHelp.buttonID = '';

PageHelp.doOnLoad = function()
{
    KaimaanJs.traceIt('PageHelp.doOnLoad');

    var visible = PageHelp.url.length > 0;
    KaimaanJs.displayNode(PageHelp.buttonID, visible);
}

KaimaanJs.showPageHelp = function()
{
    var args = "height=600px, width=760px, status=no, resizable=yes, location=no, menubar=no, toolbar=no, top=0px, left=0px, scrollbars=yes";
    var myWindow = window.open(PageHelp.url,'',args);
    myWindow.focus();
}

//---------------------------------------------- 
// http://blogs.msdn.com/giorgio/archive/2009/04/14/how-to-detect-ie8-using-javascript-client-side.aspx
KaimaanJs.getInternetExplorerVersion = function() 
{    var rv = -1; // Return value assumes failure.    
     if (navigator.appName == 'Microsoft Internet Explorer') 
     {
        var ua = navigator.userAgent;
        var re = new RegExp("MSIE ([0-9]{1,}[\.0-9]{0,})");
        if (re.exec(ua) != null)
            rv = parseFloat(RegExp.$1);
     }    
     return rv;
}
//---------------------------------------------- 
KaimaanJs.showViewStateSize = function()
{
    var buf = '';
    var bufCompressed = '';
    var node = KaimaanJs.getElementById("__VIEWSTATE");
    if(node)
    {
        buf = node.value;
    }
    node = KaimaanJs.getElementById("__VSTATE");
    if(node)
    {
        bufCompressed = node.value;
    }
    alert("Length: View state: " + buf.length + " (compressed: " + bufCompressed.length + ")");
}


//---------------------------------------------- 
KaimaanJs.getSelectedValueRadioButtonList = function(rbListID) 
{ 
   var RB1 = document.getElementById(rbListID);
   var radio = RB1.getElementsByTagName("input"); 
   var label = RB1.getElementsByTagName("label"); 
   for (var i=0;i<radio.length;i++) 
   { 
       if (radio[i].checked) 
       { 
           return radio[i].value; 
           // label[i].innerHTML; 
       } 
   } 
   return ""; 
} 

//---------------------------------------------- 
KaimaanJs.validateEmailFormat = function(source, arguments)
{
//debugger;
    var text = arguments.Value;
    // !ESC!02! wegen C1Combobox
    //var reg = /\w+([-+.]\w+)*(!ESC!02!|@)\w+([-.]\w+)*\.\w+([-.]\w+)*/;
    var regString = "\\w+([-+.]\\w+)*(!ESC!02!|@)\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";
    var rX = new RegExp(regString);
    //    var reg = /\w+([-+.]\w+)*(!ESC!02!|@)\w+([-.]\w+)*\.\w+([-.]\w+)*/;
    arguments.IsValid = rX.test(text);
}

KaimaanJs.validateEmailFormatOptional = function(source, arguments)
{
//debugger;
    var text = arguments.Value;

    // !ESC!02! wegen C1Combobox
    var reg = /^(\w+([-+.]\w+)*(!ESC!02!|@)\w+([-.]\w+)*\.\w+([-.]\w+)*)*$/;
    arguments.IsValid = reg.test(text);

    var regString = "^(\\w+([-+.]\\w+)*(!ESC!02!|@)\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*)*$";
    var rX = new RegExp(regString);
    arguments.IsValid = rX.test(text);
}

//---------------------------------------------- 
// collapsible panel
KaimaanJs.CollapsiblePanelBehavior="";

KaimaanJs.OpenCollapsiblePanel= function()
{
    $find(KaimaanJs.CollapsiblePanelBehavior)._doOpen();
}

KaimaanJs.OpenAllCollapsiblePanels= function(open, IDs)
{
   var idArray = IDs.split(",");

    for(var i=0; i < idArray.length; i++) 
    {
        var id = idArray[i];
        if(open) 
           $find(id)._doOpen();
       else
           $find(id)._doClose();
   }
   return false;
}



KaimaanJs.DoOnNodes = function(nodes, doOnFunc)
{
		var node;
		for (var i = 0; (node = nodes[i]) != null; i++) 
        {
              doOnFunc(node);
		}
}


KaimaanJs.HideNode = function(node)
{
       KaimaanJs.displayElement(node, false);
}

KaimaanJs.ShowNode = function(node)
{
       KaimaanJs.displayElement(node, true);
}

KaimaanJs.ToggleDisplayNodes = function(cssClassName, buttonID, buttonText1, buttonText2)
{
    var nodes = KaimaanJs.ElementsByClassName(cssClassName);
    if(nodes && nodes.length >0)
    {
         if(nodes[0].style.display != "block")
              KaimaanJs.DoOnNodes(nodes, KaimaanJs.ShowNode);
        else
              KaimaanJs.DoOnNodes(nodes, KaimaanJs.HideNode);
    }

    if(buttonID)
    {
         var text =  nodes[0].style.display == "block"? buttonText2 : buttonText1;
         KaimaanJs.setButtonText(buttonID, text);
    }
}

/* eine tabellenzeilen ein- / ausblenden (im ie9 nicht notwendig, aber im firefox */
KaimaanJs.HideTableRow = function(node)
{
       KaimaanJs.displayTableRow(node, false);
}

KaimaanJs.ShowTableRow = function(node)
{
       KaimaanJs.displayTableRow(node, true);
}

KaimaanJs.ToggleDisplayTableRow = function(cssClassName, buttonID, buttonText1, buttonText2)
{
    var nodes = KaimaanJs.ElementsByClassName(cssClassName);
    if(nodes && nodes.length >0)
    {
         if(nodes[0].style.display != "table-row")
              KaimaanJs.DoOnNodes(nodes, KaimaanJs.ShowTableRow);
        else
              KaimaanJs.DoOnNodes(nodes, KaimaanJs.HideTableRow);
    }

    if(buttonID)
    {
         var text =  nodes[0].style.display == "table-row"? buttonText2 : buttonText1;
         KaimaanJs.setButtonText(buttonID, text);
    }
}

KaimaanJs.ToggleDisplayChildren = function(cssClassName, parentID)
{
    var parentNode = KaimaanJs.getElementById(parentID);
    if(parentNode)
    {
        var tag = null;
        var nodes = KaimaanJs.GetElementsByClassName(cssClassName, parentNode, tag);
        if(nodes && nodes.length >0)
        {
            if(nodes[0].style.display != "block")
                 KaimaanJs.DoOnNodes(nodes, KaimaanJs.ShowNode);
           else
                 KaimaanJs.DoOnNodes(nodes, KaimaanJs.HideNode);
         }
    }
}//---------------------------------------------- 
// js-modul: checkboxlist
// Eine CheckboxList (entsprechend Asp.net-Serverelement) erstellen
//---------------------------------------------- 
var CheckboxList = new Object();

CheckboxList.AppendCheckboxList = function(parentID, texts, selections) 
{
    var parent = KaimaanJs.getElementById(parentID);
    if(parent)
    {
        while(parent.lastChild)
        {
             parent.removeChild(parent.lastChild);
        }

        parent.appendChild(CheckboxList.CreateCheckboxList(texts, selections));
    }
}
//---------------------------------------------- 
CheckboxList.CreateCheckboxList = function(texts, selections) 
{
    var rows = texts.length;
    var cols = 1;

    var table = CheckboxList.CreateEmptyTable(rows, cols);

    for( var i=0; i<rows; i++)
    {
        cell = table.rows[i].cells[0];
        CheckboxList.AppendCheckbox(cell, i, texts[i], selections[i]);
    }

    return table;
}
//---------------------------------------------- 
CheckboxList.CreateEmptyTable = function(rows, cols, border, width)
{
     var oTable = document.createElement("table");
     if(border)
         oTable.setAttribute("border", border);
     if(width)
         oTable.setAttribute("width", width);

     var oBody = document.createElement("tbody");
     oTable.appendChild(oBody);

     for( var i=0; i<rows; i++)
     {
         oBody.insertRow(i);
         for( var j=0; j<cols; j++)
         {
             oBody.rows[i].insertCell(j);
         }
     }
     return oTable;
}
//---------------------------------------------- 
CheckboxList.AppendCheckbox = function(node, idNum, caption, selected)
{
    var id = 'checkbox_' + idNum;
    var cb  = CheckboxList.GetNewCheckbox(id, caption, selected);
    node.appendChild(cb);

    // checkbox muss erst im dom sein, dann checken
    cb.checked= selected;
    node.appendChild(CheckboxList.GetNewCheckboxLabel(id, caption));
}
//---------------------------------------------- 
CheckboxList.GetNewCheckbox = function(id, caption, selected)
{
    var cb = document.createElement("input");
    cb.setAttribute("id", id );
    cb.setAttribute("type", "checkbox");
    cb.setAttribute("checked", selected);
    return cb;
}
//---------------------------------------------- 
CheckboxList.GetNewCheckboxLabel = function(id, caption)
{
    var label = document.createElement("label");
    label.setAttribute("for", id );
    label.appendChild(document.createTextNode(caption));
    return label;
}
//---------------------------------------------- 
// alle checkboxen oder keine selektieren
CheckboxList.CheckboxListSelect = function(cblID, state) 
{
    var cbl = KaimaanJs.getElementById(cblID);
    if(cbl)
    {
        var items= cbl.getElementsByTagName("input");
        for(var i=0;i<items.length;i++) 
        {
            items[i].checked = state;
        }
    }
        return false; 
}
//---------------------------------------------- 
// alle checkboxen oder keine selektieren
CheckboxList.GetStatesCheckboxList = function(cblID) 
{   
    var result="";
    var cbl = KaimaanJs.getElementById(cblID);
    if(cbl)
    {
        var items= cbl.getElementsByTagName("input");
        for(var i=0;i<items.length;i++) 
        {
            if(i > 0)
                result += ";";

            result += items[i].checked? "true": "false";
        }
    }
    return result; 
}
//---------------------------------------------- 
// in einem ajaxToolkit:TabContainer die checkboxen aus- / abwählen
CheckboxList.TabContainerSelectAll = function(tabContainerID, state)
{
    var tabContainer = $get(tabContainerID); 
    if (tabContainer != undefined && tabContainer != null) 
    { 
         tabContainer = tabContainer.control; 
         var tab = tabContainer.get_activeTab(); 
         if(tab)
         {
              var tabID = tab.get_id();
              CheckboxList.CheckboxListSelect(tabID, state);
         }
    } 
}


//----------------------------------------------------
// detect.js (aus Zakas: professional js for web developers
//----------------------------------------------------
var sUserAgent = navigator.userAgent;
var fAppVersion = parseFloat(navigator.appVersion);

function compareVersions(sVersion1, sVersion2) {

    var aVersion1 = sVersion1.split(".");
    var aVersion2 = sVersion2.split(".");
    
    if (aVersion1.length > aVersion2.length) {
        for (var i=0; i < aVersion1.length - aVersion2.length; i++) {
            aVersion2.push("0");
        }
    } else if (aVersion1.length < aVersion2.length) {
        for (var i=0; i < aVersion2.length - aVersion1.length; i++) {
            aVersion1.push("0");
        }    
    }
    
    for (var i=0; i < aVersion1.length; i++) {
 
        if (aVersion1[i] < aVersion2[i]) {
            return -1;
        } else if (aVersion1[i] > aVersion2[i]) {
            return 1;
        }    
    }
    
    return 0;

}

var isOpera = sUserAgent.indexOf("Opera") > -1;
var isMinOpera4 = isMinOpera5 = isMinOpera6 = isMinOpera7 = isMinOpera7_5 = false;

if (isOpera) {
    var fOperaVersion;
    if(navigator.appName == "Opera") {
        fOperaVersion = fAppVersion;
    } else {
        var reOperaVersion = new RegExp("Opera (\\d+\\.\\d+)");
        reOperaVersion.test(sUserAgent);
        fOperaVersion = parseFloat(RegExp["$1"]);
    }

    isMinOpera4 = fOperaVersion >= 4;
    isMinOpera5 = fOperaVersion >= 5;
    isMinOpera6 = fOperaVersion >= 6;
    isMinOpera7 = fOperaVersion >= 7;
    isMinOpera7_5 = fOperaVersion >= 7.5;
}

var isKHTML = sUserAgent.indexOf("KHTML") > -1 
              || sUserAgent.indexOf("Konqueror") > -1 
              || sUserAgent.indexOf("AppleWebKit") > -1; 
              
var isMinSafari1 = isMinSafari1_2 = false;
var isMinKonq2_2 = isMinKonq3 = isMinKonq3_1 = isMinKonq3_2 = false;

if (isKHTML) {
    isSafari = sUserAgent.indexOf("AppleWebKit") > -1;
    isKonq = sUserAgent.indexOf("Konqueror") > -1;

    if (isSafari) {
        var reAppleWebKit = new RegExp("AppleWebKit\\/(\\d+(?:\\.\\d*)?)");
        reAppleWebKit.test(sUserAgent);
        var fAppleWebKitVersion = parseFloat(RegExp["$1"]);

        isMinSafari1 = fAppleWebKitVersion >= 85;
        isMinSafari1_2 = fAppleWebKitVersion >= 124;
    } else if (isKonq) {

        var reKonq = new RegExp("Konqueror\\/(\\d+(?:\\.\\d+(?:\\.\\d)?)?)");
        reKonq.test(sUserAgent);
        isMinKonq2_2 = compareVersions(RegExp["$1"], "2.2") >= 0;
        isMinKonq3 = compareVersions(RegExp["$1"], "3.0") >= 0;
        isMinKonq3_1 = compareVersions(RegExp["$1"], "3.1") >= 0;
        isMinKonq3_2 = compareVersions(RegExp["$1"], "3.2") >= 0;
    } 
    
}

var isIE = sUserAgent.indexOf("compatible") > -1 
           && sUserAgent.indexOf("MSIE") > -1
           && !isOpera;
           
var isMinIE4 = isMinIE5 = isMinIE5_5 = isMinIE6 = false;

if (isIE) {
    var reIE = new RegExp("MSIE (\\d+\\.\\d+);");
    reIE.test(sUserAgent);
    var fIEVersion = parseFloat(RegExp["$1"]);

    isMinIE4 = fIEVersion >= 4;
    isMinIE5 = fIEVersion >= 5;
    isMinIE5_5 = fIEVersion >= 5.5;
    isMinIE6 = fIEVersion >= 6.0;
}

var isMoz = sUserAgent.indexOf("Gecko") > -1
            && !isKHTML;

var isMinMoz1 = sMinMoz1_4 = isMinMoz1_5 = false;

if (isMoz) {
    var reMoz = new RegExp("rv:(\\d+\\.\\d+(?:\\.\\d+)?)");
    reMoz.test(sUserAgent);
    isMinMoz1 = compareVersions(RegExp["$1"], "1.0") >= 0;
    isMinMoz1_4 = compareVersions(RegExp["$1"], "1.4") >= 0;
    isMinMoz1_5 = compareVersions(RegExp["$1"], "1.5") >= 0;
}

var isNS4 = !isIE && !isOpera && !isMoz && !isKHTML 
            && (sUserAgent.indexOf("Mozilla") == 0) 
            && (navigator.appName == "Netscape") 
            && (fAppVersion >= 4.0 && fAppVersion < 5.0);

var isMinNS4 = isMinNS4_5 = isMinNS4_7 = isMinNS4_8 = false;

if (isNS4) {
    isMinNS4 = true;
    isMinNS4_5 = fAppVersion >= 4.5;
    isMinNS4_7 = fAppVersion >= 4.7;
    isMinNS4_8 = fAppVersion >= 4.8;
}

var isWin = (navigator.platform == "Win32") || (navigator.platform == "Windows");
var isMac = (navigator.platform == "Mac68K") || (navigator.platform == "MacPPC") 
            || (navigator.platform == "Macintosh");

var isUnix = (navigator.platform == "X11") && !isWin && !isMac;

var isWin95 = isWin98 = isWinNT4 = isWin2K = isWinME = isWinXP = false;
var isMac68K = isMacPPC = false;
var isSunOS = isMinSunOS4 = isMinSunOS5 = isMinSunOS5_5 = false;

if (isWin) {
    isWin95 = sUserAgent.indexOf("Win95") > -1 
              || sUserAgent.indexOf("Windows 95") > -1;
    isWin98 = sUserAgent.indexOf("Win98") > -1 
              || sUserAgent.indexOf("Windows 98") > -1;
    isWinME = sUserAgent.indexOf("Win 9x 4.90") > -1 
              || sUserAgent.indexOf("Windows ME") > -1;
    isWin2K = sUserAgent.indexOf("Windows NT 5.0") > -1 
              || sUserAgent.indexOf("Windows 2000") > -1;
    isWinXP = sUserAgent.indexOf("Windows NT 5.1") > -1 
              || sUserAgent.indexOf("Windows XP") > -1;
    isWinNT4 = sUserAgent.indexOf("WinNT") > -1 
              || sUserAgent.indexOf("Windows NT") > -1 
              || sUserAgent.indexOf("WinNT4.0") > -1 
              || sUserAgent.indexOf("Windows NT 4.0") > -1 
              && (!isWinME && !isWin2K && !isWinXP);
} 

if (isMac) {
    isMac68K = sUserAgent.indexOf("Mac_68000") > -1 
               || sUserAgent.indexOf("68K") > -1;
    isMacPPC = sUserAgent.indexOf("Mac_PowerPC") > -1 
               || sUserAgent.indexOf("PPC") > -1;  
}

if (isUnix) {
    isSunOS = sUserAgent.indexOf("SunOS") > -1;

    if (isSunOS) {
        var reSunOS = new RegExp("SunOS (\\d+\\.\\d+(?:\\.\\d+)?)");
        reSunOS.test(sUserAgent);
        isMinSunOS4 = compareVersions(RegExp["$1"], "4.0") >= 0;
        isMinSunOS5 = compareVersions(RegExp["$1"], "5.0") >= 0;
        isMinSunOS5_5 = compareVersions(RegExp["$1"], "5.5") >= 0;
    }
}
//----------------------------------------------------
//----------------------------------------------------
// eventutils.js (aus Zakas: professional js for web developers
//----------------------------------------------------
var EventUtil = new Object;
EventUtil.addEventHandler = function (oTarget, sEventType, fnHandler) {
    if (oTarget.addEventListener) {
        oTarget.addEventListener(sEventType, fnHandler, false);
    } else if (oTarget.attachEvent) {
        oTarget.attachEvent("on" + sEventType, fnHandler);
    } else {
        oTarget["on" + sEventType] = fnHandler;
    }
};
        
EventUtil.removeEventHandler = function (oTarget, sEventType, fnHandler) {
    if (oTarget.removeEventListener) {
        oTarget.removeEventListener(sEventType, fnHandler, false);
    } else if (oTarget.detachEvent) {
        oTarget.detachEvent("on" + sEventType, fnHandler);
    } else { 
        oTarget["on" + sEventType] = null;
    }
};

EventUtil.formatEvent = function (oEvent) {
    if (isIE && isWin) {
        oEvent.charCode = (oEvent.type == "keypress") ? oEvent.keyCode : 0;
        oEvent.eventPhase = 2;
        oEvent.isChar = (oEvent.charCode > 0);
        oEvent.pageX = oEvent.clientX + document.body.scrollLeft;
        oEvent.pageY = oEvent.clientY + document.body.scrollTop;
        oEvent.preventDefault = function () {
            this.returnValue = false;
        };

        if (oEvent.type == "mouseout") {
            oEvent.relatedTarget = oEvent.toElement;
        } else if (oEvent.type == "mouseover") {
            oEvent.relatedTarget = oEvent.fromElement;
        }

        oEvent.stopPropagation = function () {
            this.cancelBubble = true;
        };

        oEvent.target = oEvent.srcElement;
        oEvent.time = (new Date).getTime();
    }
    return oEvent;
};

EventUtil.getEvent = function() {
    if (window.event) {
        return this.formatEvent(window.event);
    } else {
        return EventUtil.getEvent.caller.arguments[0];
    }
};
//----------------------------------------------
// listutil.js (aus zakas: prof. js. for dev.)
//----------------------------------------------
var ListUtil = new Object();

ListUtil.getSelectedIndexes = function (oListbox) {
    var arrIndexes = new Array;

    for (var i=0; i < oListbox.options.length; i++) {
        if (oListbox.options[i].selected) {
            arrIndexes.push(i);
        }
    }

    return arrIndexes;
};

ListUtil.add = function (oListbox, sName, sValue) {

    var oOption = document.createElement("option");
    oOption.appendChild(document.createTextNode(sName));

    if (arguments.length == 3) {
        oOption.setAttribute("value", sValue);
    }

    oListbox.appendChild(oOption);

}

ListUtil.remove = function (oListbox, iIndex) {
    oListbox.remove(iIndex);
};

ListUtil.clear = function (oListbox) {
    for (var i=oListbox.options.length-1; i >= 0; i--) {
        ListUtil.remove(oListbox, i);
    }
};

ListUtil.move = function (oListboxFrom, oListboxTo, iIndex) {
    var oOption = oListboxFrom.options[iIndex];

    if (oOption != null) {
        oListboxTo.appendChild(oOption);
    }
};

ListUtil.shiftUp = function (oListbox, iIndex) {
    if (iIndex > 0) {    
        var oOption = oListbox.options[iIndex];
        var oPrevOption = oListbox.options[iIndex-1];
        oListbox.insertBefore(oOption, oPrevOption);
    }    
};

ListUtil.shiftDown = function (oListbox, iIndex) {
    if (iIndex < oListbox.options.length - 1) {
        var oOption = oListbox.options[iIndex];
        var oNextOption = oListbox.options[iIndex+1];
        oListbox.insertBefore(oNextOption, oOption);
    }
};
//----------------------------------------------
// von kaimaan software gmbh, 2008
ListUtil.selectText = function(oListbox, text)
{ 
    var index = -1;
    for (var i=0; i < oListbox.options.length; i++) 
    {
        if (oListbox.options[i].text == text) 
        {
            index = i;
            break;
        }
    }
    if(index > -1)
    oListbox.options[index].selected = true;

    return index > -1;
}

//----------------------------------------------
// ende: listutil.js
//----------------------------------------------



//----------------------------------------------------
// modalpopupbv.js (buildingvalue)
//----------------------------------------------------
var ModalPopupBV= new Object();

// parameter, die vom server gesetzt werden
ModalPopupBV.webRequestPage='';
ModalPopupBV.outOfBandRequestID='';

ModalPopupBV.ModalPopupExtender1='';
ModalPopupBV.hiddenFieldResult='';

ModalPopupBV.ClientDataSeparator1='';
ModalPopupBV.ClientDataSeparator2='';

ModalPopupBV.tbVorgabewertID='';
ModalPopupBV.rbAktuellerWert='';
ModalPopupBV.rbWert1914='';

ModalPopupBV.key_gbwert='';
ModalPopupBV.key_gbwerttyp='';

ModalPopupBV.typ_wert1914='';
ModalPopupBV.typ_aktuellerwert='';
//----------------------------------------------------
ModalPopupBV.ShowModalPopup = function(callerID) 
{ 
   // async-postback um die daten zum vorbesetzen zu holen  
   ModalPopupBV.getWebRequest(callerID);

   return true;
}
//----------------------------------------------
ModalPopupBV.getWebRequest = function(arg)
{
    var wRequest = new Sys.Net.WebRequest();

    wRequest.set_httpVerb("GET");
    var query = "?isOutOfBandRequest=true&outOfBandRequestID=" + ModalPopupBV.outOfBandRequestID + "&outOfBandParameter=" + arg;
    query = KaimaanJs.addGuidArgument(query);
    wRequest.set_url(ModalPopupBV.webRequestPage + query);

    wRequest.add_completed(ModalPopupBV.receiveServerData);

    wRequest.invoke();              
 }
//----------------------------------------------------
// asyn-callback-func: das popup mit daten vorbesetzen und anzeigen
ModalPopupBV.receiveServerData = function (executor, eventArgs)
{ 
   if (executor.get_responseAvailable()) 
    {
        var result = executor.get_responseData();

        if(typeof(result) != 'string')
            return;

        ModalPopupBV.initInputsBuildingValue(result);

        var modal = $find(ModalPopupBV.ModalPopupExtender1); 
        modal.show(); 
    }
    else
        KaimaanJs.showWebRequestError(executor);

    return true;
} 
//----------------------------------------------------
ModalPopupBV.HideModalPopup = function() 
{ 
    var modal = $find(ModalPopupBV.ModalPopupExtender1); 
    modal.hide(); 
}
//----------------------------------------------------
ModalPopupBV.initInputsBuildingValue = function(result)
{
    var items = result.split(ModalPopupBV.ClientDataSeparator1);

    for( var i=0; i<items.length; i++)
    {
        var item = items[i];
        var keyvalue = item.split(ModalPopupBV.ClientDataSeparator2);
        var key = keyvalue[0];
        var value = keyvalue[1];

        if( key==ModalPopupBV.key_gbwert)
        {
            KaimaanJs.setText(ModalPopupBV.tbVorgabewertID, value);
        }
        else if(key==ModalPopupBV.key_gbwerttyp)
        {
            var e = null;
            if(value == ModalPopupBV.typ_aktuellerwert)
                e = KaimaanJs.getElementById(ModalPopupBV.rbAktuellerWert);
            else if(value == ModalPopupBV.typ_wert1914)
                e = KaimaanJs.getElementById(ModalPopupBV.rbWert1914);

            if(e)
                e.checked=true;
        }
    }
}
//----------------------------------------------------
ModalPopupBV.OnError = function(result) 
{ 
    alert('Fehler beim Callback von ModalPopupBV.receiveServerData: ' +result);
    return true;
} 
//----------------------------------------------------
ModalPopupBV.OnClientClickModalPopupOk = function(sender, e) 
{ 
    var result = ModalPopupBV.key_gbwert;
    result += ModalPopupBV.ClientDataSeparator2;
    var e = KaimaanJs.getElementById(ModalPopupBV.tbVorgabewertID);
    if(e)
         result +=e.value;

    result += ModalPopupBV.ClientDataSeparator1;

    result += ModalPopupBV.key_gbwerttyp;
    result += ModalPopupBV.ClientDataSeparator2;
    e = KaimaanJs.getElementById(ModalPopupBV.rbAktuellerWert);
    if(e)
    {
         if(e.checked)
             result += ModalPopupBV.typ_aktuellerwert;
    }

    e = KaimaanJs.getElementById(ModalPopupBV.rbWert1914);
    if(e)
    {
         if(e.checked)
             result += ModalPopupBV.typ_wert1914;
    }

    // result wird nicht übergeben, deshalb ein hiddenfield.
    var hf = KaimaanJs.getElementById(ModalPopupBV.hiddenFieldResult); 
    if(hf)
         hf.value = result;

    __doPostBack(sender, result); 
}
//----------------------------------------------------
//----------------------------------------------
// modales popups zum anzeigen von infos
//----------------------------------------------
var ModalPopupInfo = new Object();

// parameter, die vom server gesetzt werden
ModalPopupInfo.outOfBandRequestID='';
ModalPopupInfo.webRequestPage='';

ModalPopupInfo.lblModalPopupTitle='';
ModalPopupInfo.lblModalPopupContent='';

ModalPopupInfo.ModalPopupExtender1='';
ModalPopupInfo.pnlModalPopupContent11='';

ModalPopupInfo.hiddenFieldCallerID='';

ModalPopupInfo.ClientDataSeparator1='';
//----------------------------------------------
ModalPopupInfo.ShowModalPopup = function (callerID)
{ 
    // async-server-request
    var context = '';

    // callerID merken
    var hf = KaimaanJs.getElementById(ModalPopupInfo.hiddenFieldCallerID); 
    if(hf)
         hf.value = callerID;
   
    // async-postback um die daten zum vorbesetzen zu holen  
    ModalPopupInfo.getWebRequest(callerID);

    return true;
}
//----------------------------------------------
ModalPopupInfo.getWebRequest = function(arg)
{
    var wRequest = new Sys.Net.WebRequest();

    wRequest.set_httpVerb("GET");
    var query = "?isOutOfBandRequest=true&outOfBandRequestID=" + ModalPopupInfo.outOfBandRequestID + "&outOfBandParameter=" + arg;
    query = KaimaanJs.addGuidArgument(query);
    wRequest.set_url(ModalPopupInfo.webRequestPage + query);

    wRequest.add_completed(ModalPopupInfo.receiveServerData);

    wRequest.invoke();              
 }
//----------------------------------------------------
// asyn-callback-func: das popup mit daten vorbesetzen und anzeigen
ModalPopupInfo.receiveServerData = function (executor, eventArgs)
{ 
   if (executor.get_responseAvailable()) 
    {
        var result = executor.get_responseData();

        if(typeof(result) != 'string')
            return;

        ModalPopupInfo.initInputs(result);

        var modal = $find(ModalPopupInfo.ModalPopupExtender1); 
        modal.show(); 
    }
    else
        KaimaanJs.showWebRequestError(executor);

    return true;
} 
//----------------------------------------------------
ModalPopupInfo.initInputs = function (result)
{
    // beispiel: result = 'popupTitel|text

    var items = result.split(ModalPopupInfo.ClientDataSeparator1);

    var title = items[0];
    KaimaanJs.setText(ModalPopupInfo.lblModalPopupTitle, title);

    if(items.length >1)
    {
        KaimaanJs.setText(ModalPopupInfo.lblModalPopupContent, items[1]);
    }
}
//----------------------------------------------------
ModalPopupInfo.OnError = function (result) 
{ 
    alert('Fehler beim Callback von ModalPopupInfo.receiveServerData: ' +result);
    return true;
} 
//----------------------------------------------------

//----------------------------------------------
// modalpopup.js
// modale popups
//----------------------------------------------
var ModalPopupMS = new Object();

ModalPopupMS.enableDebug=false;
//----------------------------------------------------
ModalPopupMS.traceIt= function(text)
{
    if(ModalPopupMS.enableDebug)
        KaimaanJs.traceIt("ModalPopupMS:" + text);
}
//----------------------------------------------------
ModalPopupMS.traceIt("es werden die parameter gelöscht...");
// parameter, die vom server gesetzt werden
ModalPopupMS.outOfBandRequestID='';
ModalPopupMS.webRequestPage='';

ModalPopupMS.lblModalPopupTitle='';

ModalPopupMS.ModalPopupExtender1='';
ModalPopupMS.pnlModalPopupContent11='';

ModalPopupMS.hiddenFieldCallerID='';
ModalPopupMS.hiddenFieldResult='';

ModalPopupMS.ClientDataSeparator1='';
ModalPopupMS.ClientDataSeparator2='';
//----------------------------------------------
ModalPopupMS.ShowModalPopup = function (callerID)
{ 
   ModalPopupMS.traceIt("ShowModalPopup: ModalPopupMS.hiddenFieldCallerID=" + ModalPopupMS.hiddenFieldCallerID);

   // async-server-request
   var context = '';

    // callerID merken
    var hf = KaimaanJs.getElementById(ModalPopupMS.hiddenFieldCallerID); 
    if(hf)
         hf.value = callerID;
   
   // async-postback um die daten zum vorbesetzen zu holen  
   ModalPopupMS.getWebRequest(callerID);

   return true;
}
//----------------------------------------------
ModalPopupMS.getWebRequest = function(arg)
{
    var wRequest = new Sys.Net.WebRequest();

    wRequest.set_httpVerb("GET");

    var query = "?isOutOfBandRequest=true&outOfBandRequestID=" + ModalPopupMS.outOfBandRequestID + "&outOfBandParameter=" + arg;
    query = KaimaanJs.addGuidArgument(query);
    var url = ModalPopupMS.webRequestPage + query;

    ModalPopupMS.traceIt("getWebRequest: url=" + url);

    wRequest.set_url(url);

    //wRequest.set_userContext("user's context");
    wRequest.add_completed(ModalPopupMS.receiveServerData);

    wRequest.invoke();              
 }
//----------------------------------------------------
// asyn-callback-func: das popup mit daten vorbesetzen und anzeigen
ModalPopupMS.receiveServerData = function (executor, eventArgs)
{ 
    ModalPopupMS.traceIt("receiveServerData: Status=" + executor.get_statusCode() + " " + executor.get_statusText());

   if (executor.get_responseAvailable()) 
    {
        var result = executor.get_responseData();

        if(typeof(result) != 'string')
        {
            ModalPopupMS.traceIt("receiveServerData: typeof(result) != 'string'");
            return;
        }
        ModalPopupMS.initInputs(result);

        var modal = $find(ModalPopupMS.ModalPopupExtender1); 
        modal.show(); 
    }
    else
        KaimaanJs.showWebRequestError(executor);

    return true;
} 
//----------------------------------------------------
ModalPopupMS.initInputs = function (result)
{
    // beispiel: result = 'popupTitel|eins~true|zwei~false|drei~false';

    ModalPopupMS.traceIt("initInputs: result=" + result);

    var items = result.split(ModalPopupMS.ClientDataSeparator1);

    var title = items[0];
    KaimaanJs.setText(ModalPopupMS.lblModalPopupTitle, title); 

    var texts= new Array();
    var selections= new Array();

    for( var i=1; i<items.length; i++)
    {
        var ix = i-1;

        var item = items[i];
        var subitems = item.split(ModalPopupMS.ClientDataSeparator2);
        texts[ix] = subitems[0];
        selections[ix] = subitems[1] == 'true'? true: false;
    }

    ModalPopupMS.traceIt("initInputs: selections=" + selections);
    CheckboxList.AppendCheckboxList(ModalPopupMS.pnlModalPopupContent11, texts, selections);
}
//----------------------------------------------------
ModalPopupMS.OnError = function (result) 
{ 
    ModalPopupMS.traceIt("OnError: result=" + result);
    alert('Fehler beim Callback von ModalPopupMS.receiveServerData: ' +result);

    return true;
} 
//----------------------------------------------------
ModalPopupMS.OnClientClickModalPopupOk = function (sender, e) 
{ 
    ModalPopupMS.traceIt("OnClientClickModalPopupOk");

    var sSelections = CheckboxList.GetStatesCheckboxList(ModalPopupMS.pnlModalPopupContent11);

    var hf = KaimaanJs.getElementById(ModalPopupMS.hiddenFieldResult); 
    if(hf)
         hf.value = sSelections;

   // sender ist btnModalPopupOk: hier wird OnClick auf dem server aufgerufen
    __doPostBack(sender, sSelections); 
}
//----------------------------------------------

//----------------------------------------------------
// ein modales Popup vom server aufrufen, um eine Nachricht anzuzeigen
ModalPopupServer = new Object();

//----------------------------------------------------
ModalPopupServer.enableDebug=false;
ModalPopupServer.traceIt= function(text)
{
    if(ModalPopupServer.enableDebug)
        KaimaanJs.traceIt("ModalPopupServer:" + text);
}
//----------------------------------------------------
// die folgenden parameter müssen vom server aus per startscript gesetzt werden
ModalPopupServer.popupPanelId='';
ModalPopupServer.lblWindowTitleId='';
ModalPopupServer.lblTitleId='';
ModalPopupServer.lblTextId='';

ModalPopupServer.extenderId='';

ModalPopupServer.title='';
ModalPopupServer.text='';

ModalPopupServer.pnlHyperLinkId='';
ModalPopupServer.hyperLinkId='';
ModalPopupServer.hyperLinkHref='';
ModalPopupServer.hyperLinkText='';
//----------------------------------------------------
ModalPopupServer.show= function()
{
    ModalPopupServer.traceIt("show");

    KaimaanJs.setText(ModalPopupServer.lblWindowTitleId, ModalPopupServer.windowTitle);
    KaimaanJs.setText(ModalPopupServer.lblTitleId, ModalPopupServer.title);
    KaimaanJs.setText(ModalPopupServer.lblTextId, ModalPopupServer.text);

    // link einblenden
    if(ModalPopupServer.hyperLinkText.length > 0)
    {
        KaimaanJs.setText(ModalPopupServer.hyperLinkId, ModalPopupServer.hyperLinkText);
        var node = KaimaanJs.getElementById(ModalPopupServer.hyperLinkId);
        if(node)
            node.href = ModalPopupServer.hyperLinkHref;
    }
    KaimaanJs.displayNode(ModalPopupServer.pnlHyperLinkId, ModalPopupServer.hyperLinkText.length > 0);

   // anzeigen
   // das popup wird oben im fenster angezeigt, deshalb
   KaimaanJs.resetScrollY();

    var mpe = $find(ModalPopupServer.extenderId);
        if(mpe)
            mpe.show();

    Sys.Application.remove_load(ModalPopupServer.show);
}
//----------------------------------------------------
ModalPopupServer.OnClientClickClose = function (sender, e) 
{ 
    ModalPopupServer.traceIt("OnClientClickClose");

    // den panel entfernen, da er sonst bei einem postback kurz angezeigt wird
    setTimeout(ModalPopupServer.removePanel, 1500);
}
//----------------------------------------------------
ModalPopupServer.removePanel = function () 
{ 
    ModalPopupServer.traceIt("removePanel");

    KaimaanJs.removeNode(ModalPopupServer.popupPanelId);
}
//----------------------------------------------
   //---------------------------------------------- 
   // js-modul: nsp.js  (no second postback)
   //---------------------------------------------- 

   // es soll ein 2. submit verhindert werden, solang noch der erste submit bearbeitet wird:
   // - das window (nsp_divProtectorID) wird verdunkelt
   // - ein wait-cursor wird angezeigt
   // kaimaan software gmbh, hamburg 2008/03

   //---------------------------------------------- 
   // aufrufe auf dem server: nachdem die page-controls geladen wurden, muss folgendes aufgerufen werden
   //   Sys.Application.add_init(nsp_doOnInit);
   //   Sys.Application.add_load(nsp_doOnLoad);
   //   Sys.Application.add_unload(nsp_doOnUnload);

   //---------------------------------------------- 
   window.nsp_enableDebug=false;

    function nsp_traceIt(text)
    {
        if(window.nsp_enableDebug)
            KaimaanJs.traceIt(text);
    }
   //---------------------------------------------- 

   window.nsp_divProtectorID = 'nsp_divProtector';
   window.nsp_formID = 'form1';

   window.nsp_isSecondPostbackDisabled = false;

   //---------------------------------------------- 
   function nsp_doOnInit()
   {
       nsp_traceIt('nsp_OnInit:--------------------------------------------');
   }
   //---------------------------------------------- 
   function nsp_doOnUnload()
   {
       nsp_traceIt('nsp_OnUnload:------------------------------------------');
   }
   //---------------------------------------------- 
   function nsp_doOnLoad()
   {
       nsp_traceIt('nsp_OnWindowLoad');

       nsp_replace__doPostBack();
       nsp_replaceWebForm_OnSubmit();

       nsp_addEventHandlers();
   }
   //---------------------------------------------- 
    // __doPostBack ersetzen, um das window zu disablen
    function nsp_replace__doPostBack()
    {
        nsp_traceIt('nsp_replace__doPostBack: replaced');
        window.nsp__doPostBackOriginal = __doPostBack;
        __doPostBack = nsp__doPostBack;
    }   

   // ersatz ruft die original-funktion auf und sperrt evtl. das window
   function nsp__doPostBack(eventTarget, eventArgument) 
   {
      nsp_traceIt('nsp__doPostBack');
      if(!window.nsp_isSecondPostbackDisabled)
      {
         var ok = window.nsp__doPostBackOriginal(eventTarget, eventArgument);
         nsp_traceIt('nsp__doPostBack: nsp__doPostBackOriginal returned=' + ok);
         nsp_disableSecondSubmit(true);
      }
   }
   //---------------------------------------------- 
   // WebForm_OnSubmit ersetzen
   // WebForm_OnSubmit wird aufgerufen, wenn ein Validator vorhanden ist.
   // es gibt das Validator-Ergebnis zurück. wenn false, dann kein submit:
   // <form name="form1" ... onsubmit="javascript:return WebForm_OnSubmit();">

   function nsp_replaceWebForm_OnSubmit()
   {    
       nsp_traceIt('nsp_replaceWebForm_OnSubmit');
       if(window.WebForm_OnSubmit)
       {
           nsp_traceIt('nsp_replaceWebForm_OnSubmit: replaced');
           nsp_WebForm_OnSubmitOriginal = window.WebForm_OnSubmit;
           WebForm_OnSubmit = nsp_WebForm_OnSubmit;
       }
   }

   // ersatzaufruf
   function nsp_WebForm_OnSubmit()
   {
       nsp_traceIt('nsp_WebForm_OnSubmit');
       var rc=false;
      if(!window.nsp_isSecondPostbackDisabled)
      {
          if(window.nsp_WebForm_OnSubmitOriginal)
          {
              rc = nsp_WebForm_OnSubmitOriginal();
              if(rc)
                  nsp_disableSecondSubmit(true);
          }
      }
      return rc;
   }
   //---------------------------------------------- 
   function nsp_addEventHandlers()
   {
       nsp_traceIt('nsp_addEventHandlers()');
     
       var dp = KaimaanJs.getElementById(window.nsp_divProtectorID);
       if(dp)
       {     
           $addHandler(dp, 'click', nsp_protectorClicked);
           nsp_traceIt('nsp_addEventHandlers(): addHandler');
       }
       Sys.Application.add_unload(nsp_removeEventHandlers);
   }

   function nsp_removeEventHandlers()
   {
       nsp_traceIt('nsp_removeEventHandlers');
     
       var dp = KaimaanJs.getElementById(window.nsp_divProtectorID);
       if(dp)
           $removeHandler(dp, 'click', nsp_protectorClicked);
   }
   //---------------------------------------------- 
   // weitere submits verhindern
   function nsp_disableSecondSubmit(disabled)
   {
       nsp_traceIt('nsp_disableSecondSubmit');
       var d = KaimaanJs.getElementById(window.nsp_divProtectorID);
       if(d)
       {
           if(disabled==true)
           {
               nsp_setWaitCursor();
               d.className= "nsp_protector_disabled";
           }
           else
           {
               d.className= "nsp_protector_enabled";
           }
           window.nsp_isSecondPostbackDisabled = disabled;
           nsp_traceIt('nsp_disableSecondSubmit: set ' + disabled);
       }
   }

   //---------------------------------------------- 
   // kein mouse-click zulassen
    function nsp_protectorClicked(evt)
    {
        nsp_traceIt('nsp_protectorClicked');
        if(window.nsp_isSecondPostbackDisabled)
        {
            evt.stopPropagation();
            evt.preventDefault();
            nsp_traceIt('nsp_protectorClicked: event.stopPropagation()');
        }
    }
   //---------------------------------------------- 
   function nsp_setWaitCursor() 
   {
       var tags = ['input','div','html', 'a', 'button'];

       for(var i=0; i < tags.length; i++) 
       {
           var elements = document.getElementsByTagName(tags[i]);
           for(var j=0; j < elements.length; j++) 
           {                                          
               var element = elements[j];
               // nsp_traceIt(element); 
               if(element.style)
                   if(typeof element.style.cursor == 'string')
                       element.style.cursor='wait';
           }
       } 
   }
   //---------------------------------------------- 
//----------------------------------------------
// kaimaan software gmbh, hamburg 2008
// plztownlist.js
// eingabe der plz (textbox) und des ortes (select-list)
//----------------------------------------------
var PlzTownList = new Object();

//----------------------------------------------
PlzTownList.enableDebug=false;

PlzTownList.traceIt= function(text)
{
    if(PlzTownList.enableDebug)
        KaimaanJs.traceIt("PlzTownList:" + text);
}
//----------------------------------------------
PlzTownList.tbPlzId='';
PlzTownList.lbTownListId='';
PlzTownList.hfTownId='';
PlzTownList.webRequestPage='';
PlzTownList.outOfBandRequestID='';

PlzTownList.timeoutID = 0;
PlzTownList.timeoutInMilliSeconds = 1000;

// aufruf auf dem server:
// Sys.Application.add_load(PlzTownList.onLoad);
//----------------------------------------------
PlzTownList.onLoad = function()
{
     PlzTownList.refreshTownList();
}

//----------------------------------------------
PlzTownList.onKeydownPlz = function()
{
    PlzTownList.traceIt("onKeydownPlz");

    // Clear any delays
    if (PlzTownList.timeoutID)
    {
        window.clearTimeout(PlzTownList.timeoutID);
    }
    // Executes a code snippet or a function after specified delay
    PlzTownList.timeoutID = window.setTimeout(PlzTownList.refreshTownList, PlzTownList.timeoutInMilliSeconds);            
}
//----------------------------------------------
PlzTownList.refreshTownList = function(plz)
{
    PlzTownList.traceIt("refreshTownList: plz" + plz);

    if(!plz || plz <= 0)
    {
        plz = PlzTownList.getPlzInput();
    }

    if(plz)
        PlzTownList.getWebRequest(plz);
    else
        PlzTownList.resetListValues();
}
//----------------------------------------------
PlzTownList.getWebRequest = function(plz)
{
    PlzTownList.traceIt("sendWebRequest: plz=" + plz);

    var waitList = ["","Bitte warten..."];
    PlzTownList.insertListValues(waitList);

    var wRequest = new Sys.Net.WebRequest();

    wRequest.set_httpVerb("GET");
    // wRequest.set_userContext("user's context");

    var query = "?isOutOfBandRequest=true&outOfBandRequestID=" + PlzTownList.outOfBandRequestID + "&outOfBandParameter=" + plz;
    query = KaimaanJs.addGuidArgument(query);
    var rawUrl = PlzTownList.webRequestPage + query;
    wRequest.set_url(rawUrl); //PlzTownList.traceIt("sendWebRequest: resolvedUrl=" + wRequest.getResolvedUrl() );

    wRequest.add_completed(PlzTownList.receiveServerData);

    wRequest.invoke();              
 }
//----------------------------------------------
PlzTownList.receiveServerData = function(executor, eventArgs)
{
   PlzTownList.traceIt("receiveServerData");

   if(executor.get_responseAvailable()) 
   {
       PlzTownList.traceExecutor(executor);

       var results = executor.get_responseData();
       var values; 
       if(typeof(results) == 'string')
            values = results.split("|");  
       else
            values = results;

       PlzTownList.insertListValues(values);

       var plz = PlzTownList.getPlzInput();

       // wenn die plz und der ort eindeutig sind, dann den ort sichern
       if(values instanceof Array)
       {
           if(values.length == 2)
           {
                var valPlz = values[0];
                if(valPlz.length == 5)
                     if(parseInt(valPlz, 10) != NaN)
                          PlzTownList.saveTown(values[1]);
           }
       }

       // wenn möglich, den gespeicherten ort wieder in der liste auswählen
       var town = PlzTownList.readSavedTown();
       if(town)
       {
           var lb = KaimaanJs.getElementById(PlzTownList.lbTownListId);
           if(lb)
           {
               var isInList = ListUtil.selectText(lb, town);
               var plz = PlzTownList.getPlzInput();
               if( isInList==false || plz.length!=5 )
               {
                   lb.options[0].selected = true;
                   PlzTownList.saveTown('');
               }
           }
       }
   }
   else
   {
        KaimaanJs.showWebRequestError(executor);
   }
    return true;    
}
//----------------------------------------------
PlzTownList.clearTownList = function()
{
    PlzTownList.traceIt("clearTownList");

    var lb = KaimaanJs.getElementById(PlzTownList.lbTownListId);
    if(lb)
        ListUtil.clear(lb);
}
//----------------------------------------------
PlzTownList.insertListValues = function(values)
{
    PlzTownList.traceIt("insertListValues: values=" + values);

    var lb = KaimaanJs.getElementById(PlzTownList.lbTownListId);
    if(lb)
    {
        PlzTownList.clearTownList();        

        for(var i=0; i+1 < values.length; i+=2)
        {
            var sValue = values[i];
            var sName = values[i+1];
            ListUtil.add(lb, sName, sValue);
        }
    }
}
//----------------------------------------------
PlzTownList.resetListValues = function()
{
    PlzTownList.traceIt("resetListValues");

    var values = ["","PLZ eingeben"];
    PlzTownList.insertListValues(values);
}
//----------------------------------------------
PlzTownList.onChangeTownList = function()
{
    PlzTownList.traceIt("onChangeTownList");

    var lb = KaimaanJs.getElementById(PlzTownList.lbTownListId);
    if(lb)
    {
        var town = lb.options[lb.selectedIndex].text;
        PlzTownList.saveTown(town);

        var plz = lb.value;
        PlzTownList.setPlzInput(plz);
        PlzTownList.refreshTownList(plz);
    }
} 
//----------------------------------------------
PlzTownList.getPlzInput=function()
{
   var result = '';
   var tb = KaimaanJs.getElementById(PlzTownList.tbPlzId);
   if(tb)
       result = tb.value;
   return result;
}
//----------------------------------------------
PlzTownList.setPlzInput=function(value)
{
   var tb = KaimaanJs.getElementById(PlzTownList.tbPlzId);
   if(tb)
       tb.value = value;
    else
        PlzTownList.traceIt("setPlzInput: Fehler: textbox nicht gefunden");
}
//----------------------------------------------
PlzTownList.saveTown = function(town)
{
    PlzTownList.traceIt("saveTown: town=" + town);

    var hf = KaimaanJs.getElementById(PlzTownList.hfTownId);
    if(hf)
    {
        hf.value = town;
        PlzTownList.traceIt("saveTown: in hiddenField:" + town );
    }
    else
        PlzTownList.traceIt("saveTown: Fehler: hfTown nicht gefunden");
}
//----------------------------------------------
PlzTownList.readSavedTown = function()
{
    PlzTownList.traceIt("readSavedTown");

    var result = '';
    var hf = KaimaanJs.getElementById(PlzTownList.hfTownId);
    if(hf)
        result = hf.value;
    else
        PlzTownList.traceIt("readSavedTown: Fehler: hfTown nicht gefunden");
    return result;
}
//----------------------------------------------
PlzTownList.methodFailed = function(results, context, methodName)
{
    PlzTownList.traceIt("methodFailed");

    alert(String.format("Fehler bei Aufruf von Methode '{0}'. Ursache: \r\n '{1}'", methodName, results.get_message()));
}
//----------------------------------------------
PlzTownList.traceExecutor = function(executor)
{
    //if(!PlzTownList.enableDebug)
       return;

    var infos='';
    infos += "Status: [" + executor.get_statusCode() + " " + executor.get_statusText() + "]";
    infos += "Headers: " + executor.getAllResponseHeaders();
    infos += "Body:" +     executor.get_responseData();

    PlzTownList.traceIt("traceExecutor: " + infos);
}
//----------------------------------------------
// ende: plztownlist.js
//----------------------------------------------



//----------------------------------------------------
// sessionduration.js 
// kaimaan software gmbH 
//----------------------------------------------------
var SessionDuration= new Object();

// parameter, die vom server gesetzt werden
SessionDuration.webRequestPage='../SessionDuration.aspx';
SessionDuration.labelID='';
SessionDuration.panelInfosID='';
SessionDuration.holdSessionSignal='';
SessionDuration.abandonSignal='';
SessionDuration.responsePrefix='';

//--------------------------------------------
SessionDuration.intervalID = 0;
SessionDuration.intervalSeconds=300;
SessionDuration.intervalProlong=8;
SessionDuration.intervalAbandon=12;

SessionDuration.enableTest=false;

SessionDuration.callCounter=0;

//--------------------------------------------
// timer beim laden der seite setzen
 SessionDuration.setInterval= function()
{
   SessionDuration.callCounter=0;
   SessionDuration.showDurationInfo();

   if(SessionDuration.intervalID > 0)
      clearInterval(SessionDuration.intervalID);    

   SessionDuration.intervalID = window.setInterval('SessionDuration.manageInterval();', SessionDuration.intervalSeconds*1000);
}

Sys.Application.add_load(SessionDuration.setInterval);

//--------------------------------------------
// funktion wird vom timer aufgerufen
SessionDuration.manageInterval = function()
{
   SessionDuration.callCounter+=1;

   if(SessionDuration.callCounter >= SessionDuration.intervalProlong)
      SessionDuration.showProlongDialog();
   else
      if(SessionDuration.callCounter >= SessionDuration.intervalAbandon)
           SessionDuration.abandon();
      else  
           SessionDuration.holdSession();

   SessionDuration.showDurationInfo();
}

//--------------------------------------------
SessionDuration.showDurationInfo=function()
{
   var tillAbandon = (SessionDuration.intervalAbandon - SessionDuration.callCounter) * SessionDuration.intervalSeconds / 60;
   KaimaanJs.setText(SessionDuration.labelID, '[' + tillAbandon + ' min]');
}

//--------------------------------------------
// webRequest zum halten der session aufrufen, verlängert sessionTimerout
SessionDuration.holdSession=function()
{
   SessionDuration.traceIt('holdSession');
   SessionDuration.sendWebRequest(SessionDuration.holdSessionSignal);
}

//----------------------------------------------
// ruft eine Seite auf der Website auf, um den sessionTimeOut zu verlägern.
// wenn die aufgerufene seite nicht entsprechend antwortet (wegen sessionTimeout), dann wird der timer gelöscht
SessionDuration.sendWebRequest = function(arg)
{
    var wRequest = new Sys.Net.WebRequest();

    wRequest.set_httpVerb("GET");

    var now = new Date();
    var no_cache = "?no_cache=" +  now.toLocaleTimeString();
    var url = SessionDuration.webRequestPage + no_cache; 
    wRequest.set_url(url);

    wRequest.add_completed(SessionDuration.receiveServerData);

    SessionDuration.traceIt('sendWebRequest vor invoke: url=' + url);
    wRequest.invoke();              
 }

//--------------------------------------------
SessionDuration.receiveServerData = function (executor, eventArgs)
{ 
   if(executor.get_responseAvailable()) 
   {
       var result = executor.get_responseData();
       SessionDuration.traceIt('receiveServerData: result=' + result + ', eventArgs='+ eventArgs);

       if(result.indexOf(SessionDuration.responsePrefix)!== 0)
       {
          SessionDuration.traceIt('receiveServerData: falscher response-prefix; deshalb keine weiteren requests senden.');
          clearInterval(SessionDuration.intervalID); 
          KaimaanJs.setText(SessionDuration.labelID, '[Sitzung abgelaufen]');
       }
   }
   else
   {
       KaimaanJs.showWebRequestError(executor);
   }
}

//--------------------------------------------
SessionDuration.showProlongDialog = function()
{
   SessionDuration.traceIt('showProlongDialog()');
   KaimaanJs.setInnerHTML(SessionDuration.panelInfosID, SessionDuration.htmlProlongDialog());
}

//--------------------------------------------
SessionDuration.htmlProlongDialog=function()
{
    var t;
t ='<div id="sd_pnlProlongSession" class="sd_pnlProlongSession">';
t +='    Hinweis: Wegen langer Inaktivität läuft die Sitzungszeit vom tariffinder-Programm in Kürze ab. Soll die Sitzungzeit verlängert werden?<br />';
t +='    <br />';
t +='    <input id="sd_btnProlongSession" onclick="SessionDuration.doProlong();" type="button"';
t +='        value="Sitzung verlängern" class="sd_button" />';
t +='    <input id="sd_btnEndSession" onclick="SessionDuration.doNotProlong();" type="button" value="Sitzung beenden" class="sd_button" /><br />';
t +='</div>';
    return t;
}

//--------------------------------------------
SessionDuration.doProlong= function()
{
   SessionDuration.traceIt('doProlong');

   SessionDuration.setInterval();
   KaimaanJs.setInnerHTML(SessionDuration.panelInfosID, SessionDuration.htmlProlonged());
}

//--------------------------------------------
SessionDuration.htmlProlonged=function()
{
    var t;
t ='<div id="sd_pnlSessionProlonged" class="sd_pnlProlongSession">';
t +='    Die Sitzungszeit vom tariffinder wurde verlängert.';
t +='    <br />';
t +='    <br />';
t +='    <input id="sd_btnSessionProlonged" onclick="SessionDuration.hidePanelInfos();" type="button" class="sd_button"';
t +='        value="Ok" /><br />';
t +='</div>';
    return t;
}

//--------------------------------------------
SessionDuration.doNotProlong = function()
{
   SessionDuration.traceIt('doNotProlong');
   SessionDuration.abandon();
}

//--------------------------------------------
SessionDuration.hidePanelInfos = function()
{
  SessionDuration.traceIt('hidePanelInfos()');

   KaimaanJs.setInnerHTML(SessionDuration.panelInfosID, '');
}

//--------------------------------------------
SessionDuration.abandon=function()
{
   SessionDuration.traceIt('abandon');
   clearInterval(SessionDuration.intervalID); 
   SessionDuration.hidePanelInfos();   
   __doPostBack('mainMenu','Programm beenden');
}

//--------------------------------------------
SessionDuration.traceIt = function(text)
{
   if(SessionDuration.enableTest)
   {
      var d = new Date();
      KaimaanJs.traceIt(d.toLocaleTimeString() + ': SessionDuration: ' + text);
   }
}
//--------------------------------------------


function CheckBoxValidatorEvaluateIsValid(val)
{
    var control = document.getElementById(val.controltovalidate);
    var mustBeChecked = Boolean(val.mustBeChecked);

    return control.checked == mustBeChecked;
}

function CheckBoxListValidatorEvaluateIsValid(val)
{
    var control = document.getElementById(val.controltovalidate);
    var minimumNumberOfSelectedCheckBoxes = parseInt(val.minimumNumberOfSelectedCheckBoxes);

    var selectedItemCount = 0;
    var liIndex = 0;
    var currentListItem = document.getElementById(control.id + '_' + liIndex.toString());
    while (currentListItem != null)
    {
        if (currentListItem.checked) selectedItemCount++;
        liIndex++;
        currentListItem = document.getElementById(control.id + '_' + liIndex.toString());
    }
    
    return selectedItemCount >= minimumNumberOfSelectedCheckBoxes;
}//---------------------------------------------- 
// tariffinder_specifics.js

//---------------------------------------------- 
// die merkmals-auswahllist und die spaltenüberschriften von der detail-tabelle ein- und ausblenden
ResultDetailed_panelListId=null;
ResultDetailed_columnsHeaderId=null;

var clientActiveTabChangedResultDetailed = function(sender, e) 
{
    var tabIndex = sender.get_activeTabIndex();
    ResultDetailedShowExtraPanels(tabIndex===0); 
}

var ResultDetailedShowExtraPanels = function(isShow) 
{
    if(ResultDetailed_panelListId)
    {
       KaimaanJs.displayNode(ResultDetailed_panelListId, isShow);
    }
    
    if(ResultDetailed_columnsHeaderId)
    {
       KaimaanJs.displayNode(ResultDetailed_columnsHeaderId, isShow);
    }
}
//---------------------------------------------- 
// deckungsnote
var CovernoteInput = new Object();

// variablen werden vom programm besetzt:
CovernoteInput.allGroupIds='';
CovernoteInput.inputGroupIds='';
//---------------------------------------------- 
CovernoteInput.showAll = function()
{
    KaimaanJs.displayAllNodes(CovernoteInput.allGroupIds, true);
}
//---------------------------------------------- 
CovernoteInput.showOnlyInputs = function()
{
    KaimaanJs.displayNodeSubset(CovernoteInput.allGroupIds, CovernoteInput.inputGroupIds);
}
//---------------------------------------------- 
CovernoteInput.showOnlyTitles = function()
{
    KaimaanJs.displayAllNodes(CovernoteInput.allGroupIds, false);

    // redraw erzwingen beim ie 8.0
    var vers = KaimaanJs.getInternetExplorerVersion();
    if(vers >= 8.0)
    {
        window.resizeBy(0,1);
    }
}
//---------------------------------------------- 
//---------------------------------------------- 
// js-modul: end
//---------------------------------------------- 
// asp.net ajax: signalisieren, dass die script-datei geladen wurde (wenz s. 20)
if(typeof(Sys) !='undefined')
{
    Sys.Application.notifyScriptLoaded();
}
//----------------------------------------------