/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function isObject(x)
{
    return typeof x == "object" && x !== null;
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function isNumber(x)
{
    return typeof x == "number";
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function isArray(x)
{
    return isObject(x) && x.constructor == Array;
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function isBool(x)
{
    return typeof x == "boolean";
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function isString(x)
{
    return typeof x == "string";
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function isStringEmpty(x)
{
    return (typeof x == "string") && (x == "");
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function isUndefined(x)
{
    return typeof x == "undefined";
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function isFunction(x)
{
    return typeof x == "function";
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function $(obj)
{
    if (!isObject(obj))
        if (!isObject(obj = document.getElementById(obj)))
            return false;

    return obj;
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function serializeArray(aArray)
{
    var serialized = "";
    for (k in aArray)
        serialized += encodeURIComponent(aArray[k]) + "&";
    return serialized;
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function unserializeArray(aString)
{
    if (!isString(aString)) return [];

    var elements = aString.split("&");

    for (k in elements)
        elements[k] = decodeURIComponent(elements[k]);

    return elements;
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function toInt(num)
{
    if (isNumber(num))  return num;
    if (!isString(num)) return 0;

    var integerPattern = /^(-)?0*([0-9]*)[^0-9]*$/;
    var match = num.match(integerPattern);

    if (!match) return 0;

    return match[2] ? parseInt(match[2]) * (match[1] ? -1 : 1) : 0;
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function toFloat(num)
{
    if (isNumber(num))  return num;
    if (!isString(num)) return 0;

    var integerPattern = /^(-)?0*([0-9]*)(\.|,)([0-9]*)[^0-9]*$/;
    var match = num.match(integerPattern);

    if (!match) return 0;

    return match[2] ? parseFloat(match[2]+"."+match[4]) * (match[1] ? -1 : 1) : 0.0;
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function createCookie(name, value, days)
{
	if (days)
    {
		var date = new Date();
		date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
		var expires = "; expires="+date.toGMTString();
	}
	else
        var expires = "";

	document.cookie = name + "=" + value + expires + "; path=/";
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function readCookie(name)
{
	var nameEQ = name + "=";
	var ca = document.cookie.split(';');

	for (var i = 0; i < ca.length; i++)
    {
		var c = ca[i];

		while (c.charAt(0) == ' ')
            c = c.substring(1, c.length);

		if (c.indexOf(nameEQ) == 0)
            return c.substring(nameEQ.length, c.length);
	}
	return null;
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function eraseCookie(name)
{
	createCookie(name, "", -1);
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function getElementX(obj)
{
	var curleft = 0;
	if (obj.offsetParent)
	{
		while (obj.offsetParent)
		{
			curleft += obj.offsetLeft
			obj = obj.offsetParent;
		}
	}
	else if (obj.x)
		curleft += obj.x;
	return curleft;// + (is_ie ? 12 : 0);
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function getElementY(obj)
{
	var curtop = 0;
	if (obj.offsetParent)
	{
		while (obj.offsetParent)
		{
			curtop += obj.offsetTop
			obj = obj.offsetParent;
		}
	}
	else if (obj.y)
		curtop += obj.y;
	return curtop;// + (is_ie ? 17 : 0);
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function getChildNodesList(aObj, aOutput, tag, recursive)
{
    if (!isObject(aObj)) return;
    if (!aObj.hasChildNodes()) return;

    var child = aObj.firstChild;
    tag = isString(tag) ? tag : "";

    do
    {
        if (tag == "" || (child.nodeType != 3 && child.tagName.toLowerCase() == tag))
            aOutput[aOutput.length] = child;
        if (child.hasChildNodes() && recursive == true)
            getChildNodesList(child, aOutput, tag, recursive);
        child = child.nextSibling;
    }
    while (child);
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function isInArray(aArray, aNeedle)
{
    if (!isArray(aArray)) return false;
    for (key in aArray)
        if (aArray[key] === aNeedle)
            return true;
    return false;
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function isMouseIn(obj)
{
    if (!isObject(obj))
        return false;

    oX = getElementX(obj);
    oY = getElementY(obj);
    oW = obj.offsetWidth;
    oH = obj.offsetHeight;
    if (mousePos.x <= (oX + oW) &&
        mousePos.x >= oX &&
        mousePos.y <= (oY + oH) &&
        mousePos.y >= oY)
    return true; else return false;
}

/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function bubbleEvent(aEvent, aBubble)
{
    try
    {
        if (!aEvent)
            if (!(aEvent = window.event)) return;

        aEvent.cancelBubble = !aBubble;

        if (aEvent.stopPropagation && !aBubble)
            aEvent.stopPropagation();
    }
    catch (e) {};
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function clearDocumentSelection()
{
    if (document.selection)
        if (document.selection.clear)
            document.selection.clear();

    if (window.getSelection)
    {
        if (window.getSelection().removeAllRanges)
            window.getSelection().removeAllRanges();
    }
    else
    {
        if (document.getSelection)
            if (document.getSelection().removeAllRanges)
                document.getSelection().removeAllRanges();
    }

    if (document.clearSelection)
        document.clearSelection();
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function centerWindow(wnd)
{
    wnd = $(wnd);

    if (!wnd) return;

    try
    {
        var x = Math.floor((getDocumentDmi().w  - wnd.offsetWidth)  / 2);
        var y = Math.floor((getDocumentDmi().h - wnd.offsetHeight) / 2);

        wnd.style.left = ((x < 0) ? 0 : x) + getDocumentScroll().x + "px";
        wnd.style.top  = ((y < 0) ? 0 : y) + getDocumentScroll().y  + "px";
    }
    catch (e) {}
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function getDocumentDmi()
{
    if (self.innerWidth)
    {
        return {
	        w : self.innerWidth,
	        h : self.innerHeight
        }
    }
    else if (document.documentElement && document.documentElement.clientWidth)
    {
        return {
	        w : document.documentElement.clientWidth,
	        h : document.documentElement.clientHeight
        }
    }
    else if (document.body)
    {
        return {
	        w : document.body.clientWidth,
	        h : document.body.clientHeight
        }
    }

    return { w : 0, h : 0 }
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function getDocumentScroll()
{
    var scrOfX = 0, scrOfY = 0;

    if( typeof( window.pageYOffset ) == 'number' )
    {
        return {
            y : window.pageYOffset,
            x : window.pageXOffset
        }
    }
    else if( document.body && ( document.body.scrollLeft || document.body.scrollTop ) )
    {
        return {
            y : document.body.scrollTop,
            x : document.body.scrollLeft
        }
    }
    else if( document.documentElement && ( document.documentElement.scrollLeft || document.documentElement.scrollTop ) )
    {
        return {
            y : document.documentElement.scrollTop,
            x : document.documentElement.scrollLeft
        }
    }

    return { x : 0, y : 0 }
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function encodeURLParam(param)
{
    if (param === null | isUndefined(param))
        return '';
    return encodeURIComponent(param);
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function getStyleProp(element, property)
{
	var el = $(element), value;

	if (el.currentStyle)
		var value = el.currentStyle[property];
	else if (window.getComputedStyle)
		var value = document.defaultView.getComputedStyle(el, null).getPropertyValue(property);

	return value;
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function htmlSpecialChars(aString)
{
    return (aString + "").replace('&','&amp;').replace('<', '&lt;').replace('>','&gt;');
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function hideElement(el)
{
    var obj = $(el);
    if (!obj) return;
    if (!obj.style) return
    obj.style.display = "none";
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function showElement(el, type)
{
    var obj = $(el);
    if (!obj) return;
    if (!obj.style) return
    obj.style.display = isUndefined(type) ? "block" : type;
}


var __atSign = '(malpa)', __dotSign = "(kropka)";
/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function decodeEmailLink(aElement)
{
    aElement = $(aElement);
    try
    {
        aElement.innerHTML = aElement.innerHTML.replace(new RegExp(regExpEscape(__atSign),'ig'), '@').replace(new RegExp(regExpEscape(__dotSign),'ig'), '.');
        aElement.href = aElement.href.replace(new RegExp(regExpEscape(encodeURIComponent(__atSign)),'ig'), '@').replace(new RegExp(regExpEscape(encodeURIComponent(__dotSign)),'ig'), '.');
    }
    catch (e) {}
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function decodeEmailLinks()
{
    var links = document.body.getElementsByTagName("a");
    try
    {
        for (i in links)
            if (links[i].href && links[i].href.substring(0, 7) == "mailto:")
                decodeEmailLink(links[i]);
    }
    catch (e) {}
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function getObjProperty(aObj, aProperty)
{
    eval("var value = aObj." + aProperty);
    return value;
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function setObjectProperty(aObj, aProperty, aVal)
{
    eval("aObj." + aProperty + " = '" + aVal + "'");
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function regExpEscape(exp)
{
    if (!isString(exp)) return "";
    var specials = ['/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\'];
    var re = new RegExp('(\\' + specials.join('|\\') + ')', 'g');
    return exp.replace(re, '\\$1');
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function getObjFromArrayById(aObjArray, aId)
{
    for (i in aObjArray)
        if (aObjArray[i].id == aId)
            return aObjArray[i];

    return false;
}


/*-------------------------------------------------------------------------------------*/
function setOpacity(aElement, aOpacity)
{
    try
    {
        with ($(aElement))
        {
            style.filter = "alpha(opacity="+(aOpacity * 100)+")";
            style.opacity = aOpacity;
        }
    }
    catch (e) {}
}


/*-------------------------------------------------------------------------------------*/
function getOpacity(aElement)
{
    try {
        var o = toInt($(aElement).style.filter.match(/.*alpha\s*\(opacity\s*\=\s*([0-9]*).*/i)[1]) / 100;
    }
    catch (e) {
        return parseFloat(getStyleProp($(aElement), 'opacity'));
    }

    return o;
}


/*-------------------------------------------------------------------------------------*/
function getWindowInnerHeight()
{
    return window.innerHeight ? window.innerHeight : window.document.documentElement.clientHeight;
}


/*-------------------------------------------------------------------------------------*/
function getWindowInnerWidth()
{
    return window.innerWidth ? window.innerWidth : window.document.documentElement.clientWidth;
}
/*-------------------------------------------------------------------------------------*/
/* Global variables                                                                    */
/*-------------------------------------------------------------------------------------*/

// mouse coordinates
var mousePos = { x: null, y: null };

// global events handlers arrays
var __globalEvents_OnClick      = new Array();
var __globalEvents_OnMouseMove  = new Array();
var __globalEvents_OnMouseUp    = new Array();
var __globalEvents_OnMouseDown  = new Array();
var __globalEvents_OnScroll     = new Array();
var __globalEvents_OnDblClick   = new Array();
var __globalEvents_OnBlur       = new Array();


/*-------------------------------------------------------------------------------------*/
/* Attach global events handlers                                                       */
/*-------------------------------------------------------------------------------------*/

window.document.onmousemove = __globalEvents_onMouseMove
window.document.onmouseup   = __globalEvents_onMouseUp;
window.document.onmousedown = __globalEvents_onMouseDown;
window.document.onclick     = __globalEvents_onClick;
window.onscroll             = __globalEvents_onScroll;
window.document.ondblclick  = __globalEvents_onDblClick;
window.onblur               = __globalEvents_onBlur;


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function globalEvents_RegisterHandler(aName, aEventType, aHandler, aUserData)
{
    aEventType = aEventType.toLowerCase();

    switch (aEventType)
    {
        case 'mousemove':
            __globalEvents_OnMouseMove[aName] = {
                name     : aName,
                handler  : aHandler,
                userData : aUserData
            }
        break;

        case 'mouseup':
            __globalEvents_OnMouseUp[aName] = {
                name     : aName,
                handler  : aHandler,
                userData : aUserData
            }
        break;

        case 'mousedown':
            __globalEvents_OnMouseDown[aName] = {
                name     : aName,
                handler  : aHandler,
                userData : aUserData
            }
        break;

        case 'click':
            __globalEvents_OnClick[aName] = {
                name     : aName,
                handler  : aHandler,
                userData : aUserData
            }
        break;

        case 'scroll':
            __globalEvents_OnScroll[aName] = {
                name     : aName,
                handler  : aHandler,
                userData : aUserData
            }
        break;

        case 'dblclick':
            __globalEvents_OnDblClick[aName] = {
                name     : aName,
                handler  : aHandler,
                userData : aUserData
            }
        break;

        case 'blur':
            __globalEvents_OnDblClick[aName] = {
                name     : aName,
                handler  : aHandler,
                userData : aUserData
            }
        break;

        default: return false;
    }

    return true;
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function globalEvents_UnregisterHandler(aName, aEventType)
{
    aEventType = aEventType.toLowerCase();

    switch (aEventType)
    {
        case 'mousemove':
            return delete __globalEvents_OnMouseMove[aName];
        break;

        case 'mouseup':
            return delete __globalEvents_OnMouseUp[aName];
        break;

        case 'mousedown':
            return delete __globalEvents_OnMouseDown[aName];
        break;

        case 'click':
            return delete __globalEvents_OnClick[aName];
        break;

        case 'scroll':
            return delete __globalEvents_OnClick[aName];
        break;

        case 'dblclick':
            return delete __globalEvents_OnClick[aName];
        break;

        case 'blur':
            return delete __globalEvents_OnClick[aName];
        break;

        default: return false;
    }
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function __globalEvents_onMouseMove(aEvent)
{
	if (!aEvent)
        var aEvent = window.event;

    try
    {
	    if (aEvent.pageX || aEvent.pageY)
	    {
		    mousePos.x = aEvent.pageX;
		    mousePos.y = aEvent.pageY;
	    }
	    else if (aEvent.clientX || aEvent.clientY)
	    {
		    mousePos.x = aEvent.clientX + getDocumentScroll().x;
		    mousePos.y = aEvent.clientY + getDocumentScroll().y;
	    }
    }
    catch (e)
    {
        return;
    }

    bubbleEvent(aEvent, false);
    
    try
    {
        for (handlerId in __globalEvents_OnMouseMove)
            if (__globalEvents_OnMouseMove[handlerId])
                if (isFunction(__globalEvents_OnMouseMove[handlerId].handler))
                    __globalEvents_OnMouseMove[handlerId].handler(aEvent, __globalEvents_OnMouseMove[handlerId].userData);
    }
    catch (e) {}

}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function __globalEvents_onClick(aEvent)
{
    ///trace("[click]");
    bubbleEvent(aEvent, false);
    try
    {
        for (handlerId in __globalEvents_OnClick)
            if (isFunction(__globalEvents_OnClick[handlerId].handler))
                __globalEvents_OnClick[handlerId].handler(aEvent, __globalEvents_OnClick[handlerId].userData);
    }
    catch (e) {}
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function __globalEvents_onMouseUp(aEvent)
{
    //trace("[mouseup]");
    bubbleEvent(aEvent, false);
    try
    {
        for (handlerId in __globalEvents_OnMouseUp)
            if (isFunction(__globalEvents_OnMouseUp[handlerId].handler))
                __globalEvents_OnMouseUp[handlerId].handler(aEvent, __globalEvents_OnMouseUp[handlerId].userData);
    }
    catch (e) {}
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function __globalEvents_onMouseDown(aEvent)
{
    //trace("[mousedown]");
    bubbleEvent(aEvent, false);
    try
    {
        for (handlerId in __globalEvents_OnMouseDown)
            if (isFunction(__globalEvents_OnMouseDown[handlerId].handler))
                __globalEvents_OnMouseDown[handlerId].handler(aEvent, __globalEvents_OnMouseDown[handlerId].userData);
    }
    catch (e) {}
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function __globalEvents_onScroll(aEvent)
{
    ///trace("[onscroll]");
    bubbleEvent(aEvent, false);
    try
    {
        for (handlerId in __globalEvents_OnScroll)
            if (isFunction(__globalEvents_OnScroll[handlerId].handler))
                __globalEvents_OnScroll[handlerId].handler(aEvent, __globalEvents_OnScroll[handlerId].userData);
    }
    catch (e) {}
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function __globalEvents_onDblClick(aEvent)
{
    ///trace("[dblclick]");
    bubbleEvent(aEvent, false);
    try
    {
        for (handlerId in __globalEvents_OnDblClick)
            if (isFunction(__globalEvents_OnDblClick[handlerId].handler))
                __globalEvents_OnDblClick[handlerId].handler(aEvent, __globalEvents_OnDblClick[handlerId].userData);
    }
    catch (e) {}
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function __globalEvents_onBlur(aEvent)
{
    //trace("[onblur]");
    bubbleEvent(aEvent, false);
    try
    {
        for (handlerId in __globalEvents_OnBlur)
            if (isFunction(__globalEvents_OnBlur[handlerId].handler))
                __globalEvents_OnBlur[handlerId].handler(aEvent, __globalEvents_OnBlur[handlerId].userData);
    }
    catch (e) {}
}
/*-------------------------------------------------------------------------------------*/
/* Global variables                                                                    */
/*-------------------------------------------------------------------------------------*/

var __objectsEvents_Handlers = new Array();


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function objectEvents_AttachHandler(aObject, aEventType, aHandler, aUserData, aNoBubble)
{
    if (!isObject(aObject)) return;

    // find or create new object handler
    var oHandler = __objectEvents_getObjectHandler(aObject);

    try
    {
        var objectEvent = null,
            eventTriggers;

        // get object event
        eval("objectEvent = aObject." + aEventType);

        // if this event has no triggers yet, create first one
        if (!isArray(oHandler.triggers[aEventType]))
        {
            // create triggers array for this event
            eventTriggers = oHandler.triggers[aEventType] = [];
            // add a handler
            eventTriggers[eventTriggers.length] = {
                handler  : aHandler,
                userData : aUserData,
                noBubble : aNoBubble
            }
        }
        else
        {
            var eventHandler = __objectEvents_FindEventHandler(oHandler.triggers[aEventType], aHandler);
            if (eventHandler)
            {
                eventHandler.handler  = aHandler;
                eventHandler.userData = aUserData;
                eventhandler.noBubble = aNoBubble;
            }
            else
            {
                eventTriggers = oHandler.triggers[aEventType];
                eventTriggers[eventTriggers.length] = {
                    handler  : aHandler,
                    userData : aUserData,
                    noBubble : aNoBubble
                }
            }
        }

        // attach oryginal object event
        eval("aObject."+aEventType+" = function(aEvent) { return __objectEvents_TriggerObjectEvent(aEvent, '" + oHandler.id + "', '" + aEventType + "'); }");

        return true;
    }
    catch (e)
    {
        return false;
    }
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function objectEvents_DetachHandler(aObject, aEventType)
{
    var oHandler = __objectEvents_getObjectHandler(aObject);
    try
    {
        delete (oHandler.triggers[aEventType]);
    }
    catch (e) {}
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function __objectEvents_FindEventHandler(aTriggers, aHandler)
{
    try
    {
        for (key in aTriggers)
            if (isObject(aTriggers[key]))
                if (aTriggers[key].handler === aHandler)
                    return aTriggers[key];
    }
    catch (e) { return false; }

    return false;
}

/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function __objectEvents_getObjectHandler(aObject)
{
    for (key in __objectsEvents_Handlers)
        if (isObject(__objectsEvents_Handlers[key]))
            if (__objectsEvents_Handlers[key].object === aObject)
                return __objectsEvents_Handlers[key];

    return __objectsEvents_Handlers[__objectsEvents_Handlers.length] = {
        id       : __objectsEvents_Handlers.length,
        object   : aObject,
        triggers : []
    }
}


/*-------------------------------------------------------------------------------------*/
/**
 *
 */
function __objectEvents_TriggerObjectEvent(aEvent, aObjectHandlerId, aEventType)
{
    try
    {
        //trace("["+aEvent+"-"+aObjectHandlerId+"-"+aEventType+"]\n");
        var result = true,
            triggers = __objectsEvents_Handlers[aObjectHandlerId].triggers[aEventType];

        //trace("[looping triggers...]\n");
        for (id in triggers)
        {
            if (isFunction(triggers[id].handler))
            {
                //trace("[running trigger '"+id+"-"+triggers[id].handler+"-"+triggers[id].userData+"']\n");
                result = result && triggers[id].handler(triggers[id].userData);
            }
            bubbleEvent(aEvent, !triggers[id].noBubble);
        }

        return result;
    }
    catch (e) { return result; }
}/**
 * AJAX library
 *
 */

/*-------------------------------------------------------------------------------------*/
/* Global variables                                                                    */
/*-------------------------------------------------------------------------------------*/

var __xhrThreads = [];


/*-------------------------------------------------------------------------------------*/
function xmXHRThread(aAjax)
{
    /*---------------------------------------------------------------------------------*/
    /* Initialization                                                                  */
    /*---------------------------------------------------------------------------------*/

    //trace("Ajax thread: creating xmlhttprequest object...\n");
    this.fXhr = false;

    if(window.XMLHttpRequest) {
        try {
		    this.fXhr = new XMLHttpRequest();
        } catch(e) {
		    this.fXhr = false;
        }

    } else if(window.ActiveXObject) {
        var xhrVersions = new Array(
            'MSXML2.XMLHTTP.6.0',
            'MSXML2.XMLHTTP.5.0',
            'MSXML2.XMLHTTP.4.0',
            'MSXML2.XMLHTTP.3.0',
            'MSXML2.XMLHTTP',
            'Microsoft.XMLHTTP'
        );

        for (var i = 0; i < xhrVersions.length && !this.fXhr; i++)
        {
            try
            {
                this.fXhr = new ActiveXObject(xhrVersions[i]);
            }
            catch (e) {}
        }
    }

	if (!this.fXhr) {
		//alert(__jsMsg["xmajax"]["cannt_create_thread"]);
        return;
	}


    /**
    *
    */
    this.sendRequest = function (aData)
    {
        clearTimeout(this.fTimeoutId);
        this.fTimeoutId = setTimeout(
            "if (isObject(__xhrThreads["+ this.fId +"]) && __xhrThreads["+ this.fId +"].fFree == false)"+
            "__xhrThreads["+ this.fId +"].fAjax._onRequestTimeout(__xhrThreads["+ this.fId +"])", this.fTimeout);
        //alert(this.fData);
        if (isObject(this.fXhr))
            this.fXhr.send(this.fData);
    }


    /**
     *
     */
    this._reset = function ()
    {
        this.fCallback    = null;
        this.fUserData    = null;
        this.fAsynch      = true;
        this.fURL         = "";
        this.fMethod      = "GET";
        this.fHeaders     = [];
        this.fData        = null;
        this.fNoStaticURL = false;
        this.fRunning     = false;
        this.fTimeout     = 60000; // timeout in miliseconds
        this.fFree        = true;

        // attach ready state change event
        this.fXhr.onreadystatechange = new Function (
            "__xhrThreads["+ this.fId +"].fAjax._onReadyStateChange(__xhrThreads["+ this.fId +"])"
        );
    }


    /*---------------------------------------------------------------------------------*/
    /* Properties                                                                      */
    /*---------------------------------------------------------------------------------*/

    this.fId      = aAjax.getNextThreadId();
    this.fAjax    = aAjax;

    this._reset();
}


/*-------------------------------------------------------------------------------------*/
function AJAX()
{
    /*---------------------------------------------------------------------------------*/
    /* Properties                                                                      */
    /*---------------------------------------------------------------------------------*/

    /***** Private *****/
    this.fNextThreadId = 1;

    /***** Public *****/
    this.staticURL = "?ajax=1&";

    this.onBeforeRequestStart = null;
    this.onRequestStart       = null;
    this.onRequestsDone       = null;
    this.onRequestTimeout     = null;


    /*---------------------------------------------------------------------------------*/
    /* Private Methods                                                                 */
    /*---------------------------------------------------------------------------------*/

    /**
     *
     */
    this._createThread = function ()
    {
        //trace("Ajax: creating new thread...\n");
        for (id in __xhrThreads)
        {
            if (isObject(__xhrThreads[id]) && __xhrThreads[id].fFree)
            {
                __xhrThreads[id]._reset();
                __xhrThreads[id].fFree = false;
                return __xhrThreads[id];
            }
        }
        var thread = new xmXHRThread(this);
        return thread;
    }


    /**
     *
     */
    this._destroyThread = function (aThreadId)
    {
        //trace("Ajax: destroying thread #" + aThreadId);
        try
        {
            if (isObject(__xhrThreads[aThreadId]) && isObject(__xhrThreads[aThreadId].fXhr))
            {
                __xhrThreads[aThreadId].fXhr.onreadystatechange = function() {};
                //__xhrThreads[aThreadId].fXhr = null;
            }
        }
        finally
        {
            try
            {
                __xhrThreads[aThreadId].fXhr.abort();
                __xhrThreads[aThreadId]._reset();
                __xhrThreads[aThreadId].fFree = true;
            }
            finally
            {
                if (isFunction(this.onRequestsDone) && this._threadsCount(null, -1, null) == 0)
                    this.onRequestsDone();
            }
        }
    }


    /**
     *
     */
    this._onReadyStateChange = function (aThread)
    {
        if (aThread.fXhr.readyState == 4)
        {
            //trace("Ajax: request completed #" + aThread.fId);
            try
            {   //alert("Receiving "+aThread.fId);
                if (isFunction(aThread.fCallback))
                    aThread.fCallback(aThread);
            }
            finally
            {
                try
                {
                    this._destroyThread(aThread.fId);
                }
                finally
                {
                    //alert("running next synch thread");
                    this._runNextSynchThread();
                }
            }
        }
    }


    /**
     *
     */
    this._onRequestTimeout = function (aThread)
    {
        if (!isObject(aThread)) return;

        //trace("Ajax: request timeout #" + aThread.fId);

        try
        {
            try
            {
                aThread.fXhr.onreadystatechange = function() {};
            }
            finally
            {
                if (isFunction(this.onRequestTimeout))
                    this.onRequestTimeout();
            }
        }
        finally
        {
            this._destroyThread(aThread.fId);
        }
    }


    /**
     *
     */
     this._runNextSynchThread = function ()
     {
        for (key in __xhrThreads)
        {
            if (isObject(__xhrThreads[key]) && isObject(__xhrThreads[key].fXhr) && !__xhrThreads[key].fAsynch)
            {
                //alert(__xhrThreads[key].fAsynch);
                //trace("Ajax: executing next thread...");
                if (this._runThread(key, true))
                    return;
            }
        }
     }


    /**
     *
     */
    this._runThread = function (aThreadId)
    {
        try
        {
            if (__xhrThreads[aThreadId].fRunning)
                return false;

            if (!__xhrThreads[aThreadId].fAsynch && this._threadsCount(null, aThreadId, true) > 0)
                return false;

            var thread = __xhrThreads[aThreadId];

            with (thread)
            {
                if ((isFunction(this.onBeforeRequestStart) && !this.onBeforeRequestStart()) ||
                    (isFunction(this.onRequestStart) && !this.onRequestStart()))
                    {
                        //trace("Ajax: request #"+fId+" aborted from event (onBeforeRequestStart or onRequestStart)");
                        _reset();
                        fFree = true;
                        //delete __xhrThreads[aThreadId];
                        return false;
                    }

                fRunning = true;

                //trace("Ajax: sending request #" + fId + " " + ((fNoStaticURL === true) ? fURL : this.staticURL + fURL));

                var time = (new Date()).getTime();
                fXhr.open(fMethod, ((fNoStaticURL === true) ? fURL : this.staticURL + fURL) + "&" + time, true);

                //fXhr.setRequestHeader('Cookie', '__test__=abugfix');
                //fXhr.setRequestHeader('Cookie', 'xmTermin='+readCookie('xmTermin'));

                for (name in fHeaders) {
                    fXhr.setRequestHeader(name, fHeaders[name]);
                    //alert(name + ": " +fHeaders[name]);
                }

                thread.sendRequest(fData);
                return true;
            }
        }
        catch (e)
        {
            this._destroyThread(aThreadId);
            return true;
        }
    }


    /**
     *
     */
    this._threadsCount = function (aAsynch, aThreadId, aRunning)
    {
        var count = 0;

        for (key in __xhrThreads)
        {
            if (key != aThreadId && isObject(__xhrThreads[key]) && isObject(__xhrThreads[key].fXhr) && __xhrThreads[key].fFree == false
                && ((aAsynch === null) || (aAsynch == __xhrThreads[key].fAsynch))
                && ((aRunning === null) || (aRunning == __xhrThreads[key].fRunning)))
                count++;
        }

        return count;
    }


    /*---------------------------------------------------------------------------------*/
    /* Public Methods                                                                  */
    /*---------------------------------------------------------------------------------*/


    /**
     *
     */
    this.getNextThreadId = function ()
    {
        return this.fNextThreadId++;
    }


    /**
     *
     */
    this.sendRequest = function (aURL, aMethod, aCallback, aUserData, aNoStaticURL, aAsynch, aData, aHeaders)
    {
        if (!isString(aMethod))
            aMethod = "GET";

        //trace("Ajax: preparing input data\n");

        if (aMethod.toUpperCase() != "GET" && aMethod.toUpperCase() != "POST")
            return false;//(trace) ? trace('Invalid request method: ' + aMethod) : false;

        if (isUndefined(aNoStaticURL)) aNoStaticURL = false;
        if (isUndefined(aAsynch)) aAsynch = true;
        if (isUndefined(aData)) aData = null;
        if (!isObject(aHeaders)) aHeaders = [];

        var thread = this._createThread();

        with (thread)
        {
            fMethod      = aMethod;
            fCallback    = aCallback;
            fUserData    = aUserData;
            fAsynch      = aAsynch;
            fURL         = aURL;
            fHeaders     = aHeaders;
            fNoStaticURL = aNoStaticURL;
            fData        = aData;
            fFree        = false;
            // add this thread to global array
            __xhrThreads[fId] = thread;
            this._runThread(fId);
        }

        return true;
    }


    /**
     *
     */
    this.sendForm = function (aFormName, aURL, aMethod, aCallback, aUserData, aNoStaticURL, aAsynch, aHeaders)
    {
        if (!isObject(aHeaders)) aHeaders = [];

        var headers = [],
            postParams = this.getFormDataAsString(aFormName);

        headers["Content-Type"]   = "application/x-www-form-urlencoded";
        headers["Content-length"] = postParams.length;
        headers["Connection"]     = "close";

        for (name in aHeaders)
            headers[name] = aHeaders[name];

        this.sendRequest(aURL, aMethod, aCallback, aUserData, aNoStaticURL, aAsynch, postParams, headers);
    }


    /**
     *
     */
    this.getFormDataAsString = function (aFormName)
    {
        if (!document.forms[aFormName]) return null;

        var qstr = '',
            boxes = [],
            form = document.forms[aFormName];

        for (var i = 0; i < form.length; i++)
        {
            if (form[i].type == 'radio')
            {
                if (form[i].checked)
                    qstr += encodeURIComponent(form[i].name) + '=' + encodeURIComponent(form[i].value) + '&';
                continue;
            }
            if (form[i].type == 'checkbox') {
                boxes[form[i].name] = form[i].checked ? encodeURIComponent(form[i].value) : 0;
                continue;
            }
            qstr += (form[i].name != "") ? encodeURIComponent(form[i].name) + '=' + encodeURIComponent(form[i].value) + '&' : "";
        }

        for (key in boxes)
            if (boxes[key] != null)
                qstr += encodeURIComponent(key) + '=' + encodeURIComponent(boxes[key]) + '&';

        return qstr;
    }


    /**
    */
    this.abortAll = function ()
    {
        for (threadId in __xhrThreads)
            this._destroyThread(threadId);
    }


    /**
    */
    this.attachBeforeRequestStartHandler = function (aName, aHandler, aUserData)
    {
        objectEvents_AttachHandler(this, "onBeforeRequestStart", aHandler, aUserData);
    }


    /**
    */
    this.attachRequestStartHandler = function (aName, aHandler, aUserData)
    {
        objectEvents_AttachHandler(this, "onRequestStart", aHandler, aUserData);
    }


    /**
    */
    this.attachRequestsDoneHandler = function (aName, aHandler, aUserData)
    {
        objectEvents_AttachHandler(this, "onRequestsDone", aHandler, aUserData);
    }


    /**
    */
    this.attachRequestTimeoutHandler = function (aName, aHandler, aUserData)
    {
        objectEvents_AttachHandler(this, "onRequestTimeout", aHandler, aUserData);
    }
}/*****************************************************************************************************/
var __propertyTransformThreads = [];
/*****************************************************************************************************/
function transformProperty(aObj, aProperty, aPattern, aPatternNo, aRepPattern, aStep, aLimit, aInterval, aCallback, aUserData, aSetFunc, aGetFunc)
{
    var thread = false, obj = $(aObj);

    if (!obj) return;

    for (i in __propertyTransformThreads)
    {
        if (__propertyTransformThreads[i]['element'] == aObj)
        {
            clearTimeout(__propertyTransformThreads[i]['timer']);
            thread = __propertyTransformThreads[i];
            break;
        }
    }

    if (!thread)
    {
        thread = [];
        thread['id'] = __propertyTransformThreads.length;
        __propertyTransformThreads.push(thread);
    }

    thread['element'] = obj;
    thread['property'] = aProperty;
    thread['timer'] = 0;
    thread['step'] = aStep;
    thread['limit'] = aLimit;
    thread['interval'] = aInterval;
    thread['callback'] = aCallback;
    thread['userdata'] = aUserData;
    thread['pattern'] = aPattern ? aPattern : "\s*([0-9]+)\s*";
    thread['reppattern'] = aRepPattern ? aRepPattern : "%val%";
    thread['patternno'] = toInt(aPatternNo);
    thread['setfunc'] = aSetFunc;
    thread['getfunc'] = aGetFunc;

    _transformProperty(thread['id']);
}


/*****************************************************************************************************/
function _transformProperty(aId)
{
    var thread = __propertyTransformThreads[aId];

    if (!isArray(thread)) return;

    var obj = $(thread['element']),
        val, setFunc, getFunc;

    setFunc = isFunction(thread['setfunc']) ? thread['setfunc'] : false;
    getFunc = isFunction(thread['getfunc']) ? thread['getfunc'] : false;

    if (getFunc)
        val = getFunc(obj, thread);
    else
    {
        var re = new RegExp(thread['pattern'], "gi");
        val = getObjProperty(obj, thread['property']);
        val = re.exec(val);
        val = val[thread['patternno']];
    }

    if (isNaN(val)) return;

    if (val < thread['limit'])
    {
        if (val + thread['step'] >= thread['limit'])
        {
            if (setFunc)
                 setFunc(obj, thread['limit'], thread);
            else setObjProperty(obj, thread['property'], thread['reppattern'].replace("%val%", thread['limit']));
            if (isFunction(thread['callback']))
                thread['callback'](thread['property'], thread['userdata']);
            return;
        }
        if (setFunc)
             setFunc(obj, val + thread['step'], thread);
        else setObjProperty(obj, thread['property'], thread['reppattern'].replace("%val%", val + thread['step']));
    }
    else
    {
        if (val - thread['step'] <= thread['limit'])
        {
            if (setFunc)
                 setFunc(obj, thread['limit'], thread);
            else setObjProperty(obj, thread['property'], thread['reppattern'].replace("%val%", thread['limit']));
            if (isFunction(thread['callback']))
                thread['callback'](thread['property'], thread['userdata']);
            return;
        }
        if (setFunc)
             setFunc(obj, val - thread['step'], thread);
        else setObjProperty(obj, thread['property'], thread['reppattern'].replace("%val%", val - thread['step']));
    }

    thread['timer'] = setTimeout("_transformProperty("+aId+")", thread['interval']);
}


/*****************************************************************************************************/
var __transformValueThreads = [];
/*****************************************************************************************************/
function transformValue(aThreadName, aValue, aLimit, aStep, aInterval, aCallback, aSetFunc, aUserData)
{
    var thread = false;

    if (isArray(__transformValueThreads[aThreadName]))
    {
        clearTimeout(__transformValueThreads[aThreadName]['timer']);
        thread = __transformValueThreads[aThreadName];
    }
    else
    {
        thread = [];
        __transformValueThreads[aThreadName] = thread;
    }

    thread['stopped'] = false;
    thread['value'] = toInt(aValue);
    thread['timer'] = 0;
    thread['step'] = aStep;
    thread['limit'] = aLimit;
    thread['interval'] = aInterval;
    thread['callback'] = aCallback;
    thread['userdata'] = aUserData;
    thread['setfunc'] = aSetFunc;

    _transformValue(aThreadName);

}


/*****************************************************************************************************/
function _transformValue(aThreadName)
{
    var thread = __transformValueThreads[aThreadName];

    if (!isArray(thread)) return;
    if (!isFunction(thread['setfunc'])) return;

    if (thread['value'] < thread['limit'])
    {
        if ((thread['value'] += thread['step']) >= thread['limit'])
        {
            thread['value'] = thread['limit'];
            thread['setfunc'](thread);
            if (isFunction(thread['callback']))
                _transformValueCallback(aThreadName);
            return;
        }
    }
    else
    {
        if ((thread['value'] -= thread['step']) <= thread['limit'])
        {
            thread['value'] = thread['limit'];
            thread['setfunc'](thread);
            if (isFunction(thread['callback']))
                _transformValueCallback(aThreadName);
            return;
        }
    }

    thread['setfunc'](thread);
    thread['timer'] = setTimeout("_transformValue('"+aThreadName+"')", thread['interval']);
}


/*****************************************************************************************************/
function _transformValueCallback(aThreadName)
{
    try
    {
        __transformValueThreads[aThreadName]['stopped'] = true;
        if (isArray(__transformValueThreads[aThreadName]))
            if (isFunction(__transformValueThreads[aThreadName]['callback']))
                __transformValueThreads[aThreadName]['callback'](__transformValueThreads[aThreadName]);
    }
    finally {
        if (__transformValueThreads[aThreadName]['stopped'])
            delete __transformValueThreads[aThreadName];
    }
}


/*****************************************************************************************************/
function transformElementAlpha(aElement, aStep, aLimit, aInterval, aCallback, aUserData)
{
    transformValue(aElement, getOpacity(aElement), aLimit, aStep, aInterval, aCallback, _transformElementAlphaSetFunc, aElement) ;
}


/*****************************************************************************************************/
function _transformElementAlphaSetFunc(aThread)
{
    setOpacity(aThread['userdata'], aThread['value']);
}var __xmImgPresentationCFG =
{
    _img : false,
    _imgContainer : false,

    _loader: false,
    _loaderContainer: false,

    _info : false,
    _infoContainer : false,

    _caption : false,
    _captionContainer : false,

    _wnd : false,

    _timer : false,

    _windowW : 440,
    _windowH : 620,

    _effects : {
        "fadein-fadeout" : {
            'onload' : _xmImgPresentationOnLoad_FadeIn,
            'onunload' : _xmImgPresentationOnLoad_FadeOut
        },
        "fadein-slideout" : {
            'onload' : _xmImgPresentationOnLoad_FadeIn,
            'onunload' : _xmImgPresentationOnLoad_SlideOut
        },
        "slidein-slideout" : {
            'onload' : _xmImgPresentationOnLoad_SlideIn,
            'onunload' : _xmImgPresentationOnLoad_SlideOut
        },
        "slidein-fadeout" : {
            'onload' : _xmImgPresentationOnLoad_SlideIn,
            'onunload' : _xmImgPresentationOnLoad_FadeOut
        }
    },

    _currentEffect : "",
    _currentEffectOptions : null,

    _defaultEffect : "fadein-fadeout",
    _defaultEffectOptions : 5

};



/*****************************************************************************************************/
function _xmImgPresentationInit()
{
    try
    {
        if (!__xmImgPresentationCFG._wnd || __xmImgPresentationCFG._wnd.parentNode != document.body)
        {
            /** temporary container for template code */
            var container = document.createElement("span");

            with (container) with (__xmImgPresentationCFG)
            {
                innerHTML = __xmTemplates['xm-img-presentation'];

                var elements = [];
                getChildNodesList(container, elements, null, true);

                _wnd = getObjFromArrayById(elements, 'window');
                if (!_wnd) return false;

                _imgContainer = getObjFromArrayById(elements, 'imgContainer');
                if (!_imgContainer) return false;

                if (_infoContainer = getObjFromArrayById(elements, 'infoContainer'))
                    _info = getObjFromArrayById(elements, 'info');

                if (_captionContainer = getObjFromArrayById(elements, 'captionContainer'))
                    _caption = getObjFromArrayById(elements, 'caption');

                if (_loaderContainer = getObjFromArrayById(elements, 'loaderContainer'))
                    _loader = getObjFromArrayById(elements, 'loader');

                _wnd.id = _imgContainer.id = _captionContainer.id = _loaderContainer.id = _infoContainer.id = _caption.id = _loader.id = _info.id = "";

                _wnd.style.display = "none";
                window.document.body.appendChild(_wnd);
            }
        }

        if (!__xmImgPresentationCFG._wnd || __xmImgPresentationCFG._wnd.parentNode != document.body)
            return false;

        return true;
    }
    catch (e) { return false; }
}


/*****************************************************************************************************/
function _xmImgPresentationOnError()
{
    xmImgPresentationHideImage();
}


/*****************************************************************************************************/
function _xmImgPresentationOnAbort()
{
    xmImgPresentationHideImage();
}


/*****************************************************************************************************/
function xmImgPresentationShowImage(aImagePath, aCaption, aEffect, aEffectOptions)
{
    with (__xmImgPresentationCFG)
    {
        if (_img)
            _img.onload = _img.onerror = _img.onabort = null;

        if (!_xmImgPresentationInit())
        {
            alert("Błąd! Nie można zainicjalozować okna prezentacji!");
            return false;
        }

        // ukrywamy wszystko po kolei
        if (_captionContainer) {
            if (_caption)
                _caption.innerHTML = isString(aCaption) ? aCaption : "";
            _captionContainer.style.display = "none";
        }

        if (_infoContainer && _info)
            _infoContainer.style.display = "none";

        _imgContainer.style.display = "none";

        _currentEffect = isArray(_effects[aEffect]) ? aEffect : _defaultEffect;
        _currentEffectOptions = !isUndefined(aEffectOptions) ? aEffectOptions : _defaultEffectOptions;

        // pokazujemy jedynie loadera
        if (_loaderContainer && _loader)
            _loaderContainer.style.display = "";

        // tworzymy obiekt obrazu
        _img = new Image();
        _img.error = _xmImgPresentationOnError;
        _img.onabort = _xmImgPresentationOnAbort;
        _img.onload = _effects[_currentEffect]['onload'];// = _xmImgPresentationOnLoad;

        setOpacity(_wnd, 1);
        _wnd.onclick = _effects[_currentEffect]['onunload'];
        _wnd.style.display = "block";

        centerWindow(_wnd);

        _img.src = aImagePath;
    }

    return true;
}

/*****************************************************************************************************/
function _xmImgPresentationOnLoad_FadeIn()
{
    // na początku okno jest całkowicie przezroczyste
    setOpacity(__xmImgPresentationCFG._wnd, 0);

    // pokazujemy wszystko oprócz loadera
    if (__xmImgPresentationCFG._captionContainer)
        __xmImgPresentationCFG._captionContainer.style.display = "";

    if (__xmImgPresentationCFG._infoContainer && __xmImgPresentationCFG._info)
        __xmImgPresentationCFG._infoContainer.style.display = "";

    __xmImgPresentationCFG._imgContainer.style.display = "";

    // ukrywamy jedynie loadera
    if (__xmImgPresentationCFG._loaderContainer && __xmImgPresentationCFG._loader)
        __xmImgPresentationCFG._loaderContainer.style.display = "none";

    var ratio = Math.min(__xmImgPresentationCFG._windowW / __xmImgPresentationCFG._img.width, __xmImgPresentationCFG._windowH / __xmImgPresentationCFG._img.height);
    __xmImgPresentationCFG._img.width = Math.round(ratio * __xmImgPresentationCFG._img.width);
    __xmImgPresentationCFG._img.height = Math.round(ratio * __xmImgPresentationCFG._img.height);

    __xmImgPresentationCFG._imgContainer.innerHTML = "";
    __xmImgPresentationCFG._imgContainer.appendChild(__xmImgPresentationCFG._img);

    centerWindow(__xmImgPresentationCFG._wnd);

    transformElementAlpha(__xmImgPresentationCFG._wnd   , 0.1, 1, 50);
}


/*****************************************************************************************************/
function _xmImgPresentationOnLoad_SlideIn()
{
    with (__xmImgPresentationCFG)
    {
        // na początku okno jest całkowicie przezroczyste
        setOpacity(_wnd, 0);

        // pokazujemy wszystko oprócz loadera
        if (_captionContainer)
            _captionContainer.style.display = "";

        if (_infoContainer && _info)
            _infoContainer.style.display = "";

        _imgContainer.style.display = "";

        // ukrywamy jedynie loadera
        if (_loaderContainer && _loader)
            _loaderContainer.style.display = "none";

        var ratio = Math.min(_windowW / _img.width, _windowH / _img.height);
        _img.width = Math.round(ratio * _img.width);
        _img.height = Math.round(ratio * _img.height);

        _imgContainer.innerHTML = "";
        _imgContainer.appendChild(_img);

        centerWindow(_wnd);

        if (_currentEffectOptions == 5)
            _currentEffectOptions = Math.ceil(Math.random() * 3);

        var slideCoords = xmImgPresentation_SlideGetCoords();

        if (_currentEffectOptions < 2)
             _wnd.style.top = slideCoords.start;
        else _wnd.style.left = slideCoords.start;

        setOpacity(_wnd, 1);
        transformValue("xmImgPresentationSlideIn", slideCoords.start, slideCoords.stop, 80, 30, null, _xmImgPresentationOnLoad_SlideIn_setPos);
    }
}


/*****************************************************************************************************/
function _xmImgPresentationOnLoad_SlideIn_setPos(aThread)
{
    if (__xmImgPresentationCFG._currentEffectOptions < 2)
         __xmImgPresentationCFG._wnd.style.top = aThread['value'] + "px";
    else __xmImgPresentationCFG._wnd.style.left = aThread['value'] + "px";
}


/*****************************************************************************************************/
function _xmImgPresentationOnLoad_FadeOut()
{
    transformElementAlpha(__xmImgPresentationCFG._wnd, 0.1, 0, 50, xmImgPresentationHideWindow);
}


/*****************************************************************************************************/
function _xmImgPresentationOnLoad_SlideOut()
{
    with (__xmImgPresentationCFG)
    {
        var slideCoords = xmImgPresentation_SlideGetCoords();
        transformValue("xmImgPresentationSlideIn", slideCoords.stop, slideCoords.start, 120, 30, xmImgPresentationHideWindow, _xmImgPresentationOnLoad_SlideIn_setPos);
    }
}

/*****************************************************************************************************/
function xmImgPresentation_SlideGetCoords()
{
    with (__xmImgPresentationCFG)
    {
        if (_currentEffectOptions == 5)
            _currentEffectOptions = Math.ceil(Math.random() * 3);

        var slideTo = toInt((_currentEffectOptions < 2) ? _wnd.style.top : _wnd.style.left);

        var inH = getWindowInnerHeight(), inW = getWindowInnerWidth(), slideFrom;

        switch (_currentEffectOptions)
        {
            case  3: slideFrom = getWindowInnerWidth() + toInt(_wnd.offsetWidth); break;
            case  2: slideFrom = - toInt(_wnd.offsetWidth); break;
            case  1: slideFrom = getWindowInnerHeight() + toInt(_wnd.offsetHeight); break;
            default: slideFrom = - toInt(_wnd.offsetHeight);
        }
    }

    return {start : slideFrom, stop : slideTo};
}


/*****************************************************************************************************/
function xmImgPresentationHideWindow()
{
   __xmImgPresentationCFG._wnd.style.display = "none";
}var __ajax = new AJAX(),
    _currentPageContent = "",
    _ready = false,
    _module = '';

var map = null;
var geocoder = null;

function loadPage(module)
{
    _ready = false;
    _module = module;
    __ajax.sendRequest('mod=' + module, 'GET', onPageContentReceived);
    transformValue("content-slide", 0, -550, 50, 40, onHideContentComplete, setContentPos);
}


function onPageContentReceived(xhrThread)
{
    _currentPageContent = xhrThread.fXhr.responseText;
    if (_ready)
         setPageContent();
    else _ready = true;
}


function hideContent()
{
    transformValue("content-slide", 0, -550, 50, 40, showContent, setContentPos);
}


function onHideContentComplete()
{
    if (_ready)
         setPageContent();
    else _ready = true;
}


function setPageContent()
{
    $("page-content").innerHTML = _currentPageContent;

    if (_module == 'kontakt&a=mapa')
    {
        loadGMap();
    }

    decodeEmailLinks();
    setTimeout('transformValue("content-slide", -550, 0, 50, 40, null, setContentPos)', 500);
}


function loadGMap()
{
    if (GBrowserIsCompatible())
    {
        map = new GMap2(document.getElementById("map"));
        geocoder = new GClientGeocoder();
        map.enableScrollWheelZoom();
        map.enableContinuousZoom();
        map.addControl(new GLargeMapControl());
        //map.addControl(new GMapTypeControl(), new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(10, 10)));
        map.setCenter(point = new GLatLng(51.078440773938155, 19.415245056152344), 13);

        GMap2.prototype.wheelZoom = function(event)
          {
              if(event.cancelable)    event.preventDefault();
              return false;
          }
        GEvent.addDomListener(document.getElementById("map"), "DOMMouseScroll", map.wheelZoom);
        GEvent.addDomListener(document.getElementById("map"), "mousewheel", map.wheelZoom);

        var marker = new GMarker(point);
        map.addOverlay(marker);
        marker.openInfoWindowHtml(document.getElementById("kontakt").innerHTML);
        GEvent.addListener(map, "click", function(marker, point) { if (marker && marker.openInfoWindowHtml) marker.openInfoWindowHtml(document.getElementById("kontakt").innerHTML); });
        //showAddress('Radomsko  Rolna 31 Poland', '97-500 Radomsko, ul. Rolna 16<br />e-mail: grafix@hot.pl<br />telefon 44 685 11 85');
    }
}


function setContentPos(aThread)
{
    $("content-container").style.left = toInt(aThread['value']) + "px";
}

function checkContactForm()
{
    var f = $('contact-form');
    try {
        if (!/^\s*[a-z0-9]+[\w\-\.]*@([\w\-]+\.)+[a-z]+\s*$/.test(f.email_replyto.value))
        {
            alert("Proszę wpisać poprawny adres e-mail.");
            return false;
        }
        if (f.email_subject.value == '' || f.email_sender.value == '' || f.email_replyto.value == '' || f.email_msg.value == '')
        {
            alert("Wszystkie pola są wymagane. Proszę uzupełnić formularz i spróbować ponownie.");
            return false;
        }
    }
    catch (e) {}

    return true;
}


function sendContactForm()
{
    _ready = false;
    _module = "kontakt";
    __ajax.sendForm("contact-form", "mod=kontakt&a=sendemail", "POST", onPageContentReceived);
    transformValue("content-slide", 0, -550, 50, 40, onHideContentComplete, setContentPos);
}
__xmTemplates = [];

__xmTemplates['xm-img-presentation'] = "<div id=\"window\" class=\"xm-img-presentation-window\">"+
"    <div id=\"loaderContainer\" class=\"xm-img-presentation-loader\"><span id=\"loader\">Ładuję obraz...</span></div>"+
"    <div id=\"imgContainer\" class=\"xm-img-presentation-img\"></div>"+
"    <div id=\"captionContainer\" class=\"xm-img-presentation-caption\"><span id=\"caption\"></span></div>"+
"    <div id=\"infoContainer\" class=\"xm-img-presentation-info\"><span id=\"info\">Kliknij w okienko aby je zamknąć</span></div>"+
"</div>";