/// <reference path="jquery-1.3.2.js" />

/*
verze 0.5.1
nova struktura dat predavanych pomoci ajax ze serveru:
=================================================
[{id:"IdElementu1", attr: "NazevAtributu", val: "Hodnota"},
{id:"IdElementu2", attr: "NazevAtributu", val: "Hodnota"}
]

stara struktura dat predavanych pomoci ajax ze serveru:
=================================================
{IdElementu1:{attr: "NazevAtributu", 
val: "Hodnota"
},
IdElementu2:{attr: "NazevAtributu",
val: "Hodnota"
}
}
kde:
IdElementuX - jednotliva id elementu, ktere maji byt meneny
attr - nazev meneneho atributu (src, title..) 
Muze byt tez: 
"text" (innerText),  
"html" (innerHtml)
"function" spusti zadanou funkci
"event" vyvola udalost elementu (click, focuc, submit..)
val - hodnota, na kterou bude atribut nastaven

Zvlastni postaveni ma mentor.CONST.ID_QUEST: Po nacteni jsou na nej pousteny jeste dalsi akce ohledne dalsiho zpracovani.
*/
var vkAjax = {
    CONST: {
        CLASS_EXTERNAL_LINK: "external"
        ///	<summary>
        ///		linky, ktere maji odkazovat mimo tento dialog msusi mit tento class
        ///	</summary>
    },
    GLOBAL: {
        //        idDialog: ""
        //        ///	<summary>
        //        ///		tento div slouzi k vytvoreni dialogu (okna)
        //        ///	</summary>
        //		,
        url: ""
        ///	<summary>
        ///		adresa sluzby. ze ktere taham data
        ///	</summary>
		,
        showAjaxErrors: false
        ///	<summary>
        ///		maji-li se zobrazit chybova hlaseni Ajaxu
        ///	</summary>
		,
        sendAjaxErrToServer: true
        ///	<summary>
        ///		ma-li se chyba odeslat na server
        ///	</summary>
		,
        recieveAjaxErrFromServer: false
        ///	<summary>
        ///		ma-li se zpracovat odpoved ze serveru 
        ///	</summary>
		,
        ajaxErrService: "logWriter.aspx"
        ///	<summary>
        ///		adresa, kam posilat chyby ajaxu 
        ///	</summary>
    },
    AjaxRequest: function (data, CallBackFunction, params) {
        ///	<summary>
        ///		odeslani AJAX pozadavku na adresu vkAjax.GLOBAL.url	 a výsledek předá CallBackFunction
        ///	</summary>
        ///	<param name="data" type="object">
        ///		data predavana serveru
        ///		ve tvaru klic:hodnota
        ///		napr: {q:"new", udaj:3}
        ///	</param>
        ///	<param name="CallBackFunction" type="function">
        ///		Funkce, ktera bude spustena po nacteni dat. Jako parametr dostane prijata data prevedena do objektu JS
        ///	</param>
        ///	<param name="params" type="object">
        ///		data, ktera budou predana callBack funkci
        ///	</param>
        ///	<returns type="JSON" />
        $(document).unbind("ajaxError");

        $(document).ajaxError(function (event, request, settings) {
            vkAjax.GLOBAL.errText = request.responseText;
            vkAjax.GLOBAL.errPage = settings.url;
            if (vkAjax.GLOBAL.sendAjaxErrToServer) {
                var callBack = vkAjax.GLOBAL.recieveAjaxErrFromServer ? function (ansver) { vkAjax.GLOBAL.errAnsver = ansver } : null;
                $(document).unbind("ajaxError");
                jQuery.post(vkAjax.GLOBAL.ajaxErrService, { err_url: settings.url, text: request.responseText, browser: navigator.userAgent }, callBack, "text");

            }
            if (vkAjax.GLOBAL.showAjaxErrors) {
                alert("Doslo k chybe, ohlaste to spravci hry.\n" +
				"URL: " + vkAjax.GLOBAL.errPage + "\n" +
				"Text: " + vkAjax.GLOBAL.errText);
            }
        });
        $.post(vkAjax.GLOBAL.url, data, function (json) { CallBackFunction(json, params); }, "json");
    },

    ProcessQuest: function (json) {
        ///	<summary>
        ///		Data preda zadanym elementum a na vkAjax.CONST.ID_QUEST spusti dalsi akce
        ///	</summary>
        ///	<param name="json" type="JSON">
        ///		data ve strukture uvedene na zacatku tohoto souboru
        ///	</param>
        //zastaveni spousteni loaderu
        clearTimeout(vkDialog.global.loaderTimeout);

        //zpracovani zaslanych dat
        for (key in json) {
            if (!$.isArray(json)) {	//puvodni format dat
                switch (json[key].attr) {
                    case "html":
                        $("#" + key).html(json[key].val);
                        break;
                    case "text":
                        $("#" + key).text(json[key].val);
                        break;
                    case "function":
                        //						eval("(" + json[key].val + ")");
                        eval(json[key].val);
                        break;
                    case "event":
                        $("#" + key).trigger(json[key].val);
                        break;
                    default:
                        $("#" + key).attr(json[key].attr, json[key].val);
                }
                if (vkDialog.global.activeDialogs[key]) vkAjax.ProcessQuestSetUp(key);
            } else {	//novy format dat
                switch (json[key].attr) {
                    case "html":
                        $("#" + json[key].id).html(json[key].val);
                        break;
                    case "text":
                        $("#" + json[key].id).text(json[key].val);
                        break;
                    case "function":
                        //					    eval("(" + json[key].val + ")");
                        eval(json[key].val);    //pokus o upravu, aby eval nehazel chyby puvodni verze se zavorkami vychazela z pozadavku na parsovani JSON. 1.1.10
                        break;
                    case "event":
                        $("#" + json[key].id).trigger(json[key].val);
                        break;
                    default:
                        $("#" + json[key].id).attr(json[key].attr, json[key].val);
                }
                if (vkDialog.global.activeDialogs[json[key].id]) vkAjax.ProcessQuestSetUp(json[key].id);

            }
        }
    },

    ProcessQuestSetUp: function (idDialog) {
        ///	<summary>
        ///		Nastavi udalosti pro specificke elementy v vkAjax.CONST.idDialog
        ///		pro <a class=vkAjax.CONST.CLASS_EXTERNAL_LINK> ponecha standardni akci, jinak pozadavky pres json
        ///	</summary>
        //puvodni zmeneno 15.10.09
        $("a:not(." + vkAjax.CONST.CLASS_EXTERNAL_LINK + ")", "#" + idDialog).click(function () { vkAjax.SubmitAnswer(this); return false; });
        //        $("input[type='button'],input[type='image']", "#" + idDialog).click(function () { vkAjax.SubmitAnswer(this); return false; });
        $("input[type='button']:not(." + vkAjax.CONST.CLASS_EXTERNAL_LINK + "),input[type='image']:not(." + vkAjax.CONST.CLASS_EXTERNAL_LINK + ")", "#" + idDialog)
            .click(function () { vkAjax.SubmitAnswer(this); return false; });
        //        $("input", "#" + idDialog).click(function () { });
    },

    SubmitAnswer: function (sender) {
        ///	<summary>
        ///		odesle odpoved na ukol
        ///     predtim nastavi url pro odeslani
        ///	</summary>
        ///	<param name="sender" type="htmlElementButton|string">
        ///		Button na ktery bylo klepnuto
        ///		idElementu, na ktery bylo klepnuto nebo celeho dialogu
        ///	</param>
        var pomSender = (typeof sender == "string") ? document.getElementById(sender) : sender;
        if (vkDialog.global.activeDialogs[vkAjax._GetIdDialog(pomSender)]) {
            vkAjax.GLOBAL.url = vkDialog.global.activeDialogs[vkAjax._GetIdDialog(pomSender)].options.url;
            vkAjax.AjaxRequest(vkAjax.GenerateAnsverData(pomSender), function (json) { vkAjax.ProcessQuest(json); });
        }
    },

    _GetIdDialog: function (htmlElement) {
        ///	<summary>
        ///		najde id dialogu, ke kteremu prislusi zadany element
        ///     Pokud nenajde prislusny dialog, vrati prazdny retezec
        ///	</summary>
        ///	<param name="sender" type="htmlElement">
        ///		html element, ktery je soucasti dialogu
        ///	</param>
        ///	<returns type="string">
        ///		id dialogu, pokud jej najde, jinakvrati ""
        ///	</returns>
        ///<remarks>
        ///     vyzaduje spravne nastaveny vkDialog.global.activeDialogs
        ///</remarks>

        if (htmlElement == null || htmlElement.nodeName.toUpperCase() == "BODY") return "";
        if (vkDialog.global.activeDialogs[htmlElement.id]) return htmlElement.id;
        return vkAjax._GetIdDialog(htmlElement.parentNode);

    },

    GenerateAnsverData: function (sender) {
        ///	<summary>
        ///		ziska data odpovedi z inputu a vztvori z nich objekt pro odeslani AJAXem
        ///	</summary>
        ///	<param name="sender" type="htmlElementButton">
        ///		Button nebo link na ktery bylo klepnuto
        ///	</param>
        ///	<returns type="object">
        ///		struktura: {idInputu:value,..}
        ///     u beznych elementu <input>, <textarea> bere hodnotu z atributu value
        ///     u elementu checkbox, radio bere jen ty, ktere jsou zaskrtnute
        ///     u elementu <select> bere jen ty, ktere jsou vybrane
        ///     u elementu <a> bere hodnotu z atributu href a vlozi jen to, co je za poslednim "/"
        ///     u elementu <button> bere hodnotu z atributu name
        /// </returns>
        var returnedObject = {};
        $("input[TYPE='text'],input[TYPE='password'],textarea", "#" + vkAjax._GetIdDialog(sender)).each(function () {
            returnedObject[this.id] = this.value;
        });
        $("input[TYPE='checkbox'],input[TYPE='radio']", "#" + vkAjax._GetIdDialog(sender)).each(function () {
            if (this.checked) {
                returnedObject[this.id] = this.value;
            }
        });
        $("select", "#" + vkAjax._GetIdDialog(sender)).each(function () {
            if (this.selectedIndex >= 0) {
                returnedObject[this.id] = $(this).val();
            }
        });
        if (sender != null) {
            if (sender.nodeName.toLowerCase() == "a") {
                returnedObject[sender.id] = sender.href.substring(sender.href.lastIndexOf("/") + 1, 999);
            } else if (sender.nodeName.toLowerCase() == "input" && sender.type.toLowerCase() == "button") {
                returnedObject[sender.id] = sender.name;
            } else {
                returnedObject[sender.id] = sender.value;
            }
        }
        return returnedObject;
    },

    RefreshAjax: function () {
        ///	<summary>
        ///		Aktualizace dat ze serveru
        ///	</summary>
        vkAjax.AjaxRequest({}, function (json) { vkAjax.ProcessQuest(json); });
    }


};
var vkDialog = {
    CONST: {
        LOADER_TIMEOUT: 1000
        ///	<summary>
        ///		cas, za jaky se zobrazi obr pro prubeh stahovani
        ///	</summary>
		,
        LOADER_CLASS: "vk-loader"
        ///	<summary>
        ///		css class pridelena obrazku loaderu
        ///	</summary>
    },
    global: {
        loaderTimeout: null
        ///	<summary>
        ///		pro zastaveni timeoutu jeho id
        ///	</summary>
        ,
        activeDialogs: new Object
        ///	<summary>
        ///		objekt pro seznam dialogu
        ///	</summary>
    },

    create: function (idDialog) {
        ///	<summary>
        ///		Zobrazi dialog a nacte do nej data AJAXem
        ///	</summary>
        ///	<param name="idDialog" type="string/object">
        ///		1. ID elementu div, ze ktereho bude dialog vytvoren
        ///         parametry pro dialog hleda v elementu s id= "vk-"+idDialog
        ///     2. Objekt parametru: {nazev:hodnota, nazev2:hodnota2..}
        ///        jednotlive parametry:
        ///         id - ID elementu div, ze ktereho bude dialog vytvoren
        ///         url - adresa, ze ktere bude tahan AJAX obsah
        ///         clearContent - vymaza obsah dialogu pred zobrazenim
        ///         loaderImg - url obrazku, ktery bude zobrazen pri nacitani AJAX obsahu
        ///         withoutCallUrl - je-li true, AJAX se nepousti ihned po zobrazeni dialogu, ale az po akci uzivatele
        ///         htmlText - html, ktere bude vlozeno do dialogu
        ///			group - rozdeleni oken do skupin. kazda skupina se ohledne zavirani oken chova autonomne. Okna bez zadane skupiny se chovaji jako jedna skupina
        ///			multipeDialogs - je-li true, tak nezavre drive otevrena okna  stejne skupiny
        ///         ui_* - vsechny parametry zacinajici ui jsou predany jako parametry pro uiDialog
        ///	</param>
        /// <remarks>
        ///     Jestlize v dokumentu neexistuje element s id=idDialog, tak vytvori odpovidajici div
        /// </remarks>
        var options = vkDialog._GetOptions(idDialog);

        if ($("#" + options.id).length < 1) $("<div id='" + options.id + "'></div>").appendTo("body");  //neexistuje/li element, tak jej vytvorim
        if (!options.multipeDialogs) { //zruseni predchoziho okna
            vkDialog.hideGroup(options.group);
        }

        if (options.clearContent && (typeof options.clearContent == "boolean" || options.clearContent.toLocaleLowerCase() == "true")) {	//vymazani obsahu okna
            utility.clearDialog(options.id);
        }

        if (options.htmlText) $("#" + options.id).html(options.htmlText); // set html text (must be called after display window)

        var dialogOptionsDisplayNone = vkDialog.DialogOptions(idDialog);
        dialogOptionsDisplayNone.autoOpen = false;
        $("#" + options.id).dialog(dialogOptionsDisplayNone) //zobrazeni okna
        .bind('dialogbeforeclose', function (event, ui) {	//osetreni skryti dialogu
            vkDialog.global.activeDialogs[event.target.id].active = false;
        });
        //        $("#" + options.id).dialog(dialogOptionsDisplayNone).dialog('open') //zobrazeni okna
        //        .bind('dialogbeforeclose', function (event, ui) {	//osetreni skryti dialogu
        //            vkDialog.global.activeDialogs[event.target.id].active = false;
        //        });

        if (!vkDialog.global.activeDialogs[options.id]) vkDialog.global.activeDialogs[options.id] = {};
        vkDialog.global.activeDialogs[options.id].active = false;
        if (!vkDialog.global.activeDialogs[options.id].options) vkDialog.global.activeDialogs[options.id].options = {};
        for (var i in options) {
            vkDialog.global.activeDialogs[options.id].options[i] = options[i];
        }
    },

    show: function (idDialog) {
        ///	<summary>
        ///		Zobrazi dialog a nacte do nej data AJAXem
        ///	</summary>
        ///	<param name="idDialog" type="string/object">
        ///		1. ID elementu div, ze ktereho bude dialog vytvoren
        ///         parametry pro dialog hleda v elementu s id= "vk-"+idDialog
        ///     2. Objekt parametru: {nazev:hodnota, nazev2:hodnota2..}
        ///        jednotlive parametry:
        ///         id - ID elementu div, ze ktereho bude dialog vytvoren
        ///         url - adresa, ze ktere bude tahan AJAX obsah
        ///         clearContent - vymaza obsah dialogu pred zobrazenim
        ///         loaderImg - url obrazku, ktery bude zobrazen pri nacitani AJAX obsahu
        ///         withoutCallUrl - je-li true, AJAX se nepousti ihned po zobrazeni dialogu, ale az po akci uzivatele
        ///         htmlText - html, ktere bude vlozeno do dialogu
        ///			group - rozdeleni oken do skupin. kazda skupina se ohledne zavirani oken chova autonomne. Okna bez zadane skupiny se chovaji jako jedna skupina
        ///			multipeDialogs - je-li true, tak nezavre drive otevrena okna  stejne skupiny
        ///         relPosition - id elementu, ke kteremu je dialog relativne pozicovan
        ///             relLeft - posun doleva (muze byt i zaporna hodnota, default 0)
        ///             relTop - posun dolu (muze byt i zaporna hodnota, default 0)
        ///         ui_* - vsechny parametry zacinajici ui jsou predany jako parametry pro uiDialog
        ///	</param>
        /// <remarks>
        ///     Jestlize v dokumentu neexistuje element s id=idDialog, tak vytvori odpovidajici div
        /// </remarks>
        vkDialog.create(idDialog);
        var options = vkDialog.global.activeDialogs[vkDialog._GetOptions(idDialog).id].options;
        $("#" + options.id).dialog('open')
        vkDialog.global.activeDialogs[options.id].active = true;

        //vynuceni nastaveni vlastnosti dialogu, pokud jiz bylo vytvoreno drive
        var pomDialogOptions = vkDialog.DialogOptions(idDialog);
        if (pomDialogOptions.height) vkDialog._setHeight(options.id, pomDialogOptions.height); //oprava chyby v ui_dialog
        for (var i in pomDialogOptions) {
            $("#" + options.id).dialog("option", i, pomDialogOptions[i]);
        }

        if (options.url) {	//spusteni ajax pozadavku
            if (options.loaderImg) {	//spusteni loader obrazku
                clearTimeout(vkDialog.global.loaderTimeout);
                vkDialog.global.loaderTimeout = setTimeout(function () {
                    $("#" + options.id).html("<img src='" + options.loaderImg
					+ "' class='" + vkDialog.CONST.LOADER_CLASS + "' alt=''/>");
                }, vkDialog.CONST.LOADER_TIMEOUT);
            }
            vkAjax.GLOBAL.url = options.url;
            if (!options.withoutCallUrl) {
                vkAjax.RefreshAjax();
            } else {
                vkAjax.ProcessQuestSetUp(options.id);
            }
        }
    },

    _setHeight: function (idDialog, height) {
        ///	<summary>
        ///   nastavi vysku dialogu a napravi chybu ui_dialog
        ///	</summary>
        ///	<param name="idDialog" type="string">
        ///		ID dialogu, jehos vyska je nastavovana
        ///	</param>
        ///	<param name="height" type="integer">
        ///		vyska dialogu v px
        ///	</param> 
        var deltaHeight = $($("#" + idDialog)[0].parentNode).height() - $("#" + idDialog).height();
        $("#" + idDialog).dialog("option", "height", height);
        $("#" + idDialog).height(height - deltaHeight);
    },

    showWithoutCallUrl: function (idDialog, htmlText) {
        ///	<summary>
        ///   Zpracuje tlacitka (a dalsi aktivni prvky) html textu a zobrazi je v okne. Nevola loader. Nevola url pri nacteni obsahu okna. Vk-clearContent muze mit smysl pouzivat, pouze pokud je htmlText = "".
        ///	</summary>
        ///	<param name="idDialog" type="string">
        ///		ID elementu div, ze ktereho bude dialog vytvoren
        ///	</param>
        ///	<param name="htmlText" type="string">
        ///		html, kterym bude dialog naplnen bez toho, aby nacital data ze serveru
        ///	</param>

        if (htmlText != null && htmlText.length > 0) vkDialog.SetParam(idDialog, "vk-htmlText", htmlText); // set html text (must be called after display window)
        vkDialog.SetParam(idDialog, "vk-withoutCallUrl", true);
        vkDialog.show(idDialog); //zobrazeni okna
    },

    hideGroup: function (group) {
        ///	<summary>
        ///   skryje skupinu dialogu
        ///	</summary>
        ///	<param name="group" type="string">
        ///		nazev skupiny dialogu, ktere maji byt skryty soucasne
        ///	</param>
        for (var i in vkDialog.global.activeDialogs) {
            if (vkDialog.global.activeDialogs[i].options.group == group) {
                vkDialog.hide(i);
            }
        }
    },

    hide: function (idDialog) {
        ///	<summary>
        ///   skryje dialog
        ///	</summary>
        ///	<param name="idDialog" type="string">
        ///		ID elementu div, ze ktereho bude dialog vytvoren
        ///	</param>
        $("#" + idDialog).html("").dialog('close');
        //$("#" + idDialog).dialog('close');

    },

    _GetOptions: function (idDialogOrObject) {
        ///	<summary>
        ///		ziska parametry dialogu
        ///	</summary>
        ///	<param name="idDialogOrObject" type="string/object">
        ///		ID elementu div, ze ktereho bude dialog vytvoren nebo objekt parametru
        ///	</param>
        if (typeof idDialogOrObject == "string") {
            var options = {};
            options.id = idDialogOrObject;
            var regEx = /vk\-(\w+)/;
            $("span", $("#vk-" + idDialogOrObject)).each(function () {
                var myArray = regEx.exec($(this).attr("class"));
                if (myArray.length > 1) {
                    if (myArray[1].indexOf("htmlText") >= 0) {
                        options[myArray[1]] = $(this).html();
                    } else if (myArray[1].indexOf("clearContent") >= 0 || myArray[1].indexOf("withoutCallUrl") >= 0) {
                        options[myArray[1]] = ($(this).text() == "1" || $(this).text() == "true") ? true : false;
                    } else {
                        options[myArray[1]] = $(this).text();
                    }
                }
            });
            return options;
        } else {
            return idDialogOrObject;
        }
    },

    DialogOptions: function (idDialog) {
        ///	<summary>
        ///		ziska vsechny property zacinajici na "ui-" z elementu s ID idDialog a vytvori z nich objekt
        ///	</summary>
        ///	<param name="idDialog" type="string/object">
        ///		1. ID elementu div, ze ktereho bude dialog vytvoren
        ///     2. objekt parametru
        ///	</param>
        ///	<returns type="object">
        ///		struktura: {optionName:value,..} z optionName odstrani "ui-"
        /// </returns>
        var ansver = {};

        if (typeof idDialog == "string") {
            $("span[class^=vk-ui-]", $("#vk-" + idDialog)).each(function () {
                var pomValue = $(this).text();
                if (!isNaN($(this).text())) {
                    pomValue = Number($(this).text());
                }
                ansver[$(this).attr("class").substr(6, 999)] = pomValue;
            });
            $("span[class=vk-relPosition]", $("#vk-" + idDialog)).each(function () {
                //				var pos = vkDialog.AbsPosition($("#" + $(this).text())); //pozice elementu, ke kteremu chci dialog zarovnat
                //				ansver["position"] = [(pos.left + Number($("span[class=vk-relLeft]", $("#vk-" + idDialog)).text())) - $("html").scrollLeft(),
                //				pos.top + Number($("span[class=vk-relTop]", $("#vk-" + idDialog)).text()) - $("html").scrollTop()];
                ansver["position"] = vkDialog._Position($(this).text(), $("span[class=vk-relLeft]", $("#vk-" + idDialog)).text(),
										$("span[class=vk-relTop]", $("#vk-" + idDialog)).text());
            });
        } else {
            for (var i in idDialog) {
                if (i.substring(0, 3) == "ui_") ansver[i.substring(3, 999)] = idDialog[i];
            }
            if (idDialog["relPosition"]) {
                //				var pos = vkDialog.AbsPosition($("#" + idDialog["relPosition"])); //pozice elementu, ke kteremu chci dialog zarovnat
                //				ansver["position"] = [(pos.left + Number(idDialog["relLeft"])) - $("html").scrollLeft(),
                //				pos.top + Number(idDialog["relTop"]) - $("html").scrollTop()];
                ansver["position"] = vkDialog._Position(idDialog["relPosition"], idDialog["relLeft"], idDialog["relTop"]);
            }
        }
        return ansver;
    },

    _Position: function (relPosition, relLeft, relTop) {
        ///	<summary>
        ///		vytvori objekt pro pozici dialogu
        ///	</summary>
        ///	<param name="relPosition" type="string">
        ///		id elementu, vuci kteremu se bude dialog pozicovat
        ///	</param>
        ///	<param name="relLeft" type="number/string">
        ///		vodorovny posun vuci elementu v px
        ///	</param>
        ///	<param name="relTop" type="number/string">
        ///		svisly posun vuci elementu v px
        ///	</param>
        ///	<returns type="array">
        ///		[0] - left pozice
        ///		[1] - top pozice
        /// </returns>
        var pos = vkDialog.AbsPosition($("#" + relPosition)); //pozice elementu, ke kteremu chci dialog zarovnat
        return [(pos.left + Number(relLeft ? relLeft : 0)) - $("html").scrollLeft() - $("body").scrollLeft(),
				pos.top + Number(relTop ? relTop : 0) - $("html").scrollTop() - $("body").scrollTop()];
        //		return [(pos.left + Number(idDialog["relLeft"])) - $("html").scrollLeft(),
        //				pos.top + Number(idDialog["relTop"]) - $("html").scrollTop()];
    },

    AbsPosition: function (jQueryElement) {
        ///	<summary>
        ///		spocte absolutni pozici elementu na strance
        ///	</summary>
        ///	<param name="jQueryElement" type="jQuery">
        ///		element vybrany pomoci jQuery, jehoz polohu pocita
        ///	</param>
        ///	<returns type="object">
        ///		struktura: {left:num, top:num}
        /// </returns>
        if (jQueryElement.offsetParent().length > 0 && jQueryElement[0].nodeName.toUpperCase() != "BODY" && jQueryElement[0].nodeName.toUpperCase() != "HTML") {
            var pos = jQueryElement.position();
            var pomPos = vkDialog.AbsPosition(jQueryElement.offsetParent());
            pos.top += pomPos.top;
            pos.left += pomPos.left;
            return pos;
        }
        return { left: 0, top: 0 };
    },

    GetParam: function (idDialog, param) {
        ///	<summary>
        ///		precte parametr pro zobrazeni okna
        ///	</summary>
        ///	<param name="idDialog" type="string">
        ///		id elementu, ze ktereho bude dialog vytvaren.
        ///	</param>
        ///	<param name="param" type="string">
        ///		nazev parametru, ktery bude nastaven
        ///	</param>
        ///	<returns type="string">
        ///		hodnota parametru, nenajde/li parametr vraci prazdny retezec
        /// </returns>
        ///<remarks>
        ///	predpokladam, ze existuje DIV s id="vk-idDialog"
        ///</remarks>
        //        if ($("#" + idDialog).dialog('isOpen')) {
        if (vkDialog._isCreated(idDialog)) {
            if (param.indexOf("ui-") >= 0) {
                return $("#" + idDialog).dialog('option', param.substring(param.indexOf("ui-") + 3, 999));
            } else {
                return vkDialog.global.activeDialogs[idDialog].options[(param.indexOf("vk-") >= 0 ? param.substring(param.indexOf("vk-") + 3, 999) : param)];
            }
        } else {
            return $("span[class=" + param + "]", $("#vk-" + idDialog)).html() == null ? "" :
                ((param.indexOf("htmlText") >= 0) ?
                    $("span[class=" + param + "]", $("#vk-" + idDialog)).html() :
                    $("span[class=" + param + "]", $("#vk-" + idDialog)).text()
                )
        }
    },

    SetParam: function (idDialog, param, value) {
        ///	<summary>
        ///		nastavi parametr pro zobrazeni okna
        ///		v pripade, ze je dialog zobrazeny, nastavi primo vlastnost dialogu
        ///	</summary>
        ///	<param name="idDialog" type="string">
        ///		id elementu, ze ktereho bude dialog vytvaren.
        ///	</param>
        ///	<param name="param" type="string">
        ///		nazev parametru, ktery bude nastaven
        ///	</param>
        ///	<param name="value" type="object">
        ///		Hodnota, na kterou je paremetr nastaven.
        ///	</param>
        ///<remarks>
        ///	predpokladam, ze existuje DIV s id="vk-idDialog"
        ///</remarks>
        //        if ($("span[class=" + param + "]", $("#vk-" + idDialog)).length > 0) {
        //            $("span[class=" + param + "]", $("#vk-" + idDialog)).html(value);
        //        } else {
        //            $('<span class="' + param + '">' + value + '</span>').appendTo("#vk-" + idDialog);
        //        }
        if ($("span[class=" + param + "]", $("#vk-" + idDialog)).length < 1) {
            $('<span class="' + param + '"></span>').appendTo("#vk-" + idDialog);
        }
        if (param.indexOf("htmlText") >= 0) {
            $("span[class=" + param + "]", $("#vk-" + idDialog)).html(value);
        } else {
            $("span[class=" + param + "]", $("#vk-" + idDialog)).text(value);
        }

        if (vkDialog._isCreated(idDialog)) {
            if (param.indexOf("ui-") >= 0) {
                if (param.indexOf("height") >= 0) {
                    vkDialog._setHeight(idDialog, value);
                } else {
                    $("#" + idDialog).dialog('option', param.substring(param.indexOf("ui-") + 3, 999), value);
                }
            } else if (param.indexOf("htmlText") >= 0) {
                $("#" + idDialog).html(value);
                vkAjax.ProcessQuestSetUp(idDialog);
            } else {
                vkDialog.global.activeDialogs[idDialog].options[(param.indexOf("vk-") >= 0 ? param.substring(param.indexOf("vk-") + 3, 999) : param)] = value;
            }
        }
    },

    _isCreated: function (idDialog) {
        ///	<summary>
        ///		Zjisti, jestli jiz byl dialog vytvoren
        ///	</summary>
        ///	<param name="idDialog" type="string">
        ///		id elementu, ze ktereho je dialog vytvoren.
        ///	</param>
        ///	<returns type="boolean">
        ///		true - dialog existuje
        ///	</returns>
        return vkDialog.global.activeDialogs[idDialog] != undefined;
    },

    SetParamUrl: function (idDialog, param, value) {
        ///	<summary>
        ///		nastavi parametr v URL adrese
        ///		funguje u skryteho i zobrazeneho dialogu
        ///	</summary>
        ///	<param name="idDialog" type="string">
        ///		id elementu, ze ktereho bude dialog vytvaren.
        ///	</param>
        ///	<param name="param" type="string">
        ///		nazev parametru, ktery bude nastaven
        ///	</param>
        ///	<param name="value" type="object">
        ///		Hodnota, na kterou je paremetr nastaven.
        ///	</param>
        ///<remarks>
        ///	u nezobrazeneho dialogu predpokladam, ze existuje DIV s id="vk-idDialog"
        ///</remarks>
        vkDialog.SetParam(idDialog, "vk-url", vkDialog._addParamToUrl(vkDialog.GetParam(idDialog, "vk-url"), param, value));
    },

    _addParamToUrl: function (url, param, value) {
        ///	<summary>
        ///       Prida libovolny parametr k url adrese , umi si poradit s '?' a '&' v adrese.
        ///	</summary>
        ///	<param name="url" type="string">
        ///		retezec url ke kteremu je pridan parametr
        ///	</param>
        ///	<param name="param" type="string">
        ///		nazev parametru, ktery bude nastaven
        ///	</param>
        ///	<param name="value" type="object">
        ///		Hodnota, na kterou je paremetr nastaven.
        ///	</param>
        ///	<returns type="string">
        ///		upravena url
        ///	</returns>

        if (url.indexOf(param + "=") < 1) {	// v adrese neni zatim obsazen vstupni jmeno parametru
            return url + (url.indexOf("?") < 1 ? "?" : "&") + param + "=" + value;
        } else {	// jmeno parametru je jiz obsazene, prepisuji tedy!
            var re = new RegExp("(" + param + "\=)(.+?)(\&)|(" + param + "\=)(.+)");
            var pomUrl = url.replace(re, "$1$4" + value + "$3");
            var re1 = new RegExp("\\$\\d", "g");    //tyto 2 radky jsou kvuli IE9, ktery kdyz v regexp nenajde prislusny retezec, tak pri nahrazovani necha $1
            return pomUrl.replace(re1, "");
        }

    }


};


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


utility = {

    clearDialog: function (idClearDialog) {
        ///	<summary>
        ///       vymaze obsah dialogu vcetne jeho titulku
        ///	</summary>
        ///	<param name="idClearDialog" type="string">
        ///		id dialogu
        ///	</param>
        $("#" + idClearDialog).html("");
        $("#" + idClearDialog).dialog("option", "title", "");
    }

}