/* ************************************************************************* *\

    Soubor: basic.js
    
    Popis:
        Základní podpora JavaScriptu, která činí skriptování méně závislým 
        na prohlížeči. Široce využívaná dalšími funkcemi.
        
    Implementované funkce:
        jePodpora(obj)                  [indikuje podporu featury]
        najdiObjekt(objId)              [najde objekt podle identifikátoru]
        vratObjekt(objId)               [vrátí vždy nějaký objekt]
        prevedNaCislo(hod, vychozi)     [převede objekt na číslo]
        prevedNaRetezec(hod, vychozi)   [převede na řetězec]
        
    Implementované objekty:
        ParRetezcu                      [dvojice klic-hodnota]
        
    Závislosti:
        (žádné)
        
\* ************************************************************************* */


/*  function jePodpora(obj)

    Otestuje korektně podporu zadaného objektu.
*/

function jePodpora(obj) {
    // správnější je užít typeof místo přetypování na Boolean
    return (typeof(obj) == 'undefined') ? false : true;
} // function


/*  function najdiObjekt(objId)

    Najde objekt podle ID a vrátí jej. Funkce je vytvořena podle podpory
    prohlížeče.
*/

/*const*/ var najdiObjekt;

if (jePodpora(document.getElementById)) {
    // podpora pro DOM 1 a vyšší
    najdiObjekt = function (objId) {
        return document.getElementById(objId);
    } // function
} // if
else if (jePodpora(document.all)) {
    // podpora pro starší MSIE
    najdiObjekt = function (objId) {
        return eval('document.all.' + objId);
    } // function
} // else if
else if (jePodpora(document.ids)) {
    // emulace pro NN4 (to by bylo lepší snad zahodit)
    najdiObjekt = function (objId) {
        return eval('document.ids.' + objId);
    } // function
} // else if
else {
    // aby nebyly na stránce zbytečné chyby
    najdiObjekt = function (objId) {
        // nullová funkce
        return null;
    } // function
} // else


/*  function vratObjekt(obj)

    Najde objekt podle ID a vrátí jej. Pokud je zadaný objekt místo řetězce,
    vrátí přímo objekt a již jej nehledá.
*/

function vratObjekt(obj) {
    // pokud je dán objekt, vrať objekt
    if (typeof(obj) != 'string') return obj;
    // jinak zkus najít objekt podle ID
    return najdiObjekt(obj);
} // function


/*  function prevedNaCislo(hod, vychozi)

    Pokusí se o konverzi na číslo; pokud se nepovede, vrátí výchozí hodnotu.
*/

function prevedNaCislo(hod, vychozi) {
    var vysledek = Number(hod);
    // vrat podle toho, co se povedlo
    return isNaN(vysledek) ? vychozi : vysledek;
} // function


/*  function prevedNaRetezec(hod, vychozi)

    Pokusí se o konverzi na řetězec; pokud se nepovede, vrátí výchozí hodnotu.
*/

function prevedNaRetezec(hod, vychozi) {
    return (typeof(hod) == 'undefined') ? vychozi : String(hod);
} // function


/*  objekt ParRetezcu

    Představuje dvojici řetězcových hodnot, z nichž jedna představuje klíč a 
    druhá jeho hodnotu.
    
    Konstruktor:
        ParRetezcu(prvni, druhy)    [vytvoří pár z dvojice nebo z jednoho]
    
    Vlastnosti:
        klic                        [jméno hodnoty]
        hodnota                     [hodnota klíče]
        
    Metody:
        spoj()                      [převede na řetězec]
        rozdel(retezec)             [převede z řetězce]
*/

function ParRetezcu(prvni, druhy) {
    if (ParRetezcu.arguments.length == 1) {
        this.rozdel(prvni);
    } // if
    else if (ParRetezcu.arguments.length == 2) {
        // nastavení vlastností objektu
        this.hodnota = String(druhy);
        this.klic = String(prvni);
    } // else if
    else {
        // prázdné řetězce
        this.hodnota = '';
        this.klic = '';
    } // else
    
    this.escapovany = false;
} // function

/*local*/ function ParRetezcu_rozdel(retezec) {
    // konverze na řetězec
    retezec = String(retezec);
    // zjistíme rozdělovač
    var index = retezec.indexOf('=');
    
    if (index == -1) {
        this.klic = retezec;
        this.hodnota = '';
    } // if
    else {
        this.klic = retezec.substring(0, index);
        this.hodnota = retezec.substr(index + 1);
    } // else
} // function

/*local*/ function ParRetezcu_spoj() {
    // prosté spojení rovnítky
    return this.klic + '=' + this.hodnota;
} // function

/*local*/ function ParRetezcu_escapuj() {
    this.hodnota = escape(this.hodnota);
    this.klic = escape(this.klic);
    this.escapovany = true;
} // function

/*local*/ function ParRetezcu_odescapuj() {
    this.hodnota = unescape(this.hodnota);
    this.klic = unescape(this.klic);
    this.escapovany = false;
} // function

/*local*/ function ParRetezcu_escapovani(stav) {
    if (Boolean(stav) != this.escapovany) {
        if (this.escapovany) this.odescapuj();
        else this.escapuj();
    } // if
} // function

/*local*/ function ParRetezcu_kopiruj(escapovane) {
    // nová instance s těmi samými vlastnostmi
    var vysledek = new ParRetezcu(new String(this.klic), new String(this.hodnota));
    vysledek.escapovany = this.escapovany;
    // přepnout escapování podle parametru
    vysledek.escapovani(escapovane);
    return vysledek;
} // function

// upravení prototypu
ParRetezcu.prototype.spoj = ParRetezcu_spoj;
ParRetezcu.prototype.rozdel = ParRetezcu_rozdel;
ParRetezcu.prototype.escapuj = ParRetezcu_escapuj;
ParRetezcu.prototype.odescapuj = ParRetezcu_odescapuj;
ParRetezcu.prototype.escapovani = ParRetezcu_escapovani;
ParRetezcu.prototype.kopiruj = ParRetezcu_kopiruj;