// JavaScript Document


/* +--------------+ */
/* | Blur-Effekt: | */
/* +--------------+ */



document.links.onClick=blur();
document.links.onmouseOver=blur();
window.focus();


/* +-----------------+ */
/* | fenster öffnen: | */
/* +-----------------+ */

function MM_openBrWindow(theURL,winName,features) { //v2.0
  window.open(theURL,winName,features);
}


/* +-----------------------+ */
/* | Formular-Validierung: | */
/* +-----------------------+ */
var errors = "";


function markField(inField, inText) {
        document.getElementById(inField).style.backgroundColor = "#FF0000";
        errors += inText + "\n";
}

function unmarkField(inField) {
        document.getElementById(inField).style.backgroundColor = "#FFFFFF";
}


function validateField(inField, inName) {
        var value = document.requestForm.elements[inField].value;
        if (value == "" || value == null) {
                markField(inField, "Bitte füllen Sie das Feld '" + inName + "' aus.");
        } else {
                unmarkField(inField);
        }
}

function validateNumberField(inField, inName) {
        var value = document.requestForm.elements[inField].value;
        if (value == "" || value == null) {
                markField(inField, "Bitte füllen Sie das Feld '" + inName + "' aus.");
        } else if(isNaN(value)) {
                markField(inField, "Bitte geben Sie eine Zahl in das Feld '" + inName + "' ein.");
        } else {
                unmarkField(inField);
        }
}

function validateEMailField(inField, inName) {
        var value = document.requestForm.elements[inField].value;
        if (value == "" || value == null) {
                markField(inField, "Bitte füllen Sie das Feld '" + inName + "' aus.");
        } else if(value.indexOf("@") < 0) {
                markField(inField, "Bitte geben Sie eine g&uuml;ltige E-Mail-Adresse in das Feld '" + inName + "' ein.");
        } else {
                unmarkField(inField);
        }
}


/* AB HIER NEU:::::::::: */








/* +--------------+ */
/* | Blur-Effekt: | */
/* +--------------+ */



document.links.onClick=blur();
document.links.onmouseOver=blur();
window.focus();


/* +---------------+ */
/* | Zoomfunktion: | */
/* +---------------+ */


// Bilder anzeigen mit "Zoom"-Funktion

var zaehler = 50;
function aufmachen(breite,ID) {
 if (zaehler < breite) {
  document.getElementById(ID).style.display="inline";
  document.getElementById(ID).style.width=zaehler+"px";
  zaehler += 30;
  window.setTimeout("aufmachen("+breite+",'"+ID+"')",0);
 }
 else {
  document.getElementById("beschreibung-"+ID).style.display="block";
 }
}

function zumachen(ID) {
 document.getElementById(ID).style.display="none";
 document.getElementById("beschreibung-"+ID).style.display="none";
 zaehler = 50;
}



/* +-----------------+ */
/* | Sprachschalter: | */
/* +-----------------+ */


/* SpryCollapsiblePanel.js - Revision: Spry Preview Release 1.4 */

// Copyright (c) 2006. Adobe Systems Incorporated.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   * Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//   * Neither the name of Adobe Systems Incorporated nor the names of its
//     contributors may be used to endorse or promote products derived from this
//     software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

var Spry;
if (!Spry) Spry = {};
if (!Spry.Widget) Spry.Widget = {};

Spry.Widget.CollapsiblePanel = function(element, opts)
{
        this.init(element);

        Spry.Widget.CollapsiblePanel.setOptions(this, opts);

        this.attachBehaviors();
};

Spry.Widget.CollapsiblePanel.prototype.init = function(element)
{
        this.element = this.getElement(element);
        this.focusElement = null;
        this.hoverClass = "CollapsiblePanelTabHover";
        this.openClass = "CollapsiblePanelOpen";
        this.closedClass = "CollapsiblePanelClosed";
        this.focusedClass = "CollapsiblePanelFocused";
        this.enableAnimation = true;
        this.enableKeyboardNavigation = true;
        this.animator = null;
        this.hasFocus = false;
        this.contentIsOpen = true;
};

Spry.Widget.CollapsiblePanel.prototype.getElement = function(ele)
{
        if (ele && typeof ele == "string")
                return document.getElementById(ele);
        return ele;
};

Spry.Widget.CollapsiblePanel.prototype.addClassName = function(ele, className)
{
        if (!ele || !className || (ele.className && ele.className.search(new RegExp("\\b" + className + "\\b")) != -1))
                return;
        ele.className += (ele.className ? " " : "") + className;
};

Spry.Widget.CollapsiblePanel.prototype.removeClassName = function(ele, className)
{
        if (!ele || !className || (ele.className && ele.className.search(new RegExp("\\b" + className + "\\b")) == -1))
                return;
        ele.className = ele.className.replace(new RegExp("\\s*\\b" + className + "\\b", "g"), "");
};

Spry.Widget.CollapsiblePanel.prototype.hasClassName = function(ele, className)
{
        if (!ele || !className || !ele.className || ele.className.search(new RegExp("\\b" + className + "\\b")) == -1)
                return false;
        return true;
};

Spry.Widget.CollapsiblePanel.prototype.setDisplay = function(ele, display)
{
        if( ele )
                ele.style.display = display;
};

Spry.Widget.CollapsiblePanel.setOptions = function(obj, optionsObj, ignoreUndefinedProps)
{
        if (!optionsObj)
                return;
        for (var optionName in optionsObj)
        {
                if (ignoreUndefinedProps && optionsObj[optionName] == undefined)
                        continue;
                obj[optionName] = optionsObj[optionName];
        }
};

Spry.Widget.CollapsiblePanel.prototype.onTabMouseOver = function()
{
        this.addClassName(this.getTab(), this.hoverClass);
};

Spry.Widget.CollapsiblePanel.prototype.onTabMouseOut = function()
{
        this.removeClassName(this.getTab(), this.hoverClass);
};

Spry.Widget.CollapsiblePanel.prototype.open = function()
{
        this.contentIsOpen = true;
        if (this.enableAnimation)
        {
                if (this.animator)
                        this.animator.stop();
                this.animator = new Spry.Widget.CollapsiblePanel.PanelAnimator(this, true);
                this.animator.start();
        }
        else
                this.setDisplay(this.getContent(), "block");

        this.removeClassName(this.element, this.closedClass);
        this.addClassName(this.element, this.openClass);
};

Spry.Widget.CollapsiblePanel.prototype.close = function()
{
        this.contentIsOpen = false;
        if (this.enableAnimation)
        {
                if (this.animator)
                        this.animator.stop();
                this.animator = new Spry.Widget.CollapsiblePanel.PanelAnimator(this, false);
                this.animator.start();
        }
        else
                this.setDisplay(this.getContent(), "none");

        this.removeClassName(this.element, this.openClass);
        this.addClassName(this.element, this.closedClass);
};

Spry.Widget.CollapsiblePanel.prototype.onTabClick = function()
{
        if (this.isOpen())
                this.close();
        else
                this.open();
        this.focus();
};

Spry.Widget.CollapsiblePanel.prototype.onFocus = function(e)
{
        this.hasFocus = true;
        this.addClassName(this.element, this.focusedClass);
};

Spry.Widget.CollapsiblePanel.prototype.onBlur = function(e)
{
        this.hasFocus = false;
        this.removeClassName(this.element, this.focusedClass);
};

Spry.Widget.CollapsiblePanel.ENTER_KEY = 13;
Spry.Widget.CollapsiblePanel.SPACE_KEY = 32;

Spry.Widget.CollapsiblePanel.prototype.onKeyDown = function(e)
{
        var key = e.keyCode;
        if (!this.hasFocus || (key != Spry.Widget.CollapsiblePanel.ENTER_KEY && key != Spry.Widget.CollapsiblePanel.SPACE_KEY))
                return true;

        if (this.isOpen())
                this.close();
        else
                this.open();

        if (e.stopPropagation)
                e.stopPropagation();
        if (e.preventDefault)
                e.preventDefault();

        return false;
};

Spry.Widget.CollapsiblePanel.prototype.attachPanelHandlers = function()
{
        var tab = this.getTab();
        if (!tab)
                return;

        var self = this;
        Spry.Widget.CollapsiblePanel.addEventListener(tab, "click", function(e) { return self.onTabClick(); }, false);
        Spry.Widget.CollapsiblePanel.addEventListener(tab, "mouseover", function(e) { return self.onTabMouseOver(); }, false);
        Spry.Widget.CollapsiblePanel.addEventListener(tab, "mouseout", function(e) { return self.onTabMouseOut(); }, false);

        if (this.enableKeyboardNavigation)
        {
                // XXX: IE doesn't allow the setting of tabindex dynamically. This means we can't
                // rely on adding the tabindex attribute if it is missing to enable keyboard navigation
                // by default.

                // Find the first element within the tab container that has a tabindex or the first
                // anchor tag.

                var tabIndexEle = null;
                var tabAnchorEle = null;

                this.preorderTraversal(tab, function(node) {
                        if (node.nodeType == 1 /* NODE.ELEMENT_NODE */)
                        {
                                var tabIndexAttr = tab.attributes.getNamedItem("tabindex");
                                if (tabIndexAttr)
                                {
                                        tabIndexEle = node;
                                        return true;
                                }
                                if (!tabAnchorEle && node.nodeName.toLowerCase() == "a")
                                        tabAnchorEle = node;
                        }
                        return false;
                });

                if (tabIndexEle)
                        this.focusElement = tabIndexEle;
                else if (tabAnchorEle)
                        this.focusElement = tabAnchorEle;

                if (this.focusElement)
                {
                        Spry.Widget.CollapsiblePanel.addEventListener(this.focusElement, "focus", function(e) { return self.onFocus(e); }, false);
                        Spry.Widget.CollapsiblePanel.addEventListener(this.focusElement, "blur", function(e) { return self.onBlur(e); }, false);
                        Spry.Widget.CollapsiblePanel.addEventListener(this.focusElement, "keydown", function(e) { return self.onKeyDown(e); }, false);
                }
        }
};

Spry.Widget.CollapsiblePanel.addEventListener = function(element, eventType, handler, capture)
{
        try
        {
                if (element.addEventListener)
                        element.addEventListener(eventType, handler, capture);
                else if (element.attachEvent)
                        element.attachEvent("on" + eventType, handler);
        }
        catch (e) {}
};

Spry.Widget.CollapsiblePanel.prototype.preorderTraversal = function(root, func)
{
        var stopTraversal = false;
        if (root)
        {
                stopTraversal = func(root);
                if (root.hasChildNodes())
                {
                        var child = root.firstChild;
                        while (!stopTraversal && child)
                        {
                                stopTraversal = this.preorderTraversal(child, func);
                                try { child = child.nextSibling; } catch (e) { child = null; }
                        }
                }
        }
        return stopTraversal;
};

Spry.Widget.CollapsiblePanel.prototype.attachBehaviors = function()
{
        var panel = this.element;
        var tab = this.getTab();
        var content = this.getContent();

        if (this.contentIsOpen || this.hasClassName(panel, this.openClass))
        {
                this.removeClassName(panel, this.closedClass);
                this.setDisplay(content, "block");
                this.contentIsOpen = true;
        }
        else
        {
                this.removeClassName(panel, this.openClass);
                this.addClassName(panel, this.closedClass);
                this.setDisplay(content, "none");
                this.contentIsOpen = false;
        }

        this.attachPanelHandlers();
};

Spry.Widget.CollapsiblePanel.prototype.getTab = function()
{
        return this.getElementChildren(this.element)[0];
};

Spry.Widget.CollapsiblePanel.prototype.getContent = function()
{
        return this.getElementChildren(this.element)[1];
};

Spry.Widget.CollapsiblePanel.prototype.isOpen = function()
{
        return this.contentIsOpen;
};

Spry.Widget.CollapsiblePanel.prototype.getElementChildren = function(element)
{
        var children = [];
        var child = element.firstChild;
        while (child)
        {
                if (child.nodeType == 1 /* Node.ELEMENT_NODE */)
                        children.push(child);
                child = child.nextSibling;
        }
        return children;
};

Spry.Widget.CollapsiblePanel.prototype.focus = function()
{
        if (this.focusElement && this.focusElement.focus)
                this.focusElement.focus();
};

/////////////////////////////////////////////////////

Spry.Widget.CollapsiblePanel.PanelAnimator = function(panel, doOpen, opts)
{
        this.timer = null;
        this.interval = 0;
        this.stepCount = 0;

        this.fps = 0;
        this.steps = 10;
        this.duration = 500;
        this.onComplete = null;

        this.panel = panel;
        this.content = panel.getContent();
        this.panelData = [];
        this.doOpen = doOpen;

        Spry.Widget.CollapsiblePanel.setOptions(this, opts);


        // If caller specified speed in terms of frames per second,
        // convert them into steps.

        if (this.fps > 0)
        {
                this.interval = Math.floor(1000 / this.fps);
                this.steps = parseInt((this.duration + (this.interval - 1)) / this.interval);
        }
        else if (this.steps > 0)
                this.interval = this.duration / this.steps;

        var c = this.content;

        var curHeight = c.offsetHeight ? c.offsetHeight : 0;

        if (doOpen && c.style.display == "none")
                this.fromHeight = 0;
        else
                this.fromHeight = curHeight;

        if (!doOpen)
                this.toHeight = 0;
        else
        {
                if (c.style.display == "none")
                {
                        // The content area is not displayed so in order to calculate the extent
                        // of the content inside it, we have to set its display to block.

                        c.style.visibility = "hidden";
                        c.style.display = "block";
                }

                // Unfortunately in Mozilla/Firefox, fetching the offsetHeight seems to cause
                // the browser to synchronously re-layout and re-display content on the page,
                // so we see a brief flash of content that is *after* the panel being positioned
                // where it should when the panel is fully expanded. To get around this, we
                // temporarily position the content area of the panel absolutely off-screen.
                // This has the effect of taking the content out-of-flow, so nothing shifts around.

                // var oldPos = c.style.position;
                // var oldLeft = c.style.left;
                // c.style.position = "absolute";
                // c.style.left = "-2000em";

                // Clear the height property so we can calculate
                // the full height of the content we are going to show.
                c.style.height = "";
                this.toHeight = c.offsetHeight;

                // Now restore the position and offset to what it was!
                // c.style.position = oldPos;
                // c.style.left = oldLeft;
        }

        this.increment = (this.toHeight - this.fromHeight) / this.steps;
        this.overflow = c.style.overflow;

        c.style.height = this.fromHeight + "px";
        c.style.visibility = "visible";
        c.style.overflow = "hidden";
        c.style.display = "block";
};

Spry.Widget.CollapsiblePanel.PanelAnimator.prototype.start = function()
{
        var self = this;
        this.timer = setTimeout(function() { self.stepAnimation(); }, this.interval);
};

Spry.Widget.CollapsiblePanel.PanelAnimator.prototype.stop = function()
{
        if (this.timer)
        {
                clearTimeout(this.timer);

                // If we're killing the timer, restore the overflow
                // properties on the panels we were animating!

                if (this.stepCount < this.steps)
                        this.content.style.overflow = this.overflow;
        }

        this.timer = null;
};

Spry.Widget.CollapsiblePanel.PanelAnimator.prototype.stepAnimation = function()
{
        ++this.stepCount;

        this.animate();

        if (this.stepCount < this.steps)
                this.start();
        else if (this.onComplete)
                this.onComplete();
};

Spry.Widget.CollapsiblePanel.PanelAnimator.prototype.animate = function()
{
        if (this.stepCount >= this.steps)
        {
                if (!this.doOpen)
                        this.content.style.display = "none";
                this.content.style.overflow = this.overflow;
                this.content.style.height = this.toHeight + "px";
        }
        else
        {
                this.fromHeight += this.increment;
                this.content.style.height = this.fromHeight + "px";
        }
};








/* +------------------------+ */
/* | Klapp-Men&uuml;-Funktionen: | */
/* +------------------------+ */




/* SpryMenuBar.js - Revision: Spry Preview Release 1.4 */

// Copyright (c) 2006. Adobe Systems Incorporated.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   * Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//   * Neither the name of Adobe Systems Incorporated nor the names of its
//     contributors may be used to endorse or promote products derived from this
//     software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

/*******************************************************************************

 SpryMenuBar.js
 This file handles the JavaScript for Spry Menu Bar.  You should have no need
 to edit this file.  Some highlights of the MenuBar object is that timers are
 used to keep submenus from showing up until the user has hovered over the parent
 menu item for some time, as well as a timer for when they leave a submenu to keep
 showing that submenu until the timer fires.

 *******************************************************************************/

var Spry;
if(!Spry)
{
        Spry = {};
}
if(!Spry.Widget)
{
        Spry.Widget = {};
}

// Constructor for Menu Bar
// element should be an ID of an unordered list (<ol> tag)
// preloadImage1 and preloadImage2 are images for the rollover state of a menu
Spry.Widget.MenuBar = function(element, opts)
{
        this.init(element, opts);
};

Spry.Widget.MenuBar.prototype.init = function(element, opts)
{
        this.element = this.getElement(element);

        // represents the current (sub)menu we are operating on
        this.currMenu = null;

        var isie = (typeof document.all != 'undefined' && typeof window.opera == 'undefined' && navigator.vendor != 'KDE');
        if(typeof document.getElementById == 'undefined' || (navigator.vendor == 'Apple Computer, Inc.' && typeof window.XMLHttpRequest == 'undefined') || (isie && typeof document.uniqueID == 'undefined'))
        {
                // bail on older unsupported browsers
                return;
        }

        // load hover images now
        if(opts)
        {
                for(var k in opts)
                {
                        var rollover = new Image;
                        rollover.src = opts[k];
                }
        }

        if(this.element)
        {
                this.currMenu = this.element;
                var items = this.element.getElementsByTagName('li');
                for(var i=0; i<items.length; i++)
                {
                        this.initialize(items[i], element, isie);
                        if(isie)
                        {
                                this.addClassName(items[i], "MenuBarItemIE");
                                items[i].style.position = "static";
                        }
                }
                if(isie)
                {
                        if(this.hasClassName(this.element, "MenuBarVertical"))
                        {
                                this.element.style.position = "relative";
                        }
                        var linkitems = this.element.getElementsByTagName('a');
                        for(var i=0; i<linkitems.length; i++)
                        {
                                linkitems[i].style.position = "relative";
                        }
                }
        }
};

Spry.Widget.MenuBar.prototype.getElement = function(ele)
{
        if (ele && typeof ele == "string")
                return document.getElementById(ele);
        return ele;
};

Spry.Widget.MenuBar.prototype.hasClassName = function(ele, className)
{
        if (!ele || !className || !ele.className || ele.className.search(new RegExp("\\b" + className + "\\b")) == -1)
        {
                return false;
        }
        return true;
};

Spry.Widget.MenuBar.prototype.addClassName = function(ele, className)
{
        if (!ele || !className || this.hasClassName(ele, className))
                return;
        ele.className += (ele.className ? " " : "") + className;
};

Spry.Widget.MenuBar.prototype.removeClassName = function(ele, className)
{
        if (!ele || !className || !this.hasClassName(ele, className))
                return;
        ele.className = ele.className.replace(new RegExp("\\s*\\b" + className + "\\b", "g"), "");
};

// addEventListener for Menu Bar
// attach an event to a tag without creating obtrusive HTML code
Spry.Widget.MenuBar.prototype.addEventListener = function(element, eventType, handler, capture)
{
        try
        {
                if (element.addEventListener)
                {
                        element.addEventListener(eventType, handler, capture);
                }
                else if (element.attachEvent)
                {
                        element.attachEvent('on' + eventType, handler);
                }
        }
        catch (e) {}
};

// createIframeLayer for Menu Bar
// creates an IFRAME underneath a menu so that it will show above form controls and ActiveX
Spry.Widget.MenuBar.prototype.createIframeLayer = function(menu)
{
        var layer = document.createElement('iframe');
        layer.tabIndex = '-1';
        layer.src = 'javascript:false;';
        menu.parentNode.appendChild(layer);

        layer.style.left = menu.offsetLeft + 'px';
        layer.style.top = menu.offsetTop + 'px';
        layer.style.width = menu.offsetWidth + 'px';
        layer.style.height = menu.offsetHeight + 'px';
};

// removeIframeLayer for Menu Bar
// removes an IFRAME underneath a menu to reveal any form controls and ActiveX
Spry.Widget.MenuBar.prototype.removeIframeLayer =  function(menu)
{
        var layers = menu.parentNode.getElementsByTagName('iframe');
        while(layers.length > 0)
        {
                layers[0].parentNode.removeChild(layers[0]);
        }
};

// clearMenus for Menu Bar
// root is the top level unordered list (<ol> tag)
Spry.Widget.MenuBar.prototype.clearMenus = function(root)
{
        var menus = root.getElementsByTagName('ol');
        for(var i=0; i<menus.length; i++)
        {
                this.hideSubmenu(menus[i]);
        }
        this.removeClassName(this.element, "MenuBarActive");
};

// bubbledTextEvent for Menu Bar
// identify bubbled up text events in Safari so we can ignore them
Spry.Widget.MenuBar.prototype.bubbledTextEvent = function()
{
        return (navigator.vendor == 'Apple Computer, Inc.' && (event.target == event.relatedTarget.parentNode || (event.eventPhase == 3 && event.target.parentNode == event.relatedTarget)));
};

// showSubmenu for Menu Bar
// set the proper CSS class on this menu to show it
Spry.Widget.MenuBar.prototype.showSubmenu = function(menu)
{
        if(this.currMenu)
        {
                this.clearMenus(this.currMenu);
                this.currMenu = null;
        }

        if(menu)
        {
                this.addClassName(menu, "MenuBarSubmenuVisible");
                if(typeof document.all != 'undefined' && typeof window.opera == 'undefined' && navigator.vendor != 'KDE')
                {
                        if(!this.hasClassName(this.element, "MenuBarHorizontal") || menu.parentNode.parentNode != this.element)
                        {
                                menu.style.top = menu.parentNode.offsetTop + 'px';
                        }
                }
                if(typeof document.uniqueID != "undefined")
                {
                        this.createIframeLayer(menu);
                }
        }
        this.addClassName(this.element, "MenuBarActive");
};

// hideSubmenu for Menu Bar
// remove the proper CSS class on this menu to hide it
Spry.Widget.MenuBar.prototype.hideSubmenu = function(menu)
{
        if(menu)
        {
                this.removeClassName(menu, "MenuBarSubmenuVisible");
                if(typeof document.all != 'undefined' && typeof window.opera == 'undefined' && navigator.vendor != 'KDE')
                {
                        menu.style.top = '';
                        menu.style.left = '';
                }
                this.removeIframeLayer(menu);
        }
};

// initialize for Menu Bar
// create event listeners for the Menu Bar widget so we can properly
// show and hide submenus
Spry.Widget.MenuBar.prototype.initialize = function(listitem, element, isie)
{
        var opentime, closetime;
        var link = listitem.getElementsByTagName('a')[0];
        var submenus = listitem.getElementsByTagName('ol');
        var menu = (submenus.length > 0 ? submenus[0] : null);

        var hasSubMenu = false;
        if(menu)
        {
                this.addClassName(link, "MenuBarItemSubmenu");
                hasSubMenu = true;
        }

        if(!isie)
        {
                // define a simple function that comes standard in IE to determine
                // if a node is within another node
                listitem.contains = function(testNode)
                {
                        // this refers to the list item
                        if(testNode == null)
                        {
                                return false;
                        }
                        if(testNode == this)
                        {
                                return true;
                        }
                        else
                        {
                                return this.contains(testNode.parentNode);
                        }
                };
        }

        // need to save this for scope further down
        var self = this;

        this.addEventListener(listitem, 'mouseover', function(e)
        {
                if(self.bubbledTextEvent())
                {
                        // ignore bubbled text events
                        return;
                }
                clearTimeout(closetime);
                if(self.currMenu == listitem)
                {
                        self.currMenu = null;
                }
                // show menu highlighting
                self.addClassName(link, hasSubMenu ? "MenuBarItemSubmenuHover" : "MenuBarItemHover");
                if(menu && !self.hasClassName(menu, "MenuBarSubmenuVisible"))
                {
                        opentime = window.setTimeout(function(){self.showSubmenu(menu);}, 250);
                }
        }, false);

        this.addEventListener(listitem, 'mouseout', function(e)
        {
                if(self.bubbledTextEvent())
                {
                        // ignore bubbled text events
                        return;
                }

                var related = (typeof e.relatedTarget != 'undefined' ? e.relatedTarget : e.toElement);
                if(!listitem.contains(related))
                {
                        clearTimeout(opentime);
                        self.currMenu = listitem;

                        // remove menu highlighting
                        self.removeClassName(link, hasSubMenu ? "MenuBarItemSubmenuHover" : "MenuBarItemHover");
                        if(menu)
                        {
                                closetime = window.setTimeout(function(){self.hideSubmenu(menu);}, 600);
                        }
                }
        }, false);
};





/* +---------------------------+ */
/* | Subnavigation: Accordion: | */
/* +---------------------------+ */


/* SpryAccordion.js - Revision: Spry Preview Release 1.4 */

// Copyright (c) 2006. Adobe Systems Incorporated.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   * Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//   * Neither the name of Adobe Systems Incorporated nor the names of its
//     contributors may be used to endorse or promote products derived from this
//     software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

var Spry;
if (!Spry) Spry = {};
if (!Spry.Widget) Spry.Widget = {};

Spry.Widget.Accordion = function(element, opts)
{
        this.element = this.getElement(element);
        this.defaultPanel = 0;
        this.hoverClass = "AccordionPanelTabHover";
        this.openClass = "AccordionPanelOpen";
        this.closedClass = "AccordionPanelClosed";
        this.focusedClass = "AccordionFocused";
        this.enableAnimation = true;
        this.enableKeyboardNavigation = true;
        this.currentPanel = null;
        this.animator = null;
        this.hasFocus = null;
        this.duration = 500;

        this.previousPanelKeyCode = Spry.Widget.Accordion.KEY_UP;
        this.nextPanelKeyCode = Spry.Widget.Accordion.KEY_DOWN;

        this.useFixedPanelHeights = false;
        this.fixedPanelHeight = 0;

        Spry.Widget.Accordion.setOptions(this, opts, true);

        // Unfortunately in some browsers like Safari, the Stylesheets our
        // page depends on may not have been loaded at the time we are called.
        // This means we have to defer attaching our behaviors until after the
        // onload event fires, since some of our behaviors rely on dimensions
        // specified in the CSS.

        if (Spry.Widget.Accordion.onloadDidFire)
                this.attachBehaviors();
        else
                Spry.Widget.Accordion.loadQueue.push(this);
};

Spry.Widget.Accordion.onloadDidFire = false;
Spry.Widget.Accordion.loadQueue = [];

Spry.Widget.Accordion.addLoadListener = function(handler)
{
        if (typeof window.addEventListener != 'undefined')
                window.addEventListener('load', handler, false);
        else if (typeof document.addEventListener != 'undefined')
                document.addEventListener('load', handler, false);
        else if (typeof window.attachEvent != 'undefined')
                window.attachEvent('onload', handler);
};

Spry.Widget.Accordion.processLoadQueue = function(handler)
{
        Spry.Widget.Accordion.onloadDidFire = true;
        var q = Spry.Widget.Accordion.loadQueue;
        var qlen = q.length;
        for (var i = 0; i < qlen; i++)
                q[i].attachBehaviors();
};

Spry.Widget.Accordion.addLoadListener(Spry.Widget.Accordion.processLoadQueue);

Spry.Widget.Accordion.prototype.getElement = function(ele)
{
        if (ele && typeof ele == "string")
                return document.getElementById(ele);
        return ele;
};

Spry.Widget.Accordion.prototype.addClassName = function(ele, className)
{
        if (!ele || !className || (ele.className && ele.className.search(new RegExp("\\b" + className + "\\b")) != -1))
                return;
        ele.className += (ele.className ? " " : "") + className;
};

Spry.Widget.Accordion.prototype.removeClassName = function(ele, className)
{
        if (!ele || !className || (ele.className && ele.className.search(new RegExp("\\b" + className + "\\b")) == -1))
                return;
        ele.className = ele.className.replace(new RegExp("\\s*\\b" + className + "\\b", "g"), "");
};

Spry.Widget.Accordion.setOptions = function(obj, optionsObj, ignoreUndefinedProps)
{
        if (!optionsObj)
                return;
        for (var optionName in optionsObj)
        {
                if (ignoreUndefinedProps && optionsObj[optionName] == undefined)
                        continue;
                obj[optionName] = optionsObj[optionName];
        }
};

Spry.Widget.Accordion.prototype.onPanelTabMouseOver = function(panel)
{
        if (panel)
                this.addClassName(this.getPanelTab(panel), this.hoverClass);
};

Spry.Widget.Accordion.prototype.onPanelTabMouseOut = function(panel)
{
        if (panel)
                this.removeClassName(this.getPanelTab(panel), this.hoverClass);
};

Spry.Widget.Accordion.prototype.openPanel = function(panel)
{
        var panelA = this.currentPanel;
        var panelB = panel;

        if (!panelB || panelA == panelB)
                return;

        var contentA;
        if( panelA )
                contentA = this.getPanelContent(panelA);
        var contentB = this.getPanelContent(panelB);

        if (! contentB)
                return;

        if (this.useFixedPanelHeights && !this.fixedPanelHeight)
        {
                this.fixedPanelHeight = (contentA.offsetHeight) ? contentA.offsetHeight : contentA.scrollHeight;
        }

        if (this.enableAnimation)
        {
                if (this.animator)
                        this.animator.stop();
                this.animator = new Spry.Widget.Accordion.PanelAnimator(this, panelB, { duration: this.duration });
                this.animator.start();
        }
        else
        {
                if(contentA)
                        contentA.style.height = "0px";
                contentB.style.height = (this.useFixedPanelHeights ? this.fixedPanelHeight : contentB.scrollHeight) + "px";
        }

        if(panelA)
        {
                this.removeClassName(panelA, this.openClass);
                this.addClassName(panelA, this.closedClass);
        }

        this.removeClassName(panelB, this.closedClass);
        this.addClassName(panelB, this.openClass);

        this.currentPanel = panelB;
};

Spry.Widget.Accordion.prototype.openNextPanel = function()
{
        var panels = this.getPanels();
        var curPanelIndex = this.getCurrentPanelIndex();

        if( panels && curPanelIndex >= 0 && (curPanelIndex+1) < panels.length )
                this.openPanel(panels[curPanelIndex+1]);
};

Spry.Widget.Accordion.prototype.openPreviousPanel = function()
{
        var panels = this.getPanels();
        var curPanelIndex = this.getCurrentPanelIndex();

        if( panels && curPanelIndex > 0 && curPanelIndex < panels.length )
                this.openPanel(panels[curPanelIndex-1]);
};

Spry.Widget.Accordion.prototype.openFirstPanel = function()
{
        var panels = this.getPanels();
        if( panels )
                this.openPanel(panels[0]);
};

Spry.Widget.Accordion.prototype.openLastPanel = function()
{
        var panels = this.getPanels();
        if( panels )
                this.openPanel(panels[panels.length-1]);
};

Spry.Widget.Accordion.prototype.onPanelClick = function(panel)
{
        // if (this.enableKeyboardNavigation)
        //         this.element.focus();
        if (panel != this.currentPanel)
                this.openPanel(panel);
        this.focus();
};

Spry.Widget.Accordion.prototype.onFocus = function(e)
{
        // this.element.focus();
        this.hasFocus = true;
        this.addClassName(this.element, this.focusedClass);
};

Spry.Widget.Accordion.prototype.onBlur = function(e)
{
        // this.element.blur();
        this.hasFocus = false;
        this.removeClassName(this.element, this.focusedClass);
};

Spry.Widget.Accordion.KEY_UP = 38;
Spry.Widget.Accordion.KEY_DOWN = 40;

Spry.Widget.Accordion.prototype.onKeyDown = function(e)
{
        var key = e.keyCode;
        if (!this.hasFocus || (key != this.previousPanelKeyCode && key != this.nextPanelKeyCode))
                return true;

        var panels = this.getPanels();
        if (!panels || panels.length < 1)
                return false;
        var currentPanel = this.currentPanel ? this.currentPanel : panels[0];
        var nextPanel = (key == this.nextPanelKeyCode) ? currentPanel.nextSibling : currentPanel.previousSibling;

        while (nextPanel)
        {
                if (nextPanel.nodeType == 1 /* Node.ELEMENT_NODE */)
                        break;
                nextPanel = (key == this.nextPanelKeyCode) ? nextPanel.nextSibling : nextPanel.previousSibling;
        }

        if (nextPanel && currentPanel != nextPanel)
                this.openPanel(nextPanel);

        if (e.stopPropagation)
                e.stopPropagation();
        if (e.preventDefault)
                e.preventDefault();

        return false;
};

Spry.Widget.Accordion.prototype.attachPanelHandlers = function(panel)
{
        if (!panel)
                return;

        var tab = this.getPanelTab(panel);

        if (tab)
        {
                var self = this;
                Spry.Widget.Accordion.addEventListener(tab, "mouseover", function(e) { return self.onPanelClick(panel); }, false);
                //Spry.Widget.Accordion.addEventListener(tab, "mouseover", function(e) { return self.onPanelTabMouseOver(panel); }, false);
                Spry.Widget.Accordion.addEventListener(tab, "mouseout", function(e) { return self.onPanelTabMouseOut(panel); }, false);
        }
};

Spry.Widget.Accordion.addEventListener = function(element, eventType, handler, capture)
{
        try
        {
                if (element.addEventListener)
                        element.addEventListener(eventType, handler, capture);
                else if (element.attachEvent)
                        element.attachEvent("on" + eventType, handler);
        }
        catch (e) {}
};

Spry.Widget.Accordion.prototype.initPanel = function(panel, isDefault)
{
        var content = this.getPanelContent(panel);
        if (isDefault)
        {
                this.currentPanel = panel;
                this.removeClassName(panel, this.closedClass);
                this.addClassName(panel, this.openClass);
        }
        else
        {
                this.removeClassName(panel, this.openClass);
                this.addClassName(panel, this.closedClass);
                content.style.height = "0px";
        }

        this.attachPanelHandlers(panel);
};

Spry.Widget.Accordion.prototype.attachBehaviors = function()
{
        var panels = this.getPanels();
        for (var i = 0; i < panels.length; i++)
        {
                this.initPanel(panels[i], i == this.defaultPanel);
        }

        if (this.enableKeyboardNavigation)
        {
                // XXX: IE doesn't allow the setting of tabindex dynamically. This means we can't
                // rely on adding the tabindex attribute if it is missing to enable keyboard navigation
                // by default.

                var tabIndexAttr = this.element.attributes.getNamedItem("tabindex");
                // if (!tabIndexAttr) this.element.tabindex = 0;
                if (tabIndexAttr)
                {
                        var self = this;
                        Spry.Widget.Accordion.addEventListener(this.element, "focus", function(e) { return self.onFocus(e); }, false);
                        Spry.Widget.Accordion.addEventListener(this.element, "blur", function(e) { return self.onBlur(e); }, false);
                        Spry.Widget.Accordion.addEventListener(this.element, "keydown", function(e) { return self.onKeyDown(e); }, false);
                }
        }
};

Spry.Widget.Accordion.prototype.getPanels = function()
{
        return this.getElementChildren(this.element);
};

Spry.Widget.Accordion.prototype.getCurrentPanel = function()
{
        return this.currentPanel;
};

Spry.Widget.Accordion.prototype.getCurrentPanelIndex = function()
{
        var panels = this.getPanels();
        for( var i = 0 ; i < panels.length; i++ )
        {
                if( this.currentPanel == panels[i] )
                        return i;
        }
        return 0;
};

Spry.Widget.Accordion.prototype.getPanelTab = function(panel)
{
        if (!panel)
                return null;
        return this.getElementChildren(panel)[0];
};

Spry.Widget.Accordion.prototype.getPanelContent = function(panel)
{
        if (!panel)
                return null;
        return this.getElementChildren(panel)[1];
};

Spry.Widget.Accordion.prototype.getElementChildren = function(element)
{
        var children = [];
        var child = element.firstChild;
        while (child)
        {
                if (child.nodeType == 1 /* Node.ELEMENT_NODE */)
                        children.push(child);
                child = child.nextSibling;
        }
        return children;
};

Spry.Widget.Accordion.prototype.focus = function()
{
//        if (this.element && this.element.focus)
//                this.element.focus();
};

/////////////////////////////////////////////////////

Spry.Widget.Accordion.PanelAnimator = function(accordion, panel, opts)
{
        this.timer = null;
        this.interval = 0;
        this.stepCount = 0;

        this.fps = 0;
        this.steps = 10;
        this.duration = 500;
        this.onComplete = null;

        this.panel = panel;
        this.panelToOpen = accordion.getElement(panel);
        this.panelData = [];

        Spry.Widget.Accordion.setOptions(this, opts, true);


        // If caller specified speed in terms of frames per second,
        // convert them into steps.

        if (this.fps > 0)
        {
                this.interval = Math.floor(1000 / this.fps);
                this.steps = parseInt((this.duration + (this.interval - 1)) / this.interval);
        }
        else if (this.steps > 0)
                this.interval = this.duration / this.steps;

        // Set up the array of panels we want to animate.

        var panels = accordion.getPanels();
        for (var i = 0; i < panels.length; i++)
        {
                var p = panels[i];
                var c = accordion.getPanelContent(p);
                if (c)
                {
                        var h = c.offsetHeight;
                        if (h == undefined)
                                h = 0;
                        if (p == panel || h > 0)
                        {
                                var obj = new Object;
                                obj.panel = p;
                                obj.content = c;
                                obj.fromHeight = h;
                                obj.toHeight = (p == panel) ? (accordion.useFixedPanelHeights ? accordion.fixedPanelHeight : c.scrollHeight) : 0;
                                obj.increment = (obj.toHeight - obj.fromHeight) / this.steps;
                                obj.overflow = c.style.overflow;
                                this.panelData.push(obj);

                                c.style.overflow = "hidden";
                                c.style.height = h + "px";
                        }
                }
        }
};

Spry.Widget.Accordion.PanelAnimator.prototype.start = function()
{
        var self = this;
        this.timer = setTimeout(function() { self.stepAnimation(); }, this.interval);
};

Spry.Widget.Accordion.PanelAnimator.prototype.stop = function()
{
        if (this.timer)
        {
                clearTimeout(this.timer);

                // If we're killing the timer, restore the overflow
                // properties on the panels we were animating!

                if (this.stepCount < this.steps)
                {
                        for (i = 0; i < this.panelData.length; i++)
                        {
                                obj = this.panelData[i];
                                obj.content.style.overflow = obj.overflow;
                        }
                }
        }

        this.timer = null;
};

Spry.Widget.Accordion.PanelAnimator.prototype.stepAnimation = function()
{
        ++this.stepCount;

        this.animate();

        if (this.stepCount < this.steps)
                this.start();
        else if (this.onComplete)
                this.onComplete();
};

Spry.Widget.Accordion.PanelAnimator.prototype.animate = function()
{
        var i, obj;

        if (this.stepCount >= this.steps)
        {
                for (i = 0; i < this.panelData.length; i++)
                {
                        obj = this.panelData[i];
                        if (obj.panel != this.panel)
                                obj.content.style.height = "0px";
                        obj.content.style.overflow = obj.overflow;
                        obj.content.style.height = obj.toHeight + "px";
                }
        }
        else
        {
                for (i = 0; i < this.panelData.length; i++)
                {
                        obj = this.panelData[i];
                        obj.fromHeight += obj.increment;
                        obj.content.style.height = obj.fromHeight + "px";
                }
        }
};


function updateDateFields(inId) {
        var myDate = document.getElementById(inId).value;

        var day = myDate.substr(0, 2);
        var month = myDate.substr(3, 2);
        var year = myDate.substr(6);

        document.getElementById(inId + "-tag").value = day;
        document.getElementById(inId + "-monat").value = month;
        document.getElementById(inId + "-jahr").value = year;
}