Programovací rámec GRobot

Trieda SVGPodpora

java.lang.Object

SVGPodpora

public class SVGPodpora
extends Object

Táto trieda slúži na komunikáciu programovacieho rámca s okolím prostredníctvom základov štandardu SVG. Cieľom pri implementácii bolo najmä poskytnutie možnosti importu a exportu tvarov programovacieho rámca GRobot vo formáte SVG 1.1, resp. SVG 2.0. Aj keď v čase implementácie prvej verzie tejto triedy nebol návrh SVG 2.0 úplný, programovací rámec s jeho použitím od začiatku počíta a návrh SVG 2.0 bol implementovaný do procesu importu tvarov.

Poznámka: Pri exporte nie sú využité vlastnosti SVG 2.0 (najmä takzvaný „bearing“ – aktuálne pootočenie, ktorý má v budúcnosti slúžiť na implementáciu korytnačej grafiky v rámci štandardu SVG), pretože súčasný softvér tento štandard nie je schopný spracovať, takže takto exportované údaje by neboli použiteľné.

Spracovanie úplnej implementácie štandardu SVG by bolo príliš náročné. Rámec sa zameriava na úplné základy – import a export reprezentácie tvarov (úsečka, obdĺžnik, kružnica, elipsa, lomená čiara, polygón a cesta), import a export základnej reprezentácie farieb výplní a čiar a tiež hrúbok čiar a použitie geometrických transformácií tvarov. Rámec nepodporuje žiadne zložitejšie výplne, štýly/druhy čiar a nadpojenia čiar, posunutie počiatku transformácií, ani štýlovanie prostredníctvom kaskádových štýlov (CSS) a podobne. Trieda tieto vlastnosti ani nezachováva. (Jedinou drobnou výnimkou je automatický prevod vybraných CSS definícií uvedených v atribúte style="…" na hodnoty konkrétnych XML atribútov. Príklad: <rect … style="fill:blue" /> bude spracované tak, ako keby bolo uvedené v tvare <rect … fill="blue" />. Avšak okrem vybraných CSS definícií ako fill, stroke, fill-opacity, stroke-opacity, stroke-width (a príbuzných ako: stroke-dasharray, stroke-linecap, stroke-miterlimit…) a transform sú všetky ostatné CSS definície ignorované. Tiež nie je analyzovaný obsah značky <style> … </style>, z čoho vyplýva, že aj obsah atribútu class je ignorovaný.) Z toho dôvodu nie je vhodné použiť prorgamovací rámec na úpravu SVG súborov, ktoré boli vytvorené inými softvérmi (napríklad Inkscape). Stratilo by sa príliš veľa informácií. Ukážky vhodného použitia tejto triedy ukazujú nasledujúce príklady…

Príklad:

Tento príklad ukazuje spôsob vykreslenia importovaných SVG údajov v rámci podporovaných možností programovacieho rámca. Príklad potrebuje na svoje fungovanie ukážkový SVG súbor "Panak.svg", ktorý je k dispozícii na prevzatie pod zdrojovým kódom príkladu. Nakreslený obrázok je možné presúvať klikaním a ťahaním myšou.

import knižnica.Farba;
import knižnica.GRobot;
import knižnica.Svet;
import knižnica.ÚdajeUdalostí;

public class SVGZobraz extends GRobot
{
    // Konštruktor.
    private SVGZobraz()
    {
        // Nastavenie rozmerov plátien volaním nadradeného konštruktora:
        super(1200, 650);

        // Vypnutie predvoleného spôsobu automatického prekresľovania:
        Svet.nekresli();

        // Zabezpečenie toho, aby robot nebol skrytý po prvom konzolovom výpise:
        Svet.vypíš(this);

        // Prečítanie tvarov z SVG súboru:
        int prečítané = svgPodpora.čítaj("Panak.svg");

        // Overenie toho, či sa čítanie podarilo:
        if (-1 == prečítané)
        {
            // V prípade neúspechu je informácia vypísaná červenou farbou:
            Svet.farbaTextu(červená);
            Svet.vypíšRiadok("Čítanie súboru sa nepodarilo.");
        }
        else
        {
            // V prípade úspechu je vypísaný počet prečítaných tvarov:
            Svet.vypíšRiadok("Počet prečítaných tvarov: ", prečítané);
            vykresli();
        }

        // Spustenie časovača zapne kontrolu potreby prekreslenia sveta
        // v pravidelných časových inervaloch (pozri reakciu tik nižšie;
        // samozrejme, že ak sa zistí, že je prekreslenie sveta potrebné,
        // tak bude zároveň vykonané):
        Svet.spustiČasovač();
    }

    // V obsluhe udalosti časovača (tik) je zabezpečované prekresľovanie
    // sveta v pravidelných časových intervaloch (v prípade potreby).
    @Override public void tik()
    {
        if (Svet.neboloPrekreslené()) Svet.prekresli();
    }

    // Po kliknutí (alebo ťahaní myšou – pozri nižšie) bude SVG obrázok
    // prekreslený na novej pozícii.
    @Override public void klik()
    {
        podlaha.vymažGrafiku();
        if (ÚdajeUdalostí.tlačidloMyši(ĽAVÉ))
            skočNaMyš(); else otočNaMyš();
        vykresli();
    }

    // Reakcia na ťahanie myšou je rovnaká ako na klik.
    @Override public void ťahanieMyšou()
    {
        klik();
    }

    // Vlastný tvar robota bude kružnica so „zárezom.“
    @Override public void kresliSeba()
    {
        kružnica();
        dopredu();
    }

    // Táto metóda slúži na nakreslenie prečítaného jednoduchého SVG obrázka.
    // (Jednoduchého v zmysle využitia základných možností formátu SVG,
    // s ktorými dovoľuje pracovať trieda SVGPodpora.)
    public void vykresli()
    {
        // Deklarácia a definícia premenných. Farbu bude treba na overenie
        // toho, či má kreslený tvar definovanú farbu výplne alebo čiary.
        // Počet uložený v premennej by mal mierne zvýšiť efektívnosť
        // vykonávania cyklu.
        Farba farba;
        int počet = svgPodpora.počet();

        // Cyklus – nakreslenie čiar a/alebo výplní všetkých tvarov.
        for (int i = 0; i < počet; ++i)
        {
            // Kreslenie výplne:
            farba = svgPodpora.farbaVýplne(i);
            if (null != farba)
            {
                farba(farba);
                vyplňTvar(svgPodpora.dajVýsledný(i), true);
            }

            // Kreslenie čiary:
            farba = svgPodpora.farbaČiary(i);
            if (null != farba)
            {
                double hrúbkaČiary = svgPodpora.hrúbkaČiary(i) * mierka();
                if (Double.isFinite(hrúbkaČiary))
                    hrúbkaČiary(hrúbkaČiary);
                else
                    hrúbkaČiary(1);
                farba(farba);
                kresliTvar(svgPodpora.dajVýsledný(i), true);
            }
        }

        // Po dokončení každého kreslenia (prvé je vykonané pri spustení
        // aplikácie a ďalšie pri kliknutí alebo ťahaní myšou) je opätovne
        // nastavená hrúbka a farba čiary robota na 0.5 boda a červenú. To
        // ovplyvní nakreslenie vlastného tvaru robota – kružnice so „zárezom.“
        hrúbkaČiary(.5);
        farba(červená);
    }

    // Hlavná metóda.
    public static void main(String... args)
    {
        Svet.použiKonfiguráciu("SVGZobraz.cfg");
        new SVGZobraz();
    }
}

Panak.svg – SVG obrázok na prevzatie.

Výsledok:

Vzhľad časti plochy sveta po spustení príkladu a miernom posunutí panáka myšou smerom nadol
(plátno ukážky je orezané a zmenšené; veľkosť okna je po prvom spustení menšia, než veľkosť plochy).

Príklad:

Nasledujúca séria príkazov ukazuje import tvaru z SVG súboru a jeho použitie na kreslenie vlastného vyplneného tvaru robota. Príkazy vyžadujú na svoje fungovanie SVG súbor "SVGTvaryRobota.svg", ktorý je k dispozícii na prevzatie nižšie. (Pod ním nájdete rozšírenú verziu tohto príkladu.)

try
{
    svgPodpora.čítaj("SVGTvaryRobota.svg");

    Shape tvar = svgPodpora.dajVýsledný(0);

    final Oblasť tvarVOblasti = new Oblasť(
        SVGPodpora.presuňDoStredu(tvar));

    vlastnýTvar((GRobot r) -> r.vyplňOblasť(tvarVOblasti));
}
catch (Exception e)
{
    e.printStackTrace();
}

SVGTvaryRobota.svg – SVG súbor (s tvarmi robota) na prevzatie

Nasledujúce rozšírenie príkladu pracuje so zapnutým interaktívnym režimom robota a sveta a používa tiež štandardú konfiguráciu sveta aj robota. Definuje aj dve tzv. zákaznícke vlastnosti. To sú také vlastnosti, ktoré sú definované nad rámec štandardnej konfigurácie (podrobnosti sú v komentároch). Zmenu tvaru docieli používateľ po spustení aplikácie zadaním a potvrdením príkazu „nastav tvar «číslo»“ vo vstupnom riadku, pričom pri použití súboru SVGTvaryRobota.svg sú použiteľné číselné hodnoty 1 – 3 na zmenu tvarov prečítaných zo súboru a nula, ktorá znamená predvolený tvar.

import knižnica.*;
import knižnica.SVGPodpora.Transformácia;

import java.awt.Shape;

public class SVGTvarRobota extends GRobot
{
    // Do tohto atribútu bude ukladaný tvar prevedený z SVG údajov na
    // oblasť (tento proces nazývame zjednodušene v komentároch nižšie aj
    // generovaním oblasti):
    private Oblasť tvarVOblasti = null;

    // Tento atribút slúži na detekciu zmeny veľkosti robota, aby mohol byť
    // tvar uložený v oblasti (definovanej vyššie) pregenerovaný (to znamená,
    // že pri každej zmene veľkosti robota sa oblasť znovu vygeneruje – tento
    // prístup nepočíta s príliš častými zmenami veľkosti robota):
    private double poslednáVeľkosť = 10.0;

    // V tomto atribúte je uložené poradové číslo naposledy prevedeného tvaru
    // z SVG údajov (ide o jednu z dvoch tzv. zákazníckych vlastností v tomto
    // príklade):
    private int poslednýNastavenýTvar = 1;

    // Toto je záložná hodnota predchádzajúceho atribútu – je to hodnota,
    // ktorá bola prečítaná z konfigurácie (ak jestvovala) a slúži na detekciu
    // zmien (aby bola naplnená litera zapísaná v príklade TestKonfigurácie
    // uvedenom v opise triedy ObsluhaUdalostí):
    private int prečítanýNastavenýTvar = 1;

    // V tomto atribúte je názov naposledy čítaného SVG súboru, ktorého
    // údaje majú slúžiť ako zdroj tvarov (ide o jednu z dvoch tzv.
    // zákazníckych vlastností v tomto príklade):
    private String poslednýČítanýSúbor = null;

    // Toto je záložná hodnota predchádzajúceho atribútu a je medzi nimi
    // rovnaký vzťah ako medzi dvomi celočíselnými atribútmi vyššie:
    private String menoSúboruZKonfigurácie = null;
    
    // Konštruktor.
    private SVGTvarRobota()
    {
        // Úprava rozmerov plátien volaním nadradeného konštruktora.
        super(800, 600);

        // Vypnutie automatického prekresľovania, pretože tento príklad
        // používa prekresľovanie v pravidelných časových intevaloch na
        // požiadanie (rovnako ako príklady uvedené v opise metódy
        // Svet.nebolPrekreslený() a triedy Obrázok).
        Svet.nekresli();

        // Tento príkaz zabezpečí, aby sa pri ďalších výpisoch metódami
        // sveta hlavný robot automaticky neskryl (vysvetlenie je uvedené
        // v poznámke v opise metódy Plátno.vypíš(…)):
        Svet.vypíš(this);

        // Definovanie obsluhy udalostí – obsluhujeme časovač, neúspešné
        // zadanie príkazu a konfiguráciu.
        new ObsluhaUdalostí()
        {
            // Toto je reakcia na udalosti časovača.
            @Override public void tik()
            {
                // Vždy, keď má vnútorný indikátor potreby prekreslenia
                // pravdivú logickú hodnotu (true), zariadime spustenie
                // prekreslenia sveta:
                if (Svet.neboloPrekreslené()) Svet.prekresli();
            }

            // Reakcia na potvrdenie vstupu je v interaktívnom režime
            // spustená vtedy, keď potvrdený príkaz nebol rozpoznaný,
            // čiže v prípade chybného príkazu.
            @Override public void potvrdenieVstupu()
            {
                // Vyššie opísanú situáciu vyriešime tak, že potvrdený
                // reťazec vrátime späť do príkazového riadka, aby ho
                // mohol používateľ opraviť a znova potvrdiť.
                Svet.textVstupnéhoRiadka(Svet.prevezmiReťazec());
            }
            
            // Táto reakcia je spustená, keď si svet potrebuje overiť,
            // či má zmysel zapisovať konfiguráciu, či sa zmenila hodnota
            // niektorej zákazníckej vlastnosti. (Svet túto reakciu vôbec
            // nemusí spustiť.)
            @Override public boolean konfiguráciaZmenená()
            {
                // Nasledujúce riadky obsahujú kontroly zmien hodnôt
                // zákazníckych vlastností:
                if (poslednýNastavenýTvar != prečítanýNastavenýTvar)
                    return true;
                if (poslednýČítanýSúbor != menoSúboruZKonfigurácie)
                    return true;

                // (Tu by nasledovali ďalšie kontroly zmien hodnôt.)

                return false;
            }

            // Táto reakcia dovoľuje zapísať zákaznícke vlastnosti do
            // konfiguračného súboru.
            @Override public void zapíšKonfiguráciu(Súbor súbor)
                throws java.io.IOException
            {
                // Zapisujeme hodnoty vlastností:
                súbor.zapíšVlastnosť("nastavenýTvar", poslednýNastavenýTvar);
                súbor.zapíšVlastnosť("čítanýSúbor", poslednýČítanýSúbor);

                // (Tu by nasledovali ďalšie zápisy hodnôt.)
            }

            // Táto reakcia umožňuje prečítanie hodnôt zákazníckych
            // vlastností z konfiguračného súboru.
            @Override public void čítajKonfiguráciu(Súbor súbor)
                throws java.io.IOException
            {
                // Čítanie hodnôt vlastností.
                // 
                // Pri čítaní zmeníme pri každej čítanej vlastnosti naraz
                // hodnotu skutočnej vlastnosti aj hodnotu premennej
                // slúžiacej na uchovanie prečítanej hodnoty (tá slúži ako
                // detektor zmien a je vyhodnocovaná v reakcii
                // konfiguráciaZmenená.

                poslednýNastavenýTvar = prečítanýNastavenýTvar =
                    súbor.čítajVlastnosť("nastavenýTvar",
                        (long)poslednýNastavenýTvar).intValue();
                poslednýČítanýSúbor = menoSúboruZKonfigurácie =
                    súbor.čítajVlastnosť("čítanýSúbor", poslednýČítanýSúbor);

                // (Tu by nasledovali ďalšie čítania hodnôt.)
            }
        };

        // Zapnutie interaktívneho (príkazového) režimu a registrácia robota
        // v rámci konfigurácie:
        Svet.interaktívnyRežim(true);
        interaktívnyRežim(true);
        Svet.registrujRobot(this);

        // Čítanie naposledy čítaného súboru (počiatočná hodnota null má
        // špeciálny význam – vtedy sa metóda pokúsi čítať súbor
        // s predvoleným názvom – pozri definíciu metódy čítaj nižšie).
        // Keďže úspešné vykonanie tejto metódy mení (resetuje) hodnotu
        // poradového čísla naposledy nastavovaného tvaru (čo je žiaduce
        // pri vykonaní z príkazového riadka), je pred týmto volaním hodnota
        // tohto číselného atribútu zálohovaná a po ňom spätne obnovená:
        int zálohaHodnotyTvaru = poslednýNastavenýTvar;
        čítaj(poslednýČítanýSúbor);
        poslednýNastavenýTvar = zálohaHodnotyTvaru;

        // Nastavenie tvaru podľa atribútu, ktorého hodnotu sme práve
        // zálohovali a obnovili (pozri komentár a kód vyššie):
        nastavTvar(poslednýNastavenýTvar);

        // Spustenie časovača (inak by nefungovalo prekresľovanie spomínané
        // pri príkaze Svet.nekresli(); v úvode tohto konštruktora):
        Svet.spustiČasovač();
    }
    
    /////////////////////////////////////////////////////////////////
    // ##   Výhodou interaktívneho režimu je, že všetky nové    ## //
    // ##   definované verejné metódy (spĺňajúce kritériá       ## //
    // ##   opísané pri metóde Svet.interaktívnyRežim(zapni))   ## //
    // ##   sa automaticky stávajú príkazmi použiteľnými        ## //
    // ##   v tomto režime…                                     ## //
    /////////////////////////////////////////////////////////////////
    
    // Vypíše aktuálny počet útvarov uložených vo vnútornom zásobníku
    // inštancie svgPodpora. To je zároveň horná hranica číselného rozsahu
    // použiteľného s metódou nastavTvar (nižšie).
    public void vypíšPočet()
    {
        Svet.vypíšRiadok("Počet tvarov v zásobníku: ", svgPodpora.počet());
    }

    // | Tento alias je definovaný len preto, aby bola v príkazovom riadku
    // | interaktívneho režimu použiteľná aj verzia tohto príkazu bez
    // | diakritiky.
    public void vypisPocet() { vypíšPočet(); }
    
    // Táto metóda slúži na prečítanie SVG súboru so zadaným menom. Tvary,
    // ktoré sa podaria nájsť inštancii svgPodpora budú použiteľné na
    // nastavenie vlastného tvaru robota.
    public void čítaj(String meno)
    {
        // Ak je namiesto názvu súboru zadaná hodnota null, tak je použitý
        // preddefinovaný názov súboru „SVGTvaryRobota.svg“:
        if (null == meno) meno = "SVGTvaryRobota.svg";

        Svet.vypíšRiadok("Čítam súbor: ", meno);

        // Pri každom novom čítaní sú z vnútorného zásobníka tvarov
        // inštancie svgPodpora vymazané všetky tvary:
        svgPodpora.vymaž();

        // Do premennej výsledok najprv vložíme hodnotu -1, ktorá signalizuje
        // chybu:
        int výsledok = -1;

        // V nasledujúcom bloku na zachytávanie výnimiek sa pokúsime
        // prečítať súbor so zadaným menom:
        try
        {
            // Ak sa čítanie podarí, tak v premennej výsledok bude počet
            // prečítaných tvarov (aj táto metóda môže vrátiť hodnotu -1
            // bez vzniku výnimky, takže pôvodná mínus jednotka môže byť
            // bez nášho vedomia prepísaná novou, ale to vôbec neprekáža,
            // lebo výsledná informácia je totožná):
            výsledok = svgPodpora.čítaj(meno);
        }
        catch (Exception e)
        {
            // V prípade vzniknutia výnimky je na štandardnom chybovo výstupe
            // vypísaná krátka správa o pôvode („stope v zásobníku“) chyby:
            e.printStackTrace();
        }

        // Podľa hodnoty premennej výsledok je vypísané hlásenie a prípadne
        // vykonané ďalšie kroky…
        if (-1 == výsledok)
            Svet.vypíšRiadok("Čítanie súboru zlyhalo!");
        else
        {
            // V prípade úspechu je okrem vypísania správy nastavený
            // predvolený tvar robota a vymazaná oblasť obsahujúca
            // vlastný tvar:
            Svet.vypíšRiadok("Počet prečítaných tvarov: ", výsledok);
            poslednýČítanýSúbor = meno;
            poslednýNastavenýTvar = 0;
            tvarVOblasti = null;
        }
        vypíšPočet();
    }

    // | Tento alias je definovaný len preto, aby bola v príkazovom riadku
    // | interaktívneho režimu použiteľná aj verzia tohto príkazu bez
    // | diakritiky.
    public void citaj(String meno) { čítaj(meno); }

    // Táto verzia metódy dovoľuje použitie tohto príkazu bez zadania
    // parametra (namiesto ktorého je dosadená predvolená hodnota null).
    public void čítaj() { čítaj(null); }

    // | Tento alias je definovaný len preto, aby bola v príkazovom riadku
    // | interaktívneho režimu použiteľná aj verzia tohto príkazu bez
    // | diakritiky.
    public void citaj() { čítaj(); }
    
    // Táto metóda vygeneruje taký tvar oblasti, ktorý bude použiteľný ako
    // vlastný tvar robota. Oblasť musí byť umiestnená v strede plátna, inak
    // by bol vlastný tvar posunutý oproti skutočnej polohe robota. Tvar
    // oblasti je vygenerovaný z SVG tvaru, ktorý je uložený vo vnútornom
    // zásobníku inštancie svgPodpora pod poradovým číslom určeným parametrom
    // „ktorý.“ Metóda tiež zariadi, aby bola veľkosť tvaru oblasi prispôsobená
    // podľa aktuálnej veľkosti a mierky robota.
    public void nastavTvar(int ktorý)
    {
        // Hodnota nula znamená predvolený tvar robota.
        if (0 == ktorý)
        {
            poslednýNastavenýTvar = 0;
            tvarVOblasti = null;

            Svet.vypíšRiadok("Nastavený predvolený tvar.");
        }
        else
        {
            // Všetky ostatné hodnoty znamenajú poradové číslo tvaru vo
            // vnútornom zásobníku inštancie svgPodpora, pričom metódy
            // dávajúce tvary smú prijímať aj záporné čísla – v tom prípade
            // to znamená n-tý tvar od konca zásobníka. Kladné hodnoty
            // musia byť odlíšené, pretože metóda funguje rovnako ako
            // všetko v jazyku Java – nula je index prvého tvaru. Index
            // vypočítame zo zadaného poradového čísla jednoducho, je to
            // hodnota: ktorý − 1.
            Shape tvar = svgPodpora.dajVýsledný(ktorý < 0 ? ktorý : ktorý - 1);

            if (null == tvar)
            {
                // Ak metóda dajVýsledný vráti null, znamená to, že
                // tvar nebol nájdený (lebo požadovaný index je mimo
                // rozsahu).
                Svet.pípni();
                Svet.vypíšRiadok("Tvar s poradovým číslom ",
                    ktorý, " nebol nájdený.");
            }
            else
            {
                // V prípade úspešne nájdeného tvaru najprv upravíme
                // jeho veľkosť podľa aktuálnej veľkosti a mierky robota,
                // pričom ak sú veľkosť robota v súčine s mierkou rovné
                // hodnote desať, tak to značí, že veľkosť tvaru nemá
                // byť zmenená.

                // Atribút poslednáVeľkosť bude slúžiť na overenie zmeny
                // veľkosti vlastného tvaru a zároveň ho použijeme
                // v nasledujúcom kroku (na overenie potreby úpravy veľkosti
                // tvaru a na jej prípadné vykonanie).
                poslednáVeľkosť = veľkosť() * mierka();

                if (10.0 != poslednáVeľkosť)
                    // Na zmenu veľkosti tvaru (v prípade, že je potrebné ju
                    // upraviť) je použitá transformácia MIERKA:
                    tvar = SVGPodpora.dajVýsledný(
                        tvar, new Transformácia(
                            Transformácia.MIERKA,
                            poslednáVeľkosť / 10.0));

                // Potom presunieme vrátený tvar do stredu súradnicovej
                // sústavy grafického robota. Môžeme použiť metódu
                // SVGPodpora.presuňDoStredu(tvar):
                tvarVOblasti = new Oblasť(SVGPodpora.presuňDoStredu(tvar));

                // Nakoniec zaznamenáme poradové číslo použitého tvaru:
                poslednýNastavenýTvar = ktorý;

                Svet.vypíšRiadok("Nastavený tvar: ", ktorý);
            }
        }
    }
    
    // Táto verzia metódy dovoľuje použitie príkazu tohto bez zadania
    // parametra (namiesto ktorého je dosadená predvolená hodnota 1).
    public void nastavTvar() { nastavTvar(1); }
    
    // Táto reakcia zabezpečuje kreslenie vlastného (a v tomto prípade aj
    // predvoleného) tvaru robota.
    @Override public void kresliSeba()
    {
        // Ak je definovaná oblasť s vlastným tvarom, tak sa vykoná vetva
        // zabezpečujúca nakreslenie vlastného tvaru (s nejakými kontrolami).
        if (null != tvarVOblasti && 0 != poslednýNastavenýTvar)
        {
            // Ak sa zmenila veľkosť robota (alebo mierka), tak nastane
            // pregenerovanie tvaru:
            if (poslednáVeľkosť != veľkosť() * mierka())
                nastavTvar(poslednýNastavenýTvar);

            // Podľa toho, či je aktivované vypĺňanie tvarov robotom
            // bude oblasť vyplnená alebo obkreslená:
            if (vypĺňaTvary())
                vyplňOblasť(tvarVOblasti);
            else
                obkresliOblasť(tvarVOblasti);
        }
        else
        {
            // Alternatívna vetva obsahuje len príkaz kreslenia predvoleného
            // tvaru robota:
            trojzubec();
        }
    }
    
    // Hlavná metóda.
    public static void main(String... args)
    {
        Svet.použiKonfiguráciu("SVGTvarRobota.cfg");
        new SVGTvarRobota();
    }
}

Výsledok:

Ukážka vzhľadu okna po prvom spustení aplikácie
(ukážka je zmenšená).

Príklad:

Tento príklad ukazuje ako previesť (konvertovať) rastrový obrázok prečítaný z PNG súboru na množinu kruhov s veľkosťami podľa lokálneho jasu konkrétnych častí obrázka. Výsledok konverzie je uložený do vektorového SVG súboru.

Budeme postupovať tak, že najskôr prečítame bitmapový obrázok zo súboru s názvom „mola.jpeg,“ obrázok virtuálne rozdelíme na bloky veľké 10 × 10 bodov (pixelov), vypočítame priemerný farebný jas bodov v každom bloku a podľa týchto hodnôt vyrobíme kruhy tvoriace mozaiku nového obrázka vo formáte SVG. (Viaceré hodnoty v príklade sú zadané „napevno,“ nie univerzálne. Dôvodom je úsilie o nezvyšovanie zložitosti príkladu.)

import knižnica.*;

public class SVGKruhy extends GRobot
{
    // Konštruktor.
    private SVGKruhy()
    {
        // Úprava rozmerov plátna volaním nadradeného konštruktora.
        super(800, 600);

        // Skryje robot:
        skry();

        // Vypnutie automatického prekresľovania.
        Svet.nekresli();

        // Vytvorí obrázok zo súboru uloženého na pevnom disku
        // (prípadne inej jednotke, ktorá je aktuálna):
        Obrázok obrázok = Obrázok.prečítaj("mola.jpeg");

        // Zobrazí prečítaný obrázok v mierke 1 : 2, keďže obrázok má
        // v porovnaní s plátnami dvojnásobné rozmery. (Samozrejme, že
        // toto nie je univerzálne riešenie. Univerzálne riešenie by muselo
        // porovnať rozmery obrázka s rozmermi plátien a na základe toho
        // vypočítať mierku.)
        obrázok(obrázok, 0.5);

        // Ak teraz presmerujeme kreslenie na strop, kresba obrázka na
        // podlahe zostane neporušená a môžeme s ňou manipulovať samostatne
        // (to nesúvisí s grafikou samotného obrázka, tá zostane neporušená
        // i tak):
        kresliNaStrop();

        // Umiestnime robot na počiatočnú pozíciu – do ľavého dolného rohu
        // plátna. Poloha robota je dôležitá len pre výstupné SVG údaje.
        skočNa(Svet.najmenšieX() + 2.5, Svet.najmenšieY() + 2.5);

        // Nastavenie (konštantnej) veľkosti robota má zmysel najmä pri
        // inej verzii konverzie obrázka, ale výkonu aplikácie to neublíži:
        veľkosť(2.5);
        
        // Úlohou nasledujúcich štyroch (postupne sa vnárajúcich) cyklov
        // „for“ je prechádzať po blokoch 10 × 10 pixelov po obrázku,
        // vypočítať z každého bloku priemer jasu (alebo farebnosti, prípadne
        // iného parametra) a z vypočítaného údaja vyrobiť tvar, ktorý bude
        // uložený do SVG údajov.
        //
        // Poznámky:
        // ---------
        //
        // Využívané sú len metódy/príkazy programovacieho rámca GRobot.
        // Toto riešenie síce nie je optimálne, ale je odolné voči chybám,
        // pretože spracúvané hodnoty podstupujú viacnásobnú kontrolu.
        // Keby sme však potrebovali dávkovo spracovať veľké množstvo údajov
        // (napríklad mnoho obrázkov), bolo by nevyhnutné riešenie
        // optimalizovať. Odporúčame priamu prácu s rastrom:
        //
        //    int[] údaje = ((java.awt.image.DataBufferInt)obrázok.
        //        getRaster().getDataBuffer()).getData();
        //    …
        //
        // Takto získané celočíselné pole obsahuje farebné (ARGB) údaje
        // o jednotlivých bodoch obrázka počnúc ľavým horným rohom,
        // pokračujúc doprava a po jednotlivých riadkoch až na koniec.
        //
        for (double y = obrázok.najmenšieY();
            y <= obrázok.najväčšieY(); y += 10.0)
        {
            for (double x = obrázok.najmenšieX();
                x <= obrázok.najväčšieX(); x += 10.0)
            {
                // Do nasledujúcich premenných budú ukladané údaje určené
                // na výsledné spracovanie. V tomto prípade je to celková
                // suma hodnôt farebných zložiek všetkých bodov a počet
                // bodov, ktoré boli skutočne vyhodnotené.
                int suma = 0;
                int počet = 0;

                // Spracovanie bloku 10 × 10 pixelov:
                for (int j = 0; j < 10; ++j)
                {
                    for (int i = 0; i < 10; ++i)
                    {
                        // Najprv je prečítaná farba každého bodu. Bod je
                        // čítaný bez ohľadu na polohu robota. Súradnice
                        // bodu sú určené výhradne riadiacimi premennými
                        // štyroch cyklov „for“:
                        Farba farba = obrázok.farbaBodu(x + i, y + j);

                        // Ak neboli požadované súradnice mimo hraníc
                        // obrázka, tak je získaná farba spracovaná:
                        if (žiadna != farba)
                        {
                            // Zvýši sa počítadlo spracovaných farieb:
                            ++počet;

                            // A súčet všetkých farebných zložiek je pridaný
                            // do celkovej sumy:
                            suma += farba.červená() +
                                farba.zelená() + farba.modrá();
                        }
                    }
                }

                // Vyrobiť tvar má zmysel len ak sú k dispozícii údaje
                // na spracovanie.
                if (0 != počet)
                {
                    // Upravíme veľkosť robota podľa priemeru vypočítaného
                    // z farebných hodnôt všetkých spracovaných bodov
                    // (čísla vo vzorci sme získali empiricky – to jest
                    // čiastočne odhadom na základe predchádzajúcich
                    // vedomostí a skúseností a čiastočne „doladením“ podľa
                    // estetiky výsledku):
                    veľkosť(3.25 - ((suma / (3 * počet)) / 80.0));

                    // Do inštancie svgPodpora pridáme čierny krúžok na
                    // pozícii robota s veľkosťou robota:
                    svgPodpora.pridaj(kruh(), "fill", "black");
                }

                // Posunutie robota o kúsok doprava – synchrónne s prechodom
                // na ďalší spracúvaný blok pixelov:
                skoč(5.0, 0.0);
            }

            // Posunutie robota na začiatok vyššieho riadka:
            skočNa(Svet.najmenšieX() + 2.5, polohaY() + 5.0);

            // Prekreslenie sveta (skrytím tohto príkazu do komentára sa
            // proces konverzie značne urýchli):
            Svet.prekresli();
        }
        
        // Skrytie obrázka na podlahe:
        podlaha.priehľadnosť(0);

        // Uloženie SVG súboru (s predvoleným titulkom a prepisujúc
        // prípadný pôvodný súbor):
        svgPodpora.zapíš("mola-bodkova.svg", null, true);

        // Opätovné zapnutie automatického prekresľovania.
        Svet.kresli();
    }
    
    // Hlavná metóda.
    public static void main(String... args)
    {
        Svet.použiKonfiguráciu("SVGKruhy.cfg");
        new SVGKruhy();
    }
}

mola.jpeg – pôvodný rastrový obrázok na prevzatie.

Pôvodný rastrový obrázok
(zobrazovaný obrázok je oproti pôvodnému obrázku na prevzatie zmenšený o 50 %).

Výsledok:

Výsledný SVG obraz.

Príklad:

Tento príklad ukazuje vytvorenie fraktálneho útvaru rastlinky pomocou korytnačej grafiky grafického robota a jej uloženie do HTML súboru obsahujúceho SVG definíciu. Generovanie rastlinky používa náhodné čísla, preto každé spustenie vygeneruje a uloží unikátny obrázok. V skutočnosti sú ukladané dva súbory – rastrový obrázok vo formáte PNG a HTML obsahujúce SVG. Ďalšie podrobnosti o fungovaní príkladu sú v jeho komentároch.

import knižnica.*;

// Túto triedu Javy reprezentujúcu 2D úsečku potrebujeme na pridávanie
// jednotlivých úsečiek do inštancie svgPodpora.
import java.awt.geom.Line2D;

// V tomto príklade je implementovaných viacero mechanizmov, ktoré priamo
// nesúvisia s formátom SVG. Všetko je podrobne vysvetlené v komentároch.
// SVG formátu sa dotýkajú všetky pasáže používajúce triedu SVGPodpora
// a inštanciu svgPodpora.
public class SVGRastlinka extends GRobot
{
    // Súkromný konštruktor.
    private SVGRastlinka()
    {
        // Úprava rozmerov plátna volaním nadradeného konštruktora.
        super(800, 640);

        // Vypnutie predvoleného automatického prekresľovania.
        Svet.nekresli();

        // Obsluha udalostí zabezpečujúca prekresľovanie sveta
        // v pravidelných časových intervaloch.
        new ObsluhaUdalostí()
        {
            @Override public void tik()
            {
                if (Svet.neboloPrekreslené()) Svet.prekresli();
            }
        };

        // Spustenie časovača (na pravidelné prekresľovanie).
        Svet.spustiČasovač();

        // Úvodné nastavenie robota a spustenie kreslenia rastlinky.
        skoč(0, -300);
        farba(0, 120, 0, 120);
        rastlinka(96);

        // Skrytie robota.
        skry();
    }

    // Atribúty slúžiace na uchovanie súradníc úsečky.
    private double x0, y0, x1, y1;

    // Pomocná metóda na zaznamenanie aktuálnej polohy robota.
    private void uložPolohu()
    {
        // Je dôležité prepočítať súradnice zo súradnicového priestoru
        // rámca do súradnicového priestoru, ktorý je používaný formátom
        // SVG. Vo viacerých prípadoch je konverzia vykonaná automaticky,
        // ale tu to nie je možné, pretože čítame priamo polohu robota,
        // ktorú ukladáme ako bezrozmerné číslo, ktorého pôvod nie je možné
        // detegovať žiadnou súčasťou programovacieho rámca alebo Javy. Rovnaká situácia
        // nastáva aj v metóde pridajÚsečku (nižšie).
        // 
        // O súradnicových priestoroch je viac napísané v príklade v opise
        // metódy cesta() triedy GRobot a v opisoch metód zapíš a čítaj
        // v tejto triede (SVGPodpora)…
        x0 = x1 = Svet.prepočítajX(polohaX());
        y0 = y1 = Svet.prepočítajY(polohaY());
    }

    // Pomocná metóda na pridanie úsečky do SVG údajov.
    private void pridajÚsečku()
    {
        // Poznámka: Od 17. 5. 2022 je definovaná metóda SVG podpory:
        // pridajÚsečku
        // Jej použitie by tento príklad zjednodušilo.
        // Definícia tejto pomocnej metódy by nebola potrebná.

        // Je dôležité prepočítať súradnice zo súradnicového priestoru
        // rámca do súradnicového priestoru, ktorý je používaný formátom
        // SVG. Podrobnejšie je to vysvetlené v komentároch v metóde
        // uložPolohu (vyššie).
        x0 = x1; x1 = Svet.prepočítajX(polohaX());
        y0 = y1; y1 = Svet.prepočítajY(polohaY());

        // Z prevedených súradníc vytvoríme úsečku, ktorú vložíme do
        // vnútorného zásobníka tvarov inštancie svgPodpora a vzápätí
        // upravíme jej vizuálne vlastnosti.
        svgPodpora.pridaj(new Line2D.Double(x0, y0, x1, y1));
        svgPodpora.hrúbkaČiary(-1, hrúbkaČiary());
        svgPodpora.farbaČiary(-1, farba());
    }

    // Rekurzívna metóda na kreslenie rastlinky
    private void rastlinka(double dĺžka)
    {
        if (dĺžka < 2) return;

        // V komentároch v tejto metóde vysvetlíme princípy, ktorými sa
        // riadi jej vykonávanie. Na zjednodušenie ignorujme v najbližších
        // úvahách rekurzívne volanie. (Aj tak sa nakoniec ukáže, že ak
        // správne uvažujeme, tak sa ním nemusíme zaoberať.)

        // Hlavná zásada znie:
        // -------------------
        // 
        //   #######################################################
        //   ##  Po vykonaní tejto metódy musí mať robot rovnakú  ##
        //   ##  orientáciu a polohu ako mal pred jej vykonaním.  ##
        //   #######################################################

        // „Vypočítame,“ respektíve náhodne vygenerujeme, dva uhly, o ktoré
        // sa bude robot otáčať pred prechodom do rekurzívnej vetvy. Uhly
        // si musíme zapamätať v lokálnych premenných, aby sme boli schopní
        // zabezpečiť dodržanie hlavnej zásady (vyššie).
        double uhol1 = Svet.náhodnéReálneČíslo(0, 30);
        double uhol2 = Svet.náhodnéReálneČíslo(0, 30);

        // Nastavíme hrúbku čiary a položíme pero:
        hrúbkaČiary(dĺžka / 12);
        položPero();

        // Prostredný z nasledujúcej trojice príkazov mení polohu robota.
        // Túto zmenu treba na konci metódy vrátiť naspäť (v súlade
        // s dodržaním hlavnej zásady uvedenej vyššie). Keďže príkazom
        // vyššie sme položili pero, robot kreslí čiaru. Nakreslenú úsečku
        // zároveň zaznamenáme do SVG údajov metódami uložPolohu
        // a pridajÚsečku.
        uložPolohu();
        dopredu(dĺžka);
        pridajÚsečku();

        // Poznámka: Od 17. 5. 2022 je definovaná metóda SVG podpory:
        // pridajÚsečku
        // Jej použitie by tento príklad zjednodušilo.
        // Definícia pomocnej metódy pridajÚsečku() by nebola potrebná
        // a namiesto jej volania (vyššie) by sme volali:
        // svgPodpora.pridajÚsečku(this);

        // Pootočenie doprava vlastne zjednodušene znamená odčítanie
        // zadaného uhla od aktuálneho uhla. Súčet všetkých pootočení
        // musí byť rovný nule. Toto je prvé pootočenie v zápornom smere:
        vpravo(uhol1);

        // Prvé rekurzívne volanie – tu nastáva vetvenie rastlinky vpravo:
        rastlinka(dĺžka - Svet.náhodnéReálneČíslo(5, 16));

        // Toto pootočenie v kladnom smere vykompenzuje predchádzajúce
        // prvé záporné pootočenie, no zároveň robot pootočí o ďalší úsek
        // v kladnom smere (doľava):
        vľavo(uhol1 + uhol2);

        // Prvé rekurzívne volanie – tu nastáva vetvenie rastlinky vľavo:
        rastlinka(dĺžka - Svet.náhodnéReálneČíslo(5, 16));

        // Posledné pootočenie vykompenzuje poslednú zmenu orientácie na nulu:
        vpravo(uhol2);

        // Nakoniec vrátime zmenu polohy tak, aby sa robot vrátil do svojej
        // východiskovej polohy. Musíme to urobiť až po vykompenzovaní
        // všetkých zmien orientácie, inak by sa robot vrátil na iné miesto.
        // Vďaka dodržaniu hlavnej zásady si nemusíme robiť starosti s tým,
        // čo sa udeje s polohou a orientáciou robota počas rekurzívneho
        // volania pretože práve dodržanie tejto zásady zabezpečí, že po
        // návrate z rekurzívneho volania bude poloha a orientácia robota
        // zachovaná. Z pohľadu orientácie a polohy sa rekurzívnym volaním
        // nič nezmenilo. Bez tohto faktu by sa s týmto typom fraktálneho
        // kreslenia vôbec nedalo pracovať. Práve preto je zásada uvedená
        // na začiatku klasifikovaná ako hlavná. 
        zdvihniPero();
        dozadu(dĺžka);
    }

    // Tento atribút slúži na číslovanie verzií uložených grafických súborov.
    private static int n = 0;

    // Táto metóda slúži na uloženie ďalšej verzie vygenerovaného obrázka
    // v dvoch formátoch – PNG a HTML obsahujúce SVG definície.
    private static void uložĎalšíObrázok(String názov)
    {
        // Keďže v tomto príklade je implementované automatické
        // prekresľovanie časovačom, je potrebné pred uložením
        // prekresliť svet. Mohlo by sa totiž stať, že fáza ukladania
        // by predbehla fázu prekreslenia, takže by sa do súboru vo formáte
        // PNG uložil neúplný obrázok (SVG údaje sú vkladané do objektu
        // svgPodpora priebežne a nesúvisia s prekresľovaním).
        Svet.prekresli();

        // Zápis cyklu „for“ s chýbajúcim podmieneným výrazom (nižšie) znamená
        // „nekonečný cyklus.“ Žiadny cyklus nesmie byť pri programovaní
        // nekonečný! Spôsobovalo by to uviaznutie. Aj v tomto prípade nejde
        // o skutočný nekonečný cyklus, ale o cyklus, na ktorom sa usilujeme
        // ukázať také opakovanie, ktorého podmienky ukončenia nie je možné
        // zapísať v tvare logických (booleovských) výrazov.
        // 
        // V tomto prípade ide o to, aby sa cyklus ukončil až po úspešnom
        // zápise obidvoch grafických súborov – PNG a HTML obsahujúce SVG
        // definície (ďalej HTML/SVG). To znamená, že ďalšia iterácia
        // nastáva iba v prípade neúspešného zápisu jedného zo súborov.
        // Ak zlyhá zápis PNG súboru, tak vznikne výnimka, o ktorej je
        // poslaná krátka správa na chybový konzolový výstup (err)
        // a pokračuje sa ďalšou iteráciou. Ak zlyhá zápis HTML/SVG
        // súboru, tak sa preruší vykonávanie aktuálnej iterácie
        // (a akoby mimochodom sa vymaže práve zapísaný PNG súbor, aby
        // vo výsledku obsahy oboch typov súborov korešpondovali – je to
        // obeť princípu – takáto situácia môže nastať v takom prípade,
        // ak používateľ vymaže niektorý PNG súbor, ale ponechá HTML/SVG
        // súbor, inak by nastať nemala) a pokračuje sa nasledujúcou
        // iteráciou. Ak nezlyhá zápis ani jedného súboru, tak je činnosť
        // metódy ukončená. V každom z uvedených prípadov je vykonaný blok
        // finally, v ktorom nastáva zvyšovanie hodnoty počítadla n (ktoré
        // slúži na číslovanie verzií ukladaných súborov). Celý tento
        // relatívne komplikovaný (prinajmenšom komplikovane znejúci)
        // mechanizmus vedie k nasledujúcemu výslednému efektu:
        // 
        // Predpokladajme, že program je spustený prvý raz a nemá šancu
        // jestvovať ani jeden súbor s obrázkom (PNG alebo HTML/SVG). Ak
        // sa nevyskytne žiadny nepredvídateľný problém (napr. hardvérové
        // zlyhanie), tak budú obidva súbory (.png a ) korektne
        // zapísané, metóda bude hneď po prvom pokuse (to jest prvej
        // iterácii „nekonečného cyklu“) ukončená, no ešte pred skončením
        // stihne aktualizovať hodnotu počítadla n (to jest zvýšiť ju
        // o jeden v bloku finally, pretože blok finally má to výsostné
        // postavenie, že je vykonaný vždy).
        // 
        // Teraz predpokladajme, že program je spustený n-tý raz a jestvuje
        // bližšie neurčený počet uložených PNG a HTML/SVG súborov. Zápis
        // PNG súboru bude zlyhávať, dokedy bude jestvovať súbor s aktuálnym
        // poradovým číslom, pričom po každom ďalšom pokuse sa poradové
        // číslo zvýši o jeden. Pri prvom poradovom čísle, pre ktoré nebude
        // jestvovať prislúchajúci súbor zápis uspeje a ďalej sa bude
        // pokračovať tak ako v predchádzajúcom prípade. Algoritmus bude
        // úspešný aj v prípade, že by príčina zlyhania bola iná. Ukončí
        // sa jednoducho pri prvom úspechu.
        // 
        // Aby sme zamedzili uviaznutiu v nekonečnom cykle v takom prípade,
        // keď je cieľové umiestnenie súborov na zápis chránené proti zápisu,
        // je vo vetve catch umiestnená kontrola, ktorá overí, či súbor
        // s aktuálnym poradovým číslom jestvuje. Ak nie, znamená to, že
        // príčina zlyhania bola zrejme iná a vykonávanie metódy bude
        // predčasne ukončené. Algoritmus by vďaka tejto kontrole nemal
        // uviaznuť.
        // 
        // Implementácia tohto algoritmu by samozrejme mohla byť aj iná, no
        // cieľom bolo ukázať možnosť vytvorenia takého cyklu, ktorý nie je
        // riadený výhradne booleovskými podmienkami.
        for (;;)
        {
            try
            {
                // Pokus o uloženie PNG súboru.
                Svet.uložObrázok(názov + "-" + n + ".png");

                // Pokus o uloženie HTML/SVG súboru.
                if (-1 == svgPodpora.zapíš(názov + "-" + n + ".html"))
                {
                    Súbor.vymaž(názov + "-" + n + ".png");
                    continue;
                }

                // Ukončenie – sem sa vykonávanie algoritmu dostane len
                // ak boli obidva zápisy úspešné.
                return;
            }
            catch (Throwable t)
            {
                // Oznámenie o chybe na chybovú konzolu.
                System.err.println(t.getMessage());

                // Test uviaznutia pri jednotke chránenej na zápis.
                if (!Súbor.jestvuje(názov + "-" + n + ".png"))
                {
                    // Oznámenie možnej príčiny a ukončenie.
                    System.err.println("Disk je pravdepodobne " +
                        "chránený proti zápisu!");
                    return;
                }
            }
            finally
            {
                // Tento príkaz sa vykoná na konci každej iterácie, ale aj
                // tesne pred skončením metódy (popri vykonaní príkazu
                // return). Zabezpečuje postupné zvyšovanie hodnoty
                // atribútu n, ktorý slúži na číslovanie zapisovaných súborov.
                ++n;
            }
        }
    }

    // Hlavná metóda.
    public static void main(String... args)
    {
        Svet.použiKonfiguráciu("svg-rastlinka.cfg");

        try
        {
            // Spustenie časomiery, vygenerovanie rastlinky
            // a zastavenie časomiery:
            Svet.spustiČasomieru();
            new SVGRastlinka();
            double čas = Svet.zastavČasomieru();

            // Uloženie vygenerovanej rastlinky do súborov vo formátoch
            // PNG a HTML/SVG:
            uložĎalšíObrázok("rastlinka");

            // Vypísanie výsledku merania (času) na konzolu sveta
            // a systémovú konzolu:
            Svet.vypíšRiadok("Kreslenie rastlinky trvalo: ", čas, "s");
            System.out.println("Kreslenie rastlinky trvalo: " + čas + " s");

            // Uloženie textov (momentálne jediného riadka) konzoly sveta
            // do schránky operačného systému:
            Svet.textyDoSchránky();
        }
        catch (Throwable t)
        {
            // Oznámenie o prípadnej chybe:
            t.printStackTrace();
        }
    }
}

Výsledok:

Ukážka možného výstupu
(výsledný HTML súbor si môžete pozrieť tu).

Táto trieda umožňuje aj veľmi primitívne spracovanie textových SVG definícií. So zreteľom na široké možnosti štandardu SVG na prezentáciu textových (znakových) informácií sú možnosti tejto triedy skutočne primitívne. Ide v podstate len o prečítanie a zápis obsahu značky <text> a o poskytnutie základných geometrických transformácií.

Jeden celkom užitočný príklad použitia SVG podpory je v opise metódy vajce.

Použité zdroje:

• Andronikos, Nikos (Canon, Inc.) – Atanassov, Rossen (Microsoft Co.) – Bah, Tavmjong (Invited Expert) – Bellamy-Royds, Amelia (Invited Expert) – Birtles, Brian (Mozilla Japan) – Brinza, Bogdan (Microsoft Co.) – Concolato, Cyril (Telecom ParisTech) – Dahlström, Erik (Invited Expert) – Lilley, Chris (W3C) – McCormack, Cameron (Mozilla Corporation) – Schepers, Doug (W3C) – Schulze, Dirk (Adobe Systems) – Schwerdtfeger, Richard (IBM) – Takagi, Satoru (KDDI Corporation) – Watt, Jonathan (Mozilla Corporation): Scalable Vector Graphics (SVG) 2. W3C Editor’s Draft 10 July 2016. Copyright © 2016 W3C^® (MIT, ERCIM, Keio, Beihang). W3C liability, trademark and document use rules apply. Citované: 2016 – 2018.
• Andronikos, Nikos (Canon, Inc.) – Atanassov, Rossen (Microsoft Co.) – Bah, Tavmjong (Invited Expert) – Bellamy-Royds, Amelia (Invited Expert) – Birtles, Brian (Mozilla Japan) – Brinza, Bogdan (Microsoft Co.) – Concolato, Cyril (Telecom ParisTech) – Dahlström, Erik (Invited Expert) – Lilley, Chris (W3C) – McCormack, Cameron (Mozilla Corporation) – Schepers, Doug (W3C) – Schulze, Dirk (Adobe Systems) – Schwerdtfeger, Richard (IBM) – Takagi, Satoru (KDDI Corporation) – Watt, Jonathan (Mozilla Corporation): Scalable Vector Graphics (SVG) 2. W3C Working Draft 15 September 2015. Copyright © 2015 W3C^® (MIT, ERCIM, Keio, Beihang). W3C liability, trademark and document use rules apply. Citované: 2016 – 2018.
• SVG Tutorial. W3Schools.com.
• Buck, Warren: Goniometric formulas. Planetmath.org, 2007.
• Weisstein, Eric W.: Ellipse. Wolfram MathWorld.
• User:Dilma – User:Kevin: How to calculate the tangent angle with the axis of an ellipse? Mathematics Stack Exchange (calculus), 2013.
• (Zdroje citované: 2016 – 2018.)

Prehľad vnorených tried

Vnorené triedy

Modifikátor a typ	Trieda a opis
class	SVGPodpora.Spracovanie
static class	SVGPodpora.Transformacia Alias pre Transformácia.
static class	SVGPodpora.Transformácia Táto trieda slúži na uchovanie pôvodných informácií o transformáciách rozpoznávaných z textovej podoby podľa špecifikácie SVG.

Prehľad atribútov

Atribúty

Modifikátor a typ	Atribút a opis
SVGPodpora.Spracovanie	spracovanie

Prehľad konštruktorov

Konštruktory

Konštruktor a opis
SVGPodpora()

Prehľad metód

Modifikátor a typ	Metóda a opis
static String	alfaNaRetazec(Color farba) Alias pre alfaNaReťazec.
static String	alfaNaReťazec(Color farba) Vyjme zo zadanej inštancie farby hodnotu úrovne priehľadnosti a prevedie ju na reťazec v rozsahu 0.0 až 1.0.
static String	alfaNaRetazec(Farebnosť farba) Alias pre alfaNaReťazec.
static String	alfaNaReťazec(Farebnosť farba) Vyjme zo zadanej implementácie farebnosti hodnotu úrovne priehľadnosti a prevedie ju na reťazec v rozsahu 0.0 až 1.0.
int	citaj(String meno) Alias pre čítaj.
int	čítaj(String meno) Metóda postupne analyzuje XML údaje v zadanom SVG súbore (meno) a do vnútorného zásobníka uloží všetky tvary, ktoré v rámci analyzovaných údajov nájde a to bez ohľadu na ich umiestnenie vo vrstvách, skupinách alebo v rámci definícií takzvaných značiek (angl. marker) a podobne.
Shape	daj(int index) Poskytne netransformovaný tvar uložený vo vnútornom zásobníku tejto inštancie so zadaným „poradovým číslom,“ respektíve indexom.
String	dajAtribut(int index, String meno) Alias pre dajAtribút.
String	dajAtribút(int index, String meno) Poskytne hodnotu atribútu asociovaného s tvarom so zadaným indexom.
String	dajAtributVymedzenia(int index, String meno) Alias pre dajAtribútVymedzenia.
String	dajAtribútVymedzenia(int index, String meno) Poskytne hodnotu atribútu asociovaného s objektom vymedzenia so zadaným indexom.
String[]	dajAtributy(int index) Alias pre dajAtribúty.
String[]	dajAtribúty(int index) Poskytne zoznam názvov atribútov asociovaných s tvarom so zadaným indexom.
String[]	dajAtributyVymedzenia(int index) Alias pre dajAtribútyVymedzenia.
String[]	dajAtribútyVymedzenia(int index) Poskytne zoznam názvov atribútov asociovaných s vymedzením so zadaným indexom.
String	dajOrezanie(Shape klip) Vráti odkaz na orezanie, ktoré je definované v špeciálnych definíciách tejto SVG inštancie podľa zadaného tvaru.
Shape	dajPovodny(int index) Alias pre daj.
Shape	dajPôvodný(int index) Alias pre daj.
String	dajSVG() Metóda exportuje tvary uložené vo vnútornom zásobníku tejto inštancie do formátu SVG.
String	dajSVG(int index) Vráti XML/SVG reprezentáciu tvaru uloženého vo vnútornom zásobníku tejto inštancie so zadaným poradovým číslom, resp.
String	dajSVG(String formát) Metóda exportuje tvary uložené vo vnútornom zásobníku tejto inštancie do formátu SVG.
String	dajSVG(String formát, String titulok) Táto metóda slúži na export všetkých tvarov uložených vo vnútornom zásobníku tejto inštancie do formátu SVG.
Object	dajVymedzenie(int index) Poskytne objekt vymedzenia uložený vo vnútornom zásobníku tejto inštancie so zadaným „poradovým číslom,“ respektíve indexom.
Shape	dajVysledny(int index) Alias pre dajVýsledný.
Shape	dajVýsledný(int index) Poskytne transformovaný tvar, ktorý je uložený vo vnútornom zásobníku tejto inštancie pod zadaným „poradovým číslom,“ respektíve indexom (čiže nula označuje prvý tvar v zásobníku).
Shape	dajVysledny(int index, AffineTransform[] transformácie) Alias pre dajVýsledný.
Shape	dajVýsledný(int index, AffineTransform[] transformácie) Táto metóda pracuje rovnako ako metóda dajVýsledný(index, transformácia[, transformácie]), ale transformácie sú zadané v tvare poľa objektov triedy AffineTransform.
Shape	dajVysledny(int index, AffineTransform transformácia, AffineTransform... transformácie) Alias pre dajVýsledný.
Shape	dajVýsledný(int index, AffineTransform transformácia, AffineTransform... transformácie) Táto metóda pracuje rovnako ako metóda dajVýsledný, ale namiesto prípadných vnútorne definovaných transformácií použije transformácie zadané vo forme objektov triedy AffineTransform, čiže v tomto prípade je podľa typu objektu zrejmé, že ide o 2D transformácie.
Shape	dajVysledny(int index, String[] transformácie) Alias pre dajVýsledný.
Shape	dajVýsledný(int index, String[] transformácie) Táto metóda pracuje rovnako ako metóda dajVýsledný(index, transformácia[, transformácie]), ale transformácie sú zadané v tvare poľa reťazcov.
Shape	dajVysledny(int index, String transformácia, String... transformácie) Alias pre dajVýsledný.
Shape	dajVýsledný(int index, String transformácia, String... transformácie) Táto metóda pracuje rovnako ako metóda dajVýsledný, ale namiesto prípadných vnútorne definovaných transformácií použije 2D transformácie zadané v argumentoch v tvare reťazcov v súlade so špecifikáciou SVG.
Shape	dajVysledny(int index, SVGPodpora.Transformácia[] transformácie) Alias pre dajVýsledný.
Shape	dajVýsledný(int index, SVGPodpora.Transformácia[] transformácie) Táto metóda pracuje rovnako ako metóda dajVýsledný(index, transformácia[, transformácie]), ale transformácie sú zadané v tvare poľa objektov triedy Transformácia.
Shape	dajVysledny(int index, SVGPodpora.Transformácia transformácia, SVGPodpora.Transformácia... transformácie) Alias pre dajVýsledný.
Shape	dajVýsledný(int index, SVGPodpora.Transformácia transformácia, SVGPodpora.Transformácia... transformácie) Táto metóda pracuje rovnako ako metóda dajVýsledný, ale namiesto prípadných vnútorne definovaných transformácií použije transformácie zadané vo forme objektov triedy Transformácia (ktorá slúži na uchovanie informácií o rozpoznaných 2D SVG transformáciách).
static Shape	dajVysledny(Shape tvar, AffineTransform[] transformácie) Alias pre dajVýsledný.
static Shape	dajVýsledný(Shape tvar, AffineTransform[] transformácie) Táto metóda pracuje rovnako ako metóda dajVýsledný(index, transformácia[, transformácie]), ale transformácie sú zadané v tvare poľa objektov typu AffineTransform.
static Shape	dajVysledny(Shape tvar, AffineTransform transformácia, AffineTransform... transformácie) Alias pre dajVýsledný.
static Shape	dajVýsledný(Shape tvar, AffineTransform transformácia, AffineTransform... transformácie) Táto metóda umožňuje transformovať ľubovoľný tvar (Shape) Javy podľa 2D transformácií zadaných vo forme objektov typu AffineTransform.
Shape	dajVysledny(Shape tvar, String[] transformácie) Alias pre dajVýsledný.
Shape	dajVýsledný(Shape tvar, String[] transformácie) Táto metóda pracuje rovnako ako metóda dajVýsledný(index, transformácia[, transformácie]), ale transformácie sú zadané v tvare poľa reťazcov.
Shape	dajVysledny(Shape tvar, String transformácia, String... transformácie) Alias pre dajVýsledný.
Shape	dajVýsledný(Shape tvar, String transformácia, String... transformácie) Táto metóda umožňuje transformovať ľubovoľný tvar (Shape) Javy podľa 2D transformácií zadaných v tvare reťazcov v súlade so špecifikáciou SVG.
static Shape	dajVysledny(Shape tvar, SVGPodpora.Transformácia[] transformácie) Alias pre dajVýsledný.
static Shape	dajVýsledný(Shape tvar, SVGPodpora.Transformácia[] transformácie) Táto metóda pracuje rovnako ako metóda dajVýsledný(index, transformácia[, transformácie]), ale transformácie sú zadané v tvare poľa objektov typu Transformácia.
static Shape	dajVysledny(Shape tvar, SVGPodpora.Transformácia transformácia, SVGPodpora.Transformácia... transformácie) Alias pre dajVýsledný.
static Shape	dajVýsledný(Shape tvar, SVGPodpora.Transformácia transformácia, SVGPodpora.Transformácia... transformácie) Táto metóda umožňuje transformovať ľubovoľný tvar (Shape) Javy podľa 2D transformácií zadaných vo forme objektov typu Transformácia.
Vector<String>	definicie() Alias pre definície.
Vector<String>	definície() Vráti aktuálny zoznam (zásobník) špeciálnych definícií tejto SVG inštancie.
Farba	farbaCiary(int index) Alias pre farbaČiary.
void	farbaCiary(int index, Color farba) Alias pre farbaČiary.
Farba	farbaČiary(int index) Pokúsi sa zistiť farbu čiary tvaru asociovaného so zadaným indexom.
void	farbaČiary(int index, Color farba) Nastaví novú farbu čiary tvaru asociovanému so zadaným indexom.
static String	farbaNaRetazec(Color farba, boolean ignorujAlfu) Alias pre farbaNaReťazec.
static String	farbaNaReťazec(Color farba, boolean ignorujAlfu) Prevedie zadanú inštanciu farby do textovej podoby používanej v rámci jazykov HTML, CSS a teda aj SVG.
static String	farbaNaRetazec(Farebnosť farba, boolean ignorujAlfu) Alias pre farbaNaReťazec.
static String	farbaNaReťazec(Farebnosť farba, boolean ignorujAlfu) Prevedie zadanú implementáciu farebnosti do textovej podoby používanej v rámci jazykov HTML, CSS a teda aj SVG.
Farba	farbaVyplne(int index) Alias pre farbaVýplne.
Farba	farbaVýplne(int index) Pokúsi sa zistiť farbu výplne tvaru asociovaného so zadaným indexom.
void	farbaVyplne(int index, Color farba) Alias pre farbaVýplne.
void	farbaVýplne(int index, Color farba) Nastaví novú farbu výplne tvaru asociovanému so zadaným indexom.
double	hrubkaCiary(int index) Alias pre hrúbkaČiary.
void	hrubkaCiary(int index, double hrúbka) Alias pre hrúbkaČiary.
double	hrúbkaČiary(int index) Pokúsi sa zistiť hrúbku čiary tvaru asociovaného so zadaným indexom.
void	hrúbkaČiary(int index, double hrúbka) Nastaví novú hrúbku čiary tvaru asociovanému so zadaným indexom.
String[]	htmlSablona() Alias pre htmlŠablóna.
boolean	htmlSablona(String[] šablóna) Alias pre htmlŠablóna.
String[]	htmlŠablóna() Táto metóda umožňuje zistiť aktuálny tvar šablóny HTML súboru.
boolean	htmlŠablóna(String[] šablóna) Táto metóda slúži na nastavenie nového tvaru šablóny HTML súboru.
double	koeficient(String jednotka) Táto metóda umožňuje overiť hodnotu koeficientu prevodu jednotky číselnej hodnoty (pozri opis metódy reťazecNaČíslo).
void	koeficient(String jednotka, double hodnota) Táto metóda umožňuje upraviť koeficient prevodu jednotky číselnej hodnoty (pozri opis metódy reťazecNaČíslo).
String	konverziaDoubleNaString(double hodnota) Prevedie hodnotu z údajového typu double do reťazcového tvaru.
void	nahradAtribut(int index, String meno, Object hodnota) Alias pre prepíšAtribút.
void	nahraďAtribút(int index, String meno, Object hodnota) Alias pre prepíšAtribút.
void	nahradAtributVymedzenia(int index, String meno, Object hodnota) Alias pre prepíšAtribútVymedzenia.
void	nahraďAtribútVymedzenia(int index, String meno, Object hodnota) Alias pre prepíšAtribútVymedzenia.
void	nahradTvar(int index, Shape tvar) Alias pre prepíšTvar.
void	nahraďTvar(int index, Shape tvar) Alias pre prepíšTvar.
void	nahradVymedzenie(int index, Object vymedzenie) Alias pre prepíšVymedzenie.
void	nahraďVymedzenie(int index, Object vymedzenie) Alias pre prepíšVymedzenie.
void	nastavAtribut(int index, String meno, Object hodnota) Alias pre prepíšAtribút.
void	nastavAtribút(int index, String meno, Object hodnota) Alias pre prepíšAtribút.
void	nastavAtributVymedzenia(int index, String meno, Object hodnota) Alias pre prepíšAtribútVymedzenia.
void	nastavAtribútVymedzenia(int index, String meno, Object hodnota) Alias pre prepíšAtribútVymedzenia.
void	nastavTvar(int index, Shape tvar) Alias pre prepíšTvar.
void	nastavVymedzenie(int index, Object vymedzenie) Alias pre prepíšVymedzenie.
Paint	naterCiary(int index) Alias pre náterČiary.
Paint	náterČiary(int index) Pokúsi sa zistiť typ náteru čiary tvaru asociovaného so zadaným indexom.
String	naterNaRetazec(Paint náter) Alias pre náterNaReťazec.
String	náterNaReťazec(Paint náter) Pokúsi sa previesť zadaný náter do reťazcovej podoby – do definície podľa štandardu SVG.
String	naterPodlaObrazka(Image obrázok) Alias pre náterPodľaObrázka.
String	náterPodľaObrázka(Image obrázok) Zatiaľ neimplementované!
Paint	naterVyplne(int index) Alias pre náterVýplne.
Paint	náterVýplne(int index) Pokúsi sa zistiť typ náteru výplne tvaru asociovaného so zadaným indexom.
int	pocet() Alias pre počet.
int	pocetVymedzeni() Alias pre početVymedzení.
int	počet() Vráti počet tvarov, ktoré sú momentálne uskladnené v tejto inštancii (v jej vnútornom zásobníku) podpory SVG formátu.
int	početVymedzení() Vráti počet vymedzení, ktoré sú momentálne prítomné v tejto inštancii podpory SVG formátu.
void	prepisAtribut(int index, String meno, Object hodnota) Alias pre prepíšAtribút.
void	prepisAtributVymedzenia(int index, String meno, Object hodnota) Alias pre prepíšAtribútVymedzenia.
void	prepisTvar(int index, Shape tvar) Alias pre prepíšTvar.
void	prepisVymedzenie(int index, Object vymedzenie) Alias pre prepíšVymedzenie.
void	prepíšAtribút(int index, String meno, Object hodnota) Prepíše, vloží novú alebo odstráni hodnotu atribútu asociovaného s tvarom so zadaným indexom.
void	prepíšAtribútVymedzenia(int index, String meno, Object hodnota) Prepíše, vloží novú alebo odstráni hodnotu atribútu asociovaného s vymedzením so zadaným indexom.
void	prepíšTvar(int index, Shape tvar) Prepíše tvar určený indexom v rámci vnútorného zásobníka tvarov.
void	prepíšVymedzenie(int index, Object vymedzenie) Prepíše objekt vymedzenia určený indexom v rámci vnútorného zásobníka vymedzení.
static Shape	presunDoStredu(Shape tvar) Alias pre presuňDoStredu.
static Shape	presuňDoStredu(Shape tvar) Táto statická metóda vyrobí transformovanú verziu zadaného tvaru tak, aby nové súradnice jeho „stredu“ ležali v strede súradnicovej sústavy programovacieho rámca GRobot.
void	pridaj(Shape tvar, GRobot tvorca, String... atribúty) Vloží do vnútorného zásobníka tejto inštancie ďalší tvar so základnými atribútmi (ťah a/alebo výplň) nastavenými podľa zadaného tvorcu a s prípadnou doplňujúcou sériou atribútov.
void	pridaj(Shape tvar, String... atribúty) Vloží do vnútorného zásobníka tejto inštancie ďalší tvar s prípadnou sériou atribútov.
void	pridajObrazok(Image obrázok, GRobot tvorca, String... atribúty) Alias pre pridajObrázok.
void	pridajObrázok(Image obrázok, GRobot tvorca, String... atribúty) Zatiaľ neimplementované!
void	pridajObrazok(Image obrázok, String... atribúty) Alias pre pridajObrázok.
void	pridajObrázok(Image obrázok, String... atribúty) Zatiaľ neimplementované!
int	pridajSVG(String xmlSVG) Spracuje zadaný reťazec ako súčasť SVG definície a v prípade, že sú nájdené korektné XML/SVG údaje tvarov, pribudnú podľa nich do vnútorného zásobníka tejto inštancie ďalšie tvary.
void	pridajText(String text, GRobot tvorca, String... atribúty) Vloží do vnútorného zásobníka tejto inštancie nový tvar reprezentujúci text (znaky, textovú informáciu) s prípadnou sériou atribútov.
void	pridajText(String text, String... atribúty) Vloží do vnútorného zásobníka tejto inštancie nový tvar reprezentujúci text (znaky, textovú informáciu) s prípadnou sériou atribútov.
void	pridajTransformacie(int index, AffineTransform[] transformácie) Alias pre pridajTransformácie.
void	pridajTransformácie(int index, AffineTransform[] transformácie) Pridá k vnútornému atribútu transformácií (‚transform‘) tvaru určeného indexom transformácie podľa hodnôt prvkov zadaného poľa objektov afinných transformácií.
void	pridajTransformacie(int index, AffineTransform transformácia, AffineTransform... transformácie) Alias pre pridajTransformácie.
void	pridajTransformácie(int index, AffineTransform transformácia, AffineTransform... transformácie) Pridá k vnútornému atribútu transformácií (‚transform‘) tvaru určeného indexom transformácie podľa zadaného objektu alebo série objektov afinných transformácií.
void	pridajTransformacie(int index, String[] transformácie) Alias pre pridajTransformácie.
void	pridajTransformácie(int index, String[] transformácie) Pridá k vnútornému atribútu transformácií (‚transform‘) tvaru určeného indexom transformácie podľa hodnôt prvkov zadaného poľa reťazcov.
void	pridajTransformacie(int index, String transformácia, String... transformácie) Alias pre pridajTransformácie.
void	pridajTransformácie(int index, String transformácia, String... transformácie) Pridá k vnútornému atribútu transformácií (‚transform‘) tvaru určeného indexom transformácie podľa zadaného reťazca alebo série reťazcov.
void	pridajTransformacie(int index, SVGPodpora.Transformácia[] transformácie) Alias pre pridajTransformácie.
void	pridajTransformácie(int index, SVGPodpora.Transformácia[] transformácie) Pridá k vnútornému atribútu transformácií (‚transform‘) tvaru určeného indexom transformácie podľa hodnôt prvkov zadaného poľa objektov afinných transformácií.
void	pridajTransformacie(int index, SVGPodpora.Transformácia transformácia, SVGPodpora.Transformácia... transformácie) Alias pre pridajTransformácie.
void	pridajTransformácie(int index, SVGPodpora.Transformácia transformácia, SVGPodpora.Transformácia... transformácie) Pridá k vnútornému atribútu transformácií (‚transform‘) tvaru určeného indexom transformácie podľa zadaného objektu alebo série objektov afinných transformácií.
void	pridajUsecku(GRobot tvorca, String... atribúty) Alias pre pridajÚsečku.
void	pridajÚsečku(GRobot tvorca, String... atribúty) Pridá úsečku vymedzenú posledným navštíveným bodom tvorcu a jeho aktuálnou polohou.
void	pridajVymedzenie(Object vymedzenie, String... atribúty) Vloží do vnútorného zásobníka tejto inštancie ďalšie vymedzenie s prípadnou sériou atribútov.
SVGPodpora.Transformacia[]	retazceNaTransformacie(String... texty) Alias pre reťazceNaTransformácie.
SVGPodpora.Transformácia[]	reťazceNaTransformácie(String... texty) Táto metóda slúži na prevod 2D transformácií zadaných v textovej podobe v tvare, ktorý je v súlade so špecifikáciou SVG.
double	retazecNaCislo(String hodnota) Alias pre reťazecNaČíslo.
double	reťazecNaČíslo(String hodnota) Zabezpečí prevod reťazca na číslo (bez vzniku chyby) s vyhľadaním a prepočítaním prípadných jednotiek používaných v jazykoch HTML, CSS a teda aj SVG (uvedených za číselnou hodnotou v reťazcovom tvare).
static Farba	retazecNaFarbu(String text, String alfa) Alias pre reťazecNaFarbu.
static Farba	reťazecNaFarbu(String text, String alfa) Prevedie zadaný reťazec reprezentujúci farbu vo formátoch používaných jazykmi HTML, CSS a teda aj SVG na inštanciu farby programovacieho rámca.
SVGPodpora.Transformacia	retazecNaTransformaciu(String text) Alias pre reťazecNaTransformáciu.
SVGPodpora.Transformácia	reťazecNaTransformáciu(String text) Táto metóda očakáva reťazec s jedinou 2D transformáciou, ktorý prevedie na objekt typu Transformácia.
double[]	rozmerKresby() Vypočíta aktuálny rozmer kresby (šírku a výšku) a vráti ho v prvých dvoch prvkoch poľa typu double.
Bod	stredKresby() Vypočíta súradnice stredu kresby a vráti ich v inštancii triedy Bod.
Vector<String>	styl() Alias pre štýl.
String[]	svgSablona() Alias pre svgŠablóna.
boolean	svgSablona(String[] šablóna) Alias pre svgŠablóna.
String[]	svgŠablóna() Táto metóda umožňuje zistiť aktuálny tvar šablóny SVG súboru.
boolean	svgŠablóna(String[] šablóna) Táto metóda slúži na nastavenie nového tvaru šablóny SVG súboru.
Vector<String>	štýl() Vráti aktuálny zoznam (zásobník) definícií štýlov (CSS) tejto SVG inštancie.
SVGPodpora.Transformacia[]	transformacie(int index) Alias pre transformácie.
SVGPodpora.Transformácia[]	transformácie(int index) Vráti zoznam transformácií v poli objektov typu Transformácia, ktoré sú priradené k indexom určenému tvaru prostredníctvom vnútorného atribútu ‚transform‘.
void	transformacie(int index, AffineTransform[] transformácie) Alias pre transformácie.
void	transformácie(int index, AffineTransform[] transformácie) Nastaví alebo odstráni vnútorný atribút transformácií (‚transform‘) tvaru určeného indexom podľa hodnôt prvkov zadaného poľa objektov afinných transformácií.
void	transformacie(int index, AffineTransform transformácia, AffineTransform... transformácie) Alias pre transformácie.
void	transformácie(int index, AffineTransform transformácia, AffineTransform... transformácie) Nastaví alebo odstráni vnútorný atribút transformácií (‚transform‘) tvaru určeného indexom podľa zadaného objektu alebo série objektov afinných transformácií.
void	transformacie(int index, String[] transformácie) Alias pre transformácie.
void	transformácie(int index, String[] transformácie) Nastaví alebo odstráni vnútorný atribút transformácií (‚transform‘) tvaru určeného indexom podľa hodnôt prvkov zadaného poľa reťazcov.
void	transformacie(int index, String transformácia, String... transformácie) Alias pre transformácie.
void	transformácie(int index, String transformácia, String... transformácie) Nastaví alebo odstráni vnútorný atribút transformácií (‚transform‘) tvaru určeného indexom podľa hodnoty zadaného reťazca alebo série reťazcov.
void	transformacie(int index, SVGPodpora.Transformácia[] transformácie) Alias pre transformácie.
void	transformácie(int index, SVGPodpora.Transformácia[] transformácie) Nastaví alebo odstráni vnútorný atribút transformácií (‚transform‘) tvaru určeného indexom podľa hodnôt prvkov zadaného poľa objektov afinných transformácií.
void	transformacie(int index, SVGPodpora.Transformácia transformácia, SVGPodpora.Transformácia... transformácie) Alias pre transformácie.
void	transformácie(int index, SVGPodpora.Transformácia transformácia, SVGPodpora.Transformácia... transformácie) Nastaví alebo odstráni vnútorný atribút transformácií (‚transform‘) tvaru určeného indexom podľa zadaného objektu alebo série objektov afinných transformácií.
static String	transformacieNaRetazec(AffineTransform... transformácie) Alias pre transformácieNaReťazec.
static String	transformácieNaReťazec(AffineTransform... transformácie) Táto metóda slúži na prevod objektov typu AffineTransform do textovej podoby (tak, aby bola v súlade so špecifikáciou SVG).
static String	transformacieNaRetazec(SVGPodpora.Transformácia... transformácie) Alias pre transformácieNaReťazec.
static String	transformácieNaReťazec(SVGPodpora.Transformácia... transformácie) Táto metóda slúži na prevod informácií uložených v ľubovoľnom počte objektov typu Transformácia do textovej podoby, ktorá je v súlade so špecifikáciou SVG.
static String	transformaciuNaRetazec(AffineTransform transformácia) Alias pre transformáciuNaReťazec.
static String	transformáciuNaReťazec(AffineTransform transformácia) Táto metóda prevedie objekte typu AffineTransform do textovej podoby v súlade so špecifikáciou SVG.
static String	transformaciuNaRetazec(SVGPodpora.Transformácia transformácia) Alias pre transformáciuNaReťazec.
static String	transformáciuNaReťazec(SVGPodpora.Transformácia transformácia) Táto metóda je doplnkom k metóde reťazecNaTransformáciu, prevádza informácie uložené v objekte typu Transformácia do textovej podoby v súlade so špecifikáciou SVG.
void	vymaz() Alias pre vymaž.
void	vymaz(int index) Alias pre vymaž.
void	vymazVymedzenie(int index) Alias pre vymažVymedzenie.
void	vymaž() Vyčistí vnútorné zásobníky tvarov a definícií, vymedzení a štýlu tejto inštancie.
void	vymaž(int index) Odstráni tvar tejto inštancie so zadaným indexom.
void	vymažVymedzenie(int index) Odstráni vymedzenie tejto inštancie so zadaným indexom.
int	zapis(String meno) Alias pre zapíš.
int	zapis(String meno, String titulok) Alias pre zapíš.
int	zapis(String meno, String titulok, boolean prepísať) Alias pre zapíš.
int	zapíš(String meno) Metóda exportuje tvary uložené vo vnútornom zásobníku tejto inštancie do formátu SVG.
int	zapíš(String meno, String titulok) Metóda exportuje tvary uložené vo vnútornom zásobníku tejto inštancie do formátu SVG.
int	zapíš(String meno, String titulok, boolean prepísať) Táto metóda slúži na export tvarov uložených vo vnútornom zásobníku tejto inštancie do formátu SVG.
String[]	zoznamAtributov(int index) Alias pre zoznamAtribútov.
String[]	zoznamAtribútov(int index) Poskytne zoznam názvov atribútov asociovaných s tvarom so zadaným indexom.
String[]	zoznamAtributovVymedzenia(int index) Alias pre zoznamAtribútovVymedzenia.
String[]	zoznamAtribútovVymedzenia(int index) Poskytne zoznam názvov atribútov asociovaných s vymedzením so zadaným indexom.

Metódy zdedené z triedy java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Podrobnosti atribútov

spracovanie

public final SVGPodpora.Spracovanie spracovanie

Podrobnosti konštruktorov

SVGPodpora

public SVGPodpora()

Podrobnosti metód

reťazecNaTransformáciu

public SVGPodpora.Transformácia reťazecNaTransformáciu(String text)

Táto metóda očakáva reťazec s jedinou 2D transformáciou, ktorý prevedie na objekt typu Transformácia. Volajúca metóda musí zabezpečiť, aby bola táto podmienka dodržaná – je na jej zodpovednosti, aby napríklad rozdelila prípadnú sériu 2D transformácií, z ktorých sa môže skladať atribút ‚transform‘ špecifikácie SVG na jednotlivé celky. (Toto obmedzenie je dôležité v súvislosti s typom návratovej hodnoty – metóda dokáže poskytnúť informácie o jedinej rozpoznanej transformácii – vracia jediný objekt typu Transformácia alebo null v prípade neúspechu.)

Parametre:

text – reťazec obsahujúci text definície jedinej 2D transformácie, ktorý má byť prevedený na objekt typu Transformácia

Návratová hodnota:

prevedený objekt typu Transformácia alebo null, ak sa prevod nepodarí

retazecNaTransformaciu

public SVGPodpora.Transformacia retazecNaTransformaciu(String text)

Alias pre reťazecNaTransformáciu.

reťazceNaTransformácie

public SVGPodpora.Transformácia[] reťazceNaTransformácie(String... texty)

Táto metóda slúži na prevod 2D transformácií zadaných v textovej podobe v tvare, ktorý je v súlade so špecifikáciou SVG. Metóda dokáže spracovať ľubovoľný počet reťazcov obsahujúcich ľubovoľný počet SVG definícií 2D transformácií. Všetky rozpoznané definície prevedie na objekty typu Transformácia, uloží ich do poľa, ktoré vráti v návratovej hodnote.

Parametre:

texty – reťazce obsahujúce text definícií 2D SVG transformácií, ktorý majú byť prevedené na objekty typu Transformácia

Návratová hodnota:

pole s dĺžkou rovnou počtu transformácií, ktoré sa podarilo rozpoznať; každý prvok poľa obsahuje údaje o jednej rozpoznanej transformácii uložené v objekte typu Transformácia; pole môže mať aj nulovú dĺžku (ak by sa nepodarilo rozpoznať ani jednu transformáciu); v prípade kritického zlyhania môže metóda vrátiť hodnotu null

retazceNaTransformacie

public SVGPodpora.Transformacia[] retazceNaTransformacie(String... texty)

Alias pre reťazceNaTransformácie.

transformáciuNaReťazec

public static String transformáciuNaReťazec(AffineTransform transformácia)

Táto metóda prevedie objekte typu AffineTransform do textovej podoby v súlade so špecifikáciou SVG. Vo viacerých prípadoch je tento prevod jednoducho prepísaním údajov o afinnej transformácii na maticu matrix(…). Presnejší prevod je možný z údajov uložených v objektoch typu Transformácia. (Na spôsob výstupu tejto metódy má vplyv aj hodnota príznaku Transformácia.SVG2.)

Parametre:

transformácia – objekt typu AffineTransform, ktorý má byť prevedený na reťazec

Návratová hodnota:

prevedený reťazec obsahujúci text definície 2D SVG transformácie

transformaciuNaRetazec

public static String transformaciuNaRetazec(AffineTransform transformácia)

Alias pre transformáciuNaReťazec.

transformáciuNaReťazec

public static String transformáciuNaReťazec(SVGPodpora.Transformácia transformácia)

Táto metóda je doplnkom k metóde reťazecNaTransformáciu, prevádza informácie uložené v objekte typu Transformácia do textovej podoby v súlade so špecifikáciou SVG. (Na spôsob výstupu tejto metódy má vplyv aj hodnota príznaku Transformácia.SVG2.)

Parametre:

transformácia – objekt typu Transformácia, ktorý má byť prevedený na reťazec

Návratová hodnota:

prevedený reťazec obsahujúci text definície 2D SVG transformácie

transformaciuNaRetazec

public static String transformaciuNaRetazec(SVGPodpora.Transformácia transformácia)

Alias pre transformáciuNaReťazec.

transformácieNaReťazec

public static String transformácieNaReťazec(AffineTransform... transformácie)

Táto metóda slúži na prevod objektov typu AffineTransform do textovej podoby (tak, aby bola v súlade so špecifikáciou SVG). Vo viacerých prípadoch je tento prevod jednoducho prepísaním údajov o afinnej transformácii na maticu matrix(…). Presnejší prevod je možný z údajov uložených v objektoch typu Transformácia. (Na spôsob výstupu tejto metódy má vplyv aj hodnota príznaku Transformácia.SVG2.)

Parametre:

transformácie – objekty typu AffineTransform, ktoré majú byť prevedené do podoby série textových definícií uložených (podobne ako pri metóde transformácieNaReťazec prijímajúcej objekty typu Transformácia)

Návratová hodnota:

prevedený reťazec obsahujúci textové definície všetkých zadaných afinných transformácií

transformacieNaRetazec

public static String transformacieNaRetazec(AffineTransform... transformácie)

Alias pre transformácieNaReťazec.

transformácieNaReťazec

public static String transformácieNaReťazec(SVGPodpora.Transformácia... transformácie)

Táto metóda slúži na prevod informácií uložených v ľubovoľnom počte objektov typu Transformácia do textovej podoby, ktorá je v súlade so špecifikáciou SVG. (Na spôsob výstupu tejto metódy má vplyv aj hodnota príznaku Transformácia.SVG2.)

Parametre:

transformácie – objekty typu Transformácia, ktoré majú byť prevedené do celistvej podoby série textových definícií uložených v rámci jediného reťazca

Návratová hodnota:

prevedený reťazec obsahujúci textové definície všetkých zadaných transformácií

transformacieNaRetazec

public static String transformacieNaRetazec(SVGPodpora.Transformácia... transformácie)

Alias pre transformácieNaReťazec.

farbaNaReťazec

public static String farbaNaReťazec(Color farba,
                                    boolean ignorujAlfu)

Prevedie zadanú inštanciu farby do textovej podoby používanej v rámci jazykov HTML, CSS a teda aj SVG. Použitie tejto metódy je vhodné pri ukladaní údajov o farbe (napríklad výplne alebo čiary obrysu tvaru) do súboru v niektorom z uvedených súborových formátov (pri CSS by išlo o použitie nad rámec predvolených možností tejto triedy).

Podľa okolností je výsledkom tejto metódy reťazec v jednom z nasledujúcich tvarov: none (ak má zadaný objekt hodnotu null), «HTML meno farby», #rgb, #rrggbb alebo rgba(red, green, blue, alpha). Posledná reprezentácia nie je univerzálne použiteľná v SVG atribútoch fill a stroke. Štandard SVG definuje doplňujúce atribúty fill-opacity a stroke-opacity. Na ich naplnenie je výhodné použiť metódu alfaNaReťazec(farba).

Parametre:

farba – farba, ktorá má byť prevedená do reťazcovej podoby

ignorujAlfu – ak je hodnota tohto atribútu rovná true, tak vo výslednej reprezentácii bude ignorovaný kanál priehľadnosti farby (alfa)

Návratová hodnota:

farba prevedená do reťazcovej podoby

Pozri tiež:

alfaNaReťazec(Color), reťazecNaFarbu(String, String)

farbaNaRetazec

public static String farbaNaRetazec(Color farba,
                                    boolean ignorujAlfu)

Alias pre farbaNaReťazec.

farbaNaReťazec

public static String farbaNaReťazec(Farebnosť farba,
                                    boolean ignorujAlfu)

Prevedie zadanú implementáciu farebnosti do textovej podoby používanej v rámci jazykov HTML, CSS a teda aj SVG. Použitie tejto metódy je vhodné pri ukladaní údajov o farbe (napríklad výplne alebo čiary obrysu tvaru) do súboru v niektorom z uvedených súborových formátov (pri CSS by išlo o použitie nad rámec predvolených možností tejto triedy).

Podľa okolností je výsledkom tejto metódy reťazec v jednom z nasledujúcich tvarov: none (ak má zadaný objekt hodnotu null), «HTML meno farby», #rgb, #rrggbb alebo rgba(red, green, blue, alpha). Posledná reprezentácia nie je univerzálne použiteľná v SVG atribútoch fill a stroke. Štandard SVG definuje doplňujúce atribúty fill-opacity a stroke-opacity. Na ich naplnenie je výhodné použiť metódu alfaNaReťazec(farba).

Parametre:

farba – inštancia farebnosti, ktorá má byť prevedená do reťazcovej podoby

ignorujAlfu – ak je hodnota tohto atribútu rovná true, tak vo výslednej reprezentácii bude ignorovaný kanál priehľadnosti farby (alfa)

Návratová hodnota:

implementácia farebnosti prevedená do reťazcovej podoby

Pozri tiež:

alfaNaReťazec(Farebnosť), reťazecNaFarbu(String, String)

alfaNaReťazec

public static String alfaNaReťazec(Color farba)

Vyjme zo zadanej inštancie farby hodnotu úrovne priehľadnosti a prevedie ju na reťazec v rozsahu 0.0 až 1.0. Táto metóda je dôležitým doplnkom metódy farbaNaReťazec(farba, ignorujAlfu), pretože nie každý softvér pracujúci s formátom SVG akceptuje v atribútoch fill a stroke farby v tvare rgba(red, green, blue, alpha). Naproti tomu sme si overili, že všetok nami používaný softvér rešpektuje doplňujúce atribúty fill-opacity a stroke-opacity. Práve na určenie ich hodnôt je vhodná táto metóda.

Parametre:

farba – farba, ktorej zložka priehľadnosti má byť prevedená do reťazcovej podoby

Návratová hodnota:

zložka priehľadnosti zadanej farby prevedená do reťazcovej podoby (číslo v rozsahu 0.0 až 1.0 vyjadrené ako text)

Pozri tiež:

farbaNaReťazec(Color, boolean), reťazecNaFarbu(String, String)

alfaNaRetazec

public static String alfaNaRetazec(Color farba)

Alias pre alfaNaReťazec.

alfaNaReťazec

public static String alfaNaReťazec(Farebnosť farba)

Vyjme zo zadanej implementácie farebnosti hodnotu úrovne priehľadnosti a prevedie ju na reťazec v rozsahu 0.0 až 1.0. Táto metóda je dôležitým doplnkom metódy farbaNaReťazec(farba, ignorujAlfu), pretože nie každý softvér pracujúci s formátom SVG akceptuje v atribútoch fill a stroke farby v tvare rgba(red, green, blue, alpha). Naproti tomu sme si overili, že všetok nami používaný softvér rešpektuje doplňujúce atribúty fill-opacity a stroke-opacity. Práve na určenie ich hodnôt je vhodná táto metóda.

Parametre:

farba – inštancia farebnosti, ktorej zložka priehľadnosti má byť prevedená do reťazcovej podoby

Návratová hodnota:

zložka priehľadnosti zadanej inštancie prevedená do reťazcovej podoby (číslo v rozsahu 0.0 až 1.0 vyjadrené ako text)

Pozri tiež:

farbaNaReťazec(Farebnosť, boolean), reťazecNaFarbu(String, String)

alfaNaRetazec

public static String alfaNaRetazec(Farebnosť farba)

Alias pre alfaNaReťazec.

farbaNaRetazec

public static String farbaNaRetazec(Farebnosť farba,
                                    boolean ignorujAlfu)

Alias pre farbaNaReťazec.

reťazecNaFarbu

public static Farba reťazecNaFarbu(String text,
                                   String alfa)

Prevedie zadaný reťazec reprezentujúci farbu vo formátoch používaných jazykmi HTML, CSS a teda aj SVG na inštanciu farby programovacieho rámca. Metóda rozpoznáva buď názvy farebných entít uvedených jazykov (148 názvov typu black, yellow, white…), alebo reťazce v tvare:

• #rrggbb, kde rr je červená zložka v šestnástkovom tvare, gg zelená zložka v šestnástkovom tvare a bb modrá zložka v šestnástkovom tvare,
• #rgb, kde r je červená zložka v šestnástkovom tvare a g zelená zložka v šestnástkovom tvare, b modrá zložka v šestnástkovom tvare, pričom všetky zložky v tomto budú rozšírené na: rr, gg, bb, napríklad: #8af = #88aaff
• rgb(red, green, blue), kde red je červená zložka (v desiatkovom tvare), green zelená zložka, blue modrá zložka (všetko v desiatkovom tvare),
• rgba(red, green, blue, alpha), kde red je červená zložka (v desiatkovom tvare), green zelená zložka, blue modrá zložka (v desiatkových tvaroch), alpha priehľadnosť vyjadrená ako reálne číslo v rozsahu od 0.0 do 1.0.

Druhý argument (alfa) slúži na doplnenie hodnoty priehľadnosti k jednej z vyššie uvedených reprezentácií (okrem poslednej). Je to implementácia alternatívneho spôsobu určovania priehľadnosti výplne a čiary (fill a stroke) prostredníctvom XML atribútov fill-opacity a stroke-opacity štandardu SVG (niektoré softvéry rozpoznávajú len tento spôsob určovania priehľadnosti).

Metóda je vhodná ako doplnok k metódam farbaNaReťazec a alfaNaReťazec.

Parametre:

text – reťazec, ktorý má byť prevedený na farbu

alfa – dodatočný reťazec obsahujúci úroveň priehľadnosti; môže byť null

Návratová hodnota:

inštancia farby získaná z reťazcovej podoby alebo null, ak sa formát nepodarilo rozpoznať

Pozri tiež:

farbaNaReťazec(Color, boolean), alfaNaReťazec(Color)

retazecNaFarbu

public static Farba retazecNaFarbu(String text,
                                   String alfa)

Alias pre reťazecNaFarbu.

reťazecNaČíslo

public double reťazecNaČíslo(String hodnota)

Zabezpečí prevod reťazca na číslo (bez vzniku chyby) s vyhľadaním a prepočítaním prípadných jednotiek používaných v jazykoch HTML, CSS a teda aj SVG (uvedených za číselnou hodnotou v reťazcovom tvare). Všetky relatívne jednotky, okrem percenta, (to jest: em, ex, ch, rem, vw, vh, vmin a vmax) majú nastavený predvolený pomer prevodu 1 : 1, to znamená, že výsledkom je rovnaká hodnota, aká bola zapísaná v textovom tvare. Percentuálna jednotka má nastavený predvolený pomer 1 : 100. Absolútne jednotky (to jest: cm, mm, q, in, pc, pt a px) sú prepočítané podľa štandardu. Jednotky uhlov (deg, rad, grad a turn) sú prepočítané na „klasické“ uhlové stupne (deg), kedy jedna otáčka znamená 360°.

Parametre:

hodnota – číselná hodnota s prípadným uvedením jednotiek

Návratová hodnota:

výsledná prevedená a prepočítaná číselná hodnota

retazecNaCislo

public double retazecNaCislo(String hodnota)

Alias pre reťazecNaČíslo.

koeficient

public void koeficient(String jednotka,
                       double hodnota)

Táto metóda umožňuje upraviť koeficient prevodu jednotky číselnej hodnoty (pozri opis metódy reťazecNaČíslo).

Poznámka: Aktuálnu hodnotu koeficientu je možné overiť inou verziou tejto metódy. Touto metódou je tiež možné nastaviť koeficient prevodu úplne nových jednotiek.

Ak je namiesto jednotky zadaný prázdny reťazec, tak je hodnota ignorovaná. Podobne, ak je zadaná nová hodnota koeficientu nekonečná (alebo neplatná, napríklad rovná nule), tak je ignorovaná.

Parametre:

jednotka – jednotka, ktorej koeficient prevodu chceme zmeniť alebo nastaviť

hodnota – nová číselná hodnota koeficientu prevodu

koeficient

public double koeficient(String jednotka)

Táto metóda umožňuje overiť hodnotu koeficientu prevodu jednotky číselnej hodnoty (pozri opis metódy reťazecNaČíslo). Ak zadaná jednotka nejestvuje (nie je definovaná), tak táto metóda vráti hodnotu Double.NaN.

Parametre:

jednotka – jednotka, ktorej koeficient prevodu chceme zistiť

Návratová hodnota:

koeficient pre určenú jednotku alebo Double.NaN

htmlŠablóna

public String[] htmlŠablóna()

Táto metóda umožňuje zistiť aktuálny tvar šablóny HTML súboru. Šablóna je použitá metódami zapíš slúžiacimi na zápis tvarov (vo formáte SVG).

Jeden prvok poľa je ekvivalentný jednému riadku HTML súboru. Výnimku tvoria riadky obsahujúce rezervované reťazce $TVARY (resp. $SHAPES), $ŠTÝL (resp. $STYLE) alebo $DEFINÍCIE (resp. $DEFS), pretože tieto reťazce budú nahradené viacriadkovými SVG definíciami.

V prípade potreby môžete obsah tejto šablóny nahradiť iným požadovaným tvarom metódou htmlŠablóna(šablóna).

Návratová hodnota:

aktuálny tvar šablóny HTML súboru

htmlSablona

public String[] htmlSablona()

Alias pre htmlŠablóna.

svgŠablóna

public String[] svgŠablóna()

Táto metóda umožňuje zistiť aktuálny tvar šablóny SVG súboru. Šablóna je použitá metódami zapíš slúžiacimi na zápis tvarov (vo formáte SVG).

Jeden prvok poľa je ekvivalentný jednému riadku SVG súboru. Výnimku tvoria riadky obsahujúce rezervované reťazce $TVARY (resp. $SHAPES), $ŠTÝL (resp. $STYLE) alebo $DEFINÍCIE (resp. $DEFS), pretože tieto reťazce budú nahradené viacriadkovými SVG definíciami.

V prípade potreby môžete obsah tejto šablóny nahradiť iným požadovaným tvarom metódou svgŠablóna(šablóna).

Návratová hodnota:

aktuálny tvar šablóny SVG súboru

svgSablona

public String[] svgSablona()

Alias pre svgŠablóna.

htmlŠablóna

public boolean htmlŠablóna(String[] šablóna)

Táto metóda slúži na nastavenie nového tvaru šablóny HTML súboru. Šablóna je použitá metódami zapíš slúžiacimi na zápis tvarov (vo formáte SVG).

Jeden prvok poľa je ekvivalentný jednému riadku HTML súboru. Výnimku tvoria riadky obsahujúce rezervované reťazce $TVARY (resp. $SHAPES), $ŠTÝL (resp. $STYLE) alebo $DEFINÍCIE (resp. $DEFS), pretože tieto reťazce budú nahradené viacriadkovými SVG definíciami.

Šablóna musí byť v korektnom tvare (dotýka sa to syntaxe a štruktúry) HTML súboru s vloženým svg elementom, inak bude výsledný súbor v nekorektnom tvare, čo môže viesť k jeho nefunkčnosti! (Za korektnú štruktúru šablóny je zodpovedný autor.) Šablóna musí obsahovať rezervované reťazce: $TVARY (resp. $SHAPES) a $DEFINÍCIE (resp. $DEFS). Mala by tiež obsahovať rezervované reťazce: $KÓDOVANIE, $ŠÍRKA, $VÝŠKA a $TITULOK, ktoré budú nahradené korektnými údajmi – kódovaním, rozmermi plátien a zadaným alebo predvoleným titulkom a môže obsahovať rezervovaný reťazec $ŠTÝL (resp. $STYLE), ktorý bude nahradený definíciou štýlu, ak zoznam štýlov obsahuje nejaké prvky.

Poznámka: Rezervované reťazce $KÓDOVANIE, $ŠÍRKA, $VÝŠKA, $ŠTÝL a $DEFINÍCIE môžu byť uvedené aj bez diakritiky a všetky rezervované reťazce majú definované aliasy v anglickom jazyku: $KÓDOVANIE – $ENCODING, $ŠÍRKA – $WIDTH, $VÝŠKA – $HEIGHT, $ŠTÝL – $STYLE, $DEFINÍCIE – $DEFS, $TITULOK – $TITLE a $TVARY – $SHAPES.

Parametre:

šablóna – nový požadovaný tvar HTML šablóny

Návratová hodnota:

true v prípade úspechu (šablónu sa podarilo zmeniť), false v prípade neúspechu (šablóna neobsahuje požadovaný reťazec $TVARY (resp. $SHAPES) alebo $DEFINÍCIE (resp. $DEFS) alebo sa v zadaných vstupných údajoch vyskytla hodnota null)

htmlSablona

public boolean htmlSablona(String[] šablóna)

Alias pre htmlŠablóna.

svgŠablóna

public boolean svgŠablóna(String[] šablóna)

Táto metóda slúži na nastavenie nového tvaru šablóny SVG súboru. Šablóna je použitá metódami zapíš slúžiacimi na zápis tvarov (vo formáte SVG).

Jeden prvok poľa je ekvivalentný jednému riadku SVG súboru. Výnimku tvoria riadky obsahujúce rezervované reťazce $TVARY (resp. $SHAPES), $ŠTÝL (resp. $STYLE) alebo $DEFINÍCIE (resp. $DEFS), pretože tieto reťazce budú nahradené viacriadkovými SVG definíciami.

Šablóna musí byť v korektnom tvare (dotýka sa to syntaxe a štruktúry) SVG súboru, inak bude výsledný súbor v nekorektnom tvare, čo môže viesť k jeho nefunkčnosti! (Za korektnú štruktúru šablóny je zodpovedný autor.) Šablóna musí obsahovať rezervovaný reťazec: $TVARY (resp. $SHAPES) a $DEFINÍCIE (resp. $DEFS). Mala by tiež obsahovať rezervované reťazce: $KÓDOVANIE, $ŠÍRKA, $VÝŠKA a $TITULOK, ktoré budú nahradené korektnými údajmi – kódovaním, rozmermi plátien a zadaným alebo predvoleným titulkom a môže obsahovať rezervovaný reťazec $ŠTÝL (resp. $STYLE), ktorý bude nahradený definíciou štýlu, ak zoznam štýlov obsahuje nejaké prvky.

Poznámka: Rezervované reťazce $KÓDOVANIE, $ŠÍRKA, $VÝŠKA, $ŠTÝL a $DEFINÍCIE môžu byť uvedené aj bez diakritiky a všetky rezervované reťazce majú definované aliasy v anglickom jazyku: $KÓDOVANIE – $ENCODING, $ŠÍRKA – $WIDTH, $VÝŠKA – $HEIGHT, $ŠTÝL – $STYLE, $DEFINÍCIE – $DEFS, $TITULOK – $TITLE a $TVARY – $SHAPES.

Parametre:

šablóna – nový požadovaný tvar SVG šablóny

Návratová hodnota:

true v prípade úspechu (šablónu sa podarilo zmeniť), false v prípade neúspechu (šablóna neobsahuje požadovaný reťazec $TVARY (resp. $SHAPES) alebo $DEFINÍCIE (resp. $DEFS) alebo sa v zadaných vstupných údajoch vyskytla hodnota null)

svgSablona

public boolean svgSablona(String[] šablóna)

Alias pre svgŠablóna.

počet

public int počet()

Vráti počet tvarov, ktoré sú momentálne uskladnené v tejto inštancii (v jej vnútornom zásobníku) podpory SVG formátu. Tvary mohli byť do zásobníka vložené (importované) čítaním zo súboru alebo metódami pridaj a pridajText(tvar, tvorca, atribúty). Uskladnené tvary môžu byť vyjadrené v XML/SVG formáte a uložené (exportované) do súboru (HTML alebo SVG).

Návratová hodnota:

počet tvarov, ktoré sú momentálne uskladnené v tejto inštancii (v jej vnútornom zásobníku)

pocet

public int pocet()

Alias pre počet.

vymaž

public void vymaž()

Vyčistí vnútorné zásobníky tvarov a definícií, vymedzení a štýlu tejto inštancie. To znamená, že všetky vnútorne uskladnené tvary, (špeciálne) definície a ďalšie údaje budú z tejto inštancie odstránené.

vymaz

public void vymaz()

Alias pre vymaž.

vymaž

public void vymaž(int index)

Odstráni tvar tejto inštancie so zadaným indexom. Ako v ostatných prípadoch, index nula označuje prvý tvar v zásobníku. Ak je zadaný index záporný, tak bude metóda brať do úvahy tvar od konca zásobníka. To znamená, že index -1 označuje posledný tvar v zásobníku. Ak výsledný index (po úprave zo zápornej hodnoty na kladnú alebo bez úpravy) neukazuje na jestvujúci tvar (čiže jeho hodnota je mimo rozsahu 0 až počet() - 1, tak metóda nevykoná nič.

Parametre:

index – index tvaru, ktorý má byť vymazaný

vymaz

public void vymaz(int index)

Alias pre vymaž.

presuňDoStredu

public static Shape presuňDoStredu(Shape tvar)

Táto statická metóda vyrobí transformovanú verziu zadaného tvaru tak, aby nové súradnice jeho „stredu“ ležali v strede súradnicovej sústavy programovacieho rámca GRobot. „Stredom“ tvaru je myslený stred ohraničujúceho obdĺžnika tvaru. (O súradnicových priestoroch sa podrobnejšie píše napríklad v opisoch metód GRobot.cesta(), SVGpodpora.zapíš(…), SVGpodpora.čítaj(meno) a priebežne v celej dokumentácii.)

Malá algoritmická analýza

Keby nejestvovala táto metóda, bolo by potrebné zakaždým vykonať nasledujúce príkazy:

Bod bod = Bod.polohaTvaru(tvar);

tvar = SVGPodpora.dajVýsledný(tvar,
    new Transformácia(Transformácia.POSUN,
        -bod.polohaX(), bod.polohaY()));

Navyše, ak by nejestvovala metóda polohaTvaru, tak by bolo treba postupovať mierne odlišným spôsobom, napríklad využiť niektorý robot (r):

//  1. Najprv zálohovať jeho aktuálnu polohu (ak na nej záleží):
Bod záloha = r.poloha();

//  2. Potom sa robotom presunúť do stredu tvaru:
r.skočNa(tvar);

//  3. Potom využiť aktuálnu polohu robota na výrobu
//     presunutého tvaru (pomocou transformácie):
tvar = SVGPodpora.dajVýsledný(tvar,
    new Transformácia(Transformácia.POSUN,
        -r.polohaX(), r.polohaY()));

//  4. Nakoniec vrátiť robot do pôvodnej polohy (zo zálohy):
r.skočNa(záloha);

Tieto okolnosti viedli k vzniku tejto metódy, ktorá pracuje priamočiarejšie.

Parametre:

tvar – tvar, ktorého presunutá verzia má byť vyprodukovaná

Návratová hodnota:

transformovaný tvar – presunutý do stredu súradnicovej sústavy programovacieho rámca

presunDoStredu

public static Shape presunDoStredu(Shape tvar)

Alias pre presuňDoStredu.

stredKresby

public Bod stredKresby()

Vypočíta súradnice stredu kresby a vráti ich v inštancii triedy Bod. Vrátené súradnice sú prepočítané do súradnicového priestoru rámca. (O súradnicových priestoroch sa podrobnejšie píše napríklad v opisoch metód GRobot.cesta(), SVGpodpora.zapíš(…), SVGpodpora.čítaj(meno) a priebežne v celej dokumentácii.)

Príklad:

Nasledujúci príklad ukazuje spôsob použitia tejto metódy na pridanie takých transformácií (vo forme objektov triedy AffineTransform) všetkým tvarom kresby, ktoré ju posunú do stredu súradnicovej sústavy sveta (programovacieho rámca):

Upozornenie: Tento príklad vyžaduje importovanie triedy Javy AffineTransform.

// Získame súradnice stredu:
Bod stred = svgPodpora.stredKresby();

// Vyrobíme transformáciu posunutia, ktorá však očakáva súradnice
// v rámci súradnicového priestoru Javy (preto neobrátime y-ovú
// súradnicu):
AffineTransform posun = AffineTransform.
    getTranslateInstance(-stred.polohaX(), stred.polohaY());

// Uložíme počet tvarov kresby do pomocnej premennej:
int počet = svgPodpora.počet();

// Pridáme transformáciu ku každému tvaru:
for (int i = 0; i < počet; ++i)
    svgPodpora.pridajTransformácie(i, posun);

Upozornenie: Táto metóda nesúvisí s metódou presuňDoStredu, ktorá pracuje s jednotlivými inštanciami triedy Shape.

Poznámka: V triede nie je úmyselne definovaná metóda „presuňKresbuDoStredu“, ktorá by uzavrela (skryla) algoritmus vyššie uvedeného príkladu. Algoritmus používa na presun jednotlivých tvarov transformácie, ktoré pridáva k sérii prípadných jestvujúcich transformácií. Nepresúva tvary kresby priamo (fyzicky). Metódy daj a dajPôvodný vrátia neposunuté tvary. Posun sa prejaví až na tvaroch vrátených metódou dajVýsledný.

V niektorých prípadoch nemusí byť výsledok celej transformácie v súlade s očakávaniami, pretože môžu nastať nežiaduce interakcie s jestvujúcimi transformáciami niektorých tvarov. V takom prípade odporúčame vybrané (prípadne všetky) tvary prepísať ich transformovanými verziami (spolu s tým vymazať atribút ‚transform‘ – zadaním hodnoty null) a až potom ich posunúť. Upozornenie, po tejto transformácii nemusí (a pravdepodobne ani nebude) metóda rozmerKresby vracať korektnú hodnotu. Ak potrebujete poznať veľkosť kresby, musíte ju zistiť ihneď po prečítaní SVG súboru, skôr než vykonáte zásahy do vnútorných stavov inštancie triedy SVGPodpora.

Návratová hodnota:

bod so súradnicami stredu kresby

rozmerKresby

public double[] rozmerKresby()

Vypočíta aktuálny rozmer kresby (šírku a výšku) a vráti ho v prvých dvoch prvkoch poľa typu double.

Upozornenie: V prípade, že je vnútorný stav kresby upravený niektorými druhmi transformácií, nemusí táto metóda fungovať spoľahlivo. Ak potrebujete napríklad zistiť veľkosť kresby prečítanej z SVG súboru, tak je najlepšie ho zisťovať ihneď po prečítaní kresby zo súboru (skôr než budú vykonané určité zásahy do vnútorných stavov inštancie triedy SVGPodpora).

Návratová hodnota:

dvojica hodnôt (uložených v prvých dvoch prvkoch poľa) udávajúcich rozmer kresby

daj

public Shape daj(int index)

Poskytne netransformovaný tvar uložený vo vnútornom zásobníku tejto inštancie so zadaným „poradovým číslom,“ respektíve indexom. To znamená, že nula označuje prvý tvar v zásobníku. Ak je zadaný index záporný, metóda bude hľadať tvar od konca zásobníka. To znamená, že index -1 označuje posledný tvar vložený do vnútorného zásobníka. Ak index ani po úprave zo zápornej hodnoty na kladnú neukazuje na jestvujúci tvar, to znamená, že jeho hodnota je mimo rozsahu 0 až počet() - 1, tak metóda vráti hodnotu null.

Parametre:

index – index požadovaného tvaru z vnútorného zásobníka

Návratová hodnota:

netransformovaný tvar uložený vo vnútornom zásobníku pod zadaným indexom alebo null

dajPôvodný

public Shape dajPôvodný(int index)

Alias pre daj.

dajPovodny

public Shape dajPovodny(int index)

Alias pre daj.

dajVýsledný

public Shape dajVýsledný(int index)

Poskytne transformovaný tvar, ktorý je uložený vo vnútornom zásobníku tejto inštancie pod zadaným „poradovým číslom,“ respektíve indexom (čiže nula označuje prvý tvar v zásobníku). Táto metóda pracuje s vnútorne definovaným atribútom ‚transform‘, avšak spracúva iba 2D transformácie (ako všetky súčasti tejto triedy). Ak uvedený atribút nie je definovaný, tak je výstup tejto metódy zhodný s výstupom metódy daj (a teda aj dajPôvodný).

Tiež platia rovnaké informácie, aké sú uvedené v opise metódy daj, čiže: Ak je zadaný index záporný, metóda hľadá tvar od konca zásobníka, to znamená, že hodnota indexu -1 označuje posledný tvar vložený do vnútorného zásobníka. Ak index ani po úprave z prípadnej zápornej hodnoty na kladnú neukazuje na jestvujúci tvar, to znamená, že jeho hodnota je mimo rozsahu 0 až počet() - 1, tak táto metóda vráti hodnotu null.

Parametre:

index – index požadovaného tvaru z vnútorného zásobníka

Návratová hodnota:

tvar uložený vo vnútornom zásobníku pod zadaným indexom transformovaný podľa hodnoty vnútorného atribútu ‚transform‘ (ak má atribút definovanú hodnotu, inak je vrátený netransforomvaný tvar), alebo null ak tvar so zadaným indexom nejestvuje

dajVysledny

public Shape dajVysledny(int index)

Alias pre dajVýsledný.

dajVýsledný

public Shape dajVýsledný(int index,
                         String transformácia,
                         String... transformácie)

Táto metóda pracuje rovnako ako metóda dajVýsledný, ale namiesto prípadných vnútorne definovaných transformácií použije 2D transformácie zadané v argumentoch v tvare reťazcov v súlade so špecifikáciou SVG. Výsledný tvar bude transformovaný zloženou 2D transformáciou zostavenej zo všetkých rozpoznaných 2D transformácií obsiahnutých v zadaných argumentoch transformácia a transformácie.

Parametre:

index – index požadovaného tvaru z vnútorného zásobníka

transformácia – povinná transformácia (2D) v textovom tvare; podľa špecifikácie SVG môže obsahovať i niekoľko transformácií uvedených za sebou

transformácie – ďalšie (nepovinné) transformácie (2D), z ktorých každá môže obsahovať jednu alebo viac transformácií (2D – podľa špecifikácie SVG)

Návratová hodnota:

tvar, ktorý je uložený vo vnútornom zásobníku pod zadaným indexom a transformovaný podľa zadanej transformácie alebo transformácií alebo null ak tvar so zadaným indexom nejestvuje

dajVysledny

public Shape dajVysledny(int index,
                         String transformácia,
                         String... transformácie)

Alias pre dajVýsledný.

dajVýsledný

public Shape dajVýsledný(int index,
                         String[] transformácie)

Táto metóda pracuje rovnako ako metóda dajVýsledný(index, transformácia[, transformácie]), ale transformácie sú zadané v tvare poľa reťazcov.

Parametre:

index – index požadovaného tvaru z vnútorného zásobníka

transformácie – pole reťazcových prvkov, z ktorých každý môže obsahovať jednu alebo viac transformácií (2D – podľa špecifikácie SVG)

Návratová hodnota:

tvar, ktorý je uložený vo vnútornom zásobníku pod zadaným indexom a transformovaný podľa zadaných transformácií alebo null ak tvar so zadaným indexom nejestvuje

dajVysledny

public Shape dajVysledny(int index,
                         String[] transformácie)

Alias pre dajVýsledný.

dajVýsledný

public Shape dajVýsledný(int index,
                         AffineTransform transformácia,
                         AffineTransform... transformácie)

Táto metóda pracuje rovnako ako metóda dajVýsledný, ale namiesto prípadných vnútorne definovaných transformácií použije transformácie zadané vo forme objektov triedy AffineTransform, čiže v tomto prípade je podľa typu objektu zrejmé, že ide o 2D transformácie. Výsledný tvar bude transformovaný transformáciou zloženou zo všetkých zadaných transformácií.

Parametre:

index – index požadovaného tvaru z vnútorného zásobníka

transformácia – povinný objekt transformácia typu AffineTransform

transformácie – ďalšie (nepovinné) objekty transformácií typu AffineTransform

Návratová hodnota:

tvar, ktorý je uložený vo vnútornom zásobníku pod zadaným indexom a transformovaný podľa zadanej transformácie alebo transformácií alebo null ak tvar so zadaným indexom nejestvuje

dajVysledny

public Shape dajVysledny(int index,
                         AffineTransform transformácia,
                         AffineTransform... transformácie)

Alias pre dajVýsledný.

dajVýsledný

public Shape dajVýsledný(int index,
                         AffineTransform[] transformácie)

Táto metóda pracuje rovnako ako metóda dajVýsledný(index, transformácia[, transformácie]), ale transformácie sú zadané v tvare poľa objektov triedy AffineTransform.

Parametre:

index – index požadovaného tvaru z vnútorného zásobníka

transformácie – pole objektov typu AffineTransform

Návratová hodnota:

tvar, ktorý je uložený vo vnútornom zásobníku pod zadaným indexom a transformovaný podľa zadaných transformácií alebo null ak tvar so zadaným indexom nejestvuje

dajVysledny

public Shape dajVysledny(int index,
                         AffineTransform[] transformácie)

Alias pre dajVýsledný.

dajVýsledný

public Shape dajVýsledný(int index,
                         SVGPodpora.Transformácia transformácia,
                         SVGPodpora.Transformácia... transformácie)

Táto metóda pracuje rovnako ako metóda dajVýsledný, ale namiesto prípadných vnútorne definovaných transformácií použije transformácie zadané vo forme objektov triedy Transformácia (ktorá slúži na uchovanie informácií o rozpoznaných 2D SVG transformáciách). Výsledný tvar bude transformovaný transformáciou zloženou zo všetkých zadaných transformácií.

Parametre:

index – index požadovaného tvaru z vnútorného zásobníka

transformácia – povinný objekt transformácia typu Transformácia

transformácie – ďalšie (nepovinné) objekty transformácií typu Transformácia

Návratová hodnota:

tvar, ktorý je uložený vo vnútornom zásobníku pod zadaným indexom a transformovaný podľa zadanej transformácie alebo transformácií alebo null ak tvar so zadaným indexom nejestvuje

dajVysledny

public Shape dajVysledny(int index,
                         SVGPodpora.Transformácia transformácia,
                         SVGPodpora.Transformácia... transformácie)

Alias pre dajVýsledný.

dajVýsledný

public Shape dajVýsledný(int index,
                         SVGPodpora.Transformácia[] transformácie)

Táto metóda pracuje rovnako ako metóda dajVýsledný(index, transformácia[, transformácie]), ale transformácie sú zadané v tvare poľa objektov triedy Transformácia.

Parametre:

index – index požadovaného tvaru z vnútorného zásobníka

transformácie – pole objektov typu Transformácia

Návratová hodnota:

tvar, ktorý je uložený vo vnútornom zásobníku pod zadaným indexom a transformovaný podľa zadaných transformácií alebo null ak tvar so zadaným indexom nejestvuje

dajVysledny

public Shape dajVysledny(int index,
                         SVGPodpora.Transformácia[] transformácie)

Alias pre dajVýsledný.

dajVýsledný

public Shape dajVýsledný(Shape tvar,
                         String transformácia,
                         String... transformácie)

Táto metóda umožňuje transformovať ľubovoľný tvar (Shape) Javy podľa 2D transformácií zadaných v tvare reťazcov v súlade so špecifikáciou SVG.

Parametre:

tvar – tvar javy – objekt typu Shape (môže ísť aj o niektorý tvar generovaný robotom)

transformácia – povinná 2D transformácia v textovom tvare; podľa špecifikácie SVG môže obsahovať i niekoľko transformácií uvedených za sebou

transformácie – ďalšie (nepovinné) transformácie (2D), z ktorých každá môže obsahovať jednu alebo viac transformácií (podľa špecifikácie SVG)

Návratová hodnota:

vstupný tvar (z parametra tvar) transformovaný podľa zadaných transformácií (ak nastane chyba, tak je návratovou hodnotou null)

dajVysledny

public Shape dajVysledny(Shape tvar,
                         String transformácia,
                         String... transformácie)

Alias pre dajVýsledný.

dajVýsledný

public Shape dajVýsledný(Shape tvar,
                         String[] transformácie)

Táto metóda pracuje rovnako ako metóda dajVýsledný(index, transformácia[, transformácie]), ale transformácie sú zadané v tvare poľa reťazcov.

Parametre:

tvar – tvar javy – objekt typu Shape (môže ísť aj o niektorý tvar generovaný robotom)

transformácie – pole reťazcových prvkov, z ktorých každý môže obsahovať jednu alebo viac transformácií (2D – podľa špecifikácie SVG)

Návratová hodnota:

vstupný tvar (z parametra tvar) transformovaný podľa zadaných transformácií (ak nastane chyba, tak je návratovou hodnotou null)

dajVysledny

public Shape dajVysledny(Shape tvar,
                         String[] transformácie)

Alias pre dajVýsledný.

dajVýsledný

public static Shape dajVýsledný(Shape tvar,
                                SVGPodpora.Transformácia transformácia,
                                SVGPodpora.Transformácia... transformácie)

Táto metóda umožňuje transformovať ľubovoľný tvar (Shape) Javy podľa 2D transformácií zadaných vo forme objektov typu Transformácia.

Parametre:

tvar – tvar javy – objekt typu Shape (môže ísť aj o niektorý tvar generovaný robotom)

transformácia – povinný objekt transformácia typu Transformácia

transformácie – ďalšie (nepovinné) objekty transformácií typu Transformácia

Návratová hodnota:

vstupný tvar (z parametra tvar) transformovaný podľa zadaných transformácií (ak nastane chyba, tak je návratovou hodnotou null)

dajVysledny

public static Shape dajVysledny(Shape tvar,
                                SVGPodpora.Transformácia transformácia,
                                SVGPodpora.Transformácia... transformácie)

Alias pre dajVýsledný.

dajVýsledný

public static Shape dajVýsledný(Shape tvar,
                                SVGPodpora.Transformácia[] transformácie)

Táto metóda pracuje rovnako ako metóda dajVýsledný(index, transformácia[, transformácie]), ale transformácie sú zadané v tvare poľa objektov typu Transformácia.

Parametre:

tvar – tvar javy – objekt typu Shape (môže ísť aj o niektorý tvar generovaný robotom)

transformácie – pole objektov typu Transformácia

Návratová hodnota:

vstupný tvar (z parametra tvar) transformovaný podľa zadaných transformácií (ak nastane chyba, tak je návratovou hodnotou null)

dajVysledny

public static Shape dajVysledny(Shape tvar,
                                SVGPodpora.Transformácia[] transformácie)

Alias pre dajVýsledný.

dajVýsledný

public static Shape dajVýsledný(Shape tvar,
                                AffineTransform transformácia,
                                AffineTransform... transformácie)

Táto metóda umožňuje transformovať ľubovoľný tvar (Shape) Javy podľa 2D transformácií zadaných vo forme objektov typu AffineTransform.

Parametre:

tvar – tvar javy – objekt typu Shape (môže ísť aj o niektorý tvar generovaný robotom)

transformácia – povinný objekt transformácia typu AffineTransform

transformácie – ďalšie (nepovinné) objekty transformácií typu AffineTransform

Návratová hodnota:

vstupný tvar (z parametra tvar) transformovaný podľa zadaných transformácií (ak nastane chyba, tak je návratovou hodnotou null)

dajVysledny

public static Shape dajVysledny(Shape tvar,
                                AffineTransform transformácia,
                                AffineTransform... transformácie)

Alias pre dajVýsledný.

dajVýsledný

public static Shape dajVýsledný(Shape tvar,
                                AffineTransform[] transformácie)

Táto metóda pracuje rovnako ako metóda dajVýsledný(index, transformácia[, transformácie]), ale transformácie sú zadané v tvare poľa objektov typu AffineTransform.

Parametre:

tvar – tvar javy – objekt typu Shape (môže ísť aj o niektorý tvar generovaný robotom)

transformácie – pole objektov typu AffineTransform

Návratová hodnota:

vstupný tvar (z parametra tvar) transformovaný podľa zadaných transformácií (ak nastane chyba, tak je návratovou hodnotou null)

dajVysledny

public static Shape dajVysledny(Shape tvar,
                                AffineTransform[] transformácie)

Alias pre dajVýsledný.

prepíšTvar

public void prepíšTvar(int index,
                       Shape tvar)

Prepíše tvar určený indexom v rámci vnútorného zásobníka tvarov. Všetky vlastnosti (atribúty) súvisiace s tvarom zostanú zachované. Ak je zadaný index záporný, tak metóda prepíše tvar počítaný od konca zásobníka, to znamená, že index -1 označuje posledný tvar v zásobníku. Ak kladný alebo záporný index ukáže na tvar mimo zásobníka, tak metóda nevykoná žiadnu akciu. Ak je hodnota argumentu tvar rovná null, tak metóda tiež nevykoná žiadnu akciu.

Parametre:

index – index tvaru vo vnútornom zásobníku (hodnoty mimo platného rozsahu sú ignorované)

tvar – nový tvar, ktorým má byť nahradený jestvujúci tvar vo vnútornom zásobníku tvarov (hodnota null je ignorovaná)

prepisTvar

public void prepisTvar(int index,
                       Shape tvar)

Alias pre prepíšTvar.

nahraďTvar

public void nahraďTvar(int index,
                       Shape tvar)

Alias pre prepíšTvar.

nahradTvar

public void nahradTvar(int index,
                       Shape tvar)

Alias pre prepíšTvar.

nastavTvar

public void nastavTvar(int index,
                       Shape tvar)

Alias pre prepíšTvar.

dajAtribút

public String dajAtribút(int index,
                         String meno)

Poskytne hodnotu atribútu asociovaného s tvarom so zadaným indexom. Ak je zadaný index záporný, metóda bude hľadať atribút pre tvar od konca zásobníka, to znamená, že index -1 označuje posledný tvar vložený do vnútorného zásobníka. Ak požadovaný atribút (alebo tvar) nejestvuje, tak metóda vráti hodnotu null.

Parametre:

index – index požadovaného tvaru z vnútorného zásobníka

meno – názov požadovaného atribútu asociovaného s tvarom

Návratová hodnota:

reťazec s hodnotou požadovaného atribútu alebo null

dajAtribut

public String dajAtribut(int index,
                         String meno)

Alias pre dajAtribút.

dajAtribúty

public String[] dajAtribúty(int index)

Poskytne zoznam názvov atribútov asociovaných s tvarom so zadaným indexom. Ak je zadaný index záporný, tak metóda vytvorí zoznam atribútov pre tvar od konca vnútorného zásobníka tvarov. To znamená, že index -1 označuje posledný tvar vložený do vnútorného zásobníka tvarov. Ak požadovaný tvar nejestvuje, tak táto metóda namiesto zoznamu vráti hodnotu null, inak vráti pole reťazcov (hoci aj prázdne).

Poznámka: V rôznych fázach vývoja boli v tejto triede implementované dve rôzne metódy, ktorých výsledok je identický, len sa k nemu dopracúvajú iným spôsobom: dajAtribúty a zoznamAtribútov. Z dôvodu zachovania spätnej kompatibility boli obidve metódy v tejto triede ponechané.

Parametre:

index – index požadovaného tvaru z vnútorného zásobníka

Návratová hodnota:

pole reťazcov s názvami atribútov asociovaných s vyšetrovaným tvarom alebo null

dajAtributy

public String[] dajAtributy(int index)

Alias pre dajAtribúty.

dajSVG

public String dajSVG(int index)

Vráti XML/SVG reprezentáciu tvaru uloženého vo vnútornom zásobníku tejto inštancie so zadaným poradovým číslom, resp. indexom – nula označuje prvý tvar. (Ide vlastne o export tvaru do reťazca.) Ak je zadaný index záporný, metóda bude hľadať tvar od konca zásobníka, to znamená, že index -1 označuje posledný tvar vložený do vnútorného zásobníka. Index musí po tejto úprave ukazovať na jestvujúci tvar, to znamená, že jeho hodnota musí byť v rozsahu 0 až počet() - 1, inak metóda vráti hodnotu null. (Vkladanie/vytváranie nových tvarov do vnútorného zásobníka tejto inštancie s použitím XML/SVG reprezentácie je možné, okrem prečítania priamo z SVG alebo HTML súboru, aj metódou pridajSVG(xmlSVG).)

Poznámka: Pri exporte nie sú využité vlastnosti SVG 2.0, najmä takzvaný „bearing“ – aktuálne pootočenie, ktorý má v budúcnosti slúžiť na implementáciu korytnačej grafiky v rámci štandardu SVG. Dôvodom nepoužitia novšej verzie štandardu je to, že súčasný softvér tento štandard nie je schopný spracovať. To znamená, že takto exportované údaje by neboli v praxi použiteľné.

Parametre:

index – index požadovaného tvaru z vnútorného zásobníka

Návratová hodnota:

textová XML/SVG reprezentácia tvaru uloženého vo vnútornom zásobníku pod zadaným indexom alebo null

farbaVýplne

public Farba farbaVýplne(int index)

Pokúsi sa zistiť farbu výplne tvaru asociovaného so zadaným indexom. Možnosti metódy sú obmedzené (pozri aj informácie v opise triedy).

Pozri aj príbuznú metódu: náterVýplne

Upozornenie: Táto metóda vracia ako predvolenú farbu (to jest, ak nie je definovaný atribút fill) čiernu farbu. Hodnota null je vrátená len tom v prípade, keď je hodnota SVG atribútu fill rovná "none". Táto hodnota sa dá nastaviť metódou farbaVýplne(index, farba) zadaním inštancie farby žiadna.

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na zistenie hodnoty atribútu metódu dajAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde dajAtribút)

Návratová hodnota:

objekt typu Farba alebo null

farbaVyplne

public Farba farbaVyplne(int index)

Alias pre farbaVýplne.

náterVýplne

public Paint náterVýplne(int index)

Pokúsi sa zistiť typ náteru výplne tvaru asociovaného so zadaným indexom. Možnosti metódy sú obmedzené na zisťovanie lineárneho alebo radiálneho gradientu (inak povedané: priamočiareho alebo kruhového farebného prechodu) alebo výplne plnou farbou. V podstate ak sa nepodarí identifikovať jeden z uvedených gradientov, tak metóda zavolá príbuznú metódu farbaVýplne.

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na zistenie hodnoty atribútu metódu dajAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde dajAtribút)

Návratová hodnota:

objekt typu Paint alebo null

naterVyplne

public Paint naterVyplne(int index)

Alias pre náterVýplne.

farbaČiary

public Farba farbaČiary(int index)

Pokúsi sa zistiť farbu čiary tvaru asociovaného so zadaným indexom. Možnosti metódy sú obmedzené (pozri informácie v opise triedy). Ak sa farbu nepodarí zistiť, tak metóda vráti hodnotu null.

Pozri aj príbuznú metódu: náterČiary

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na zistenie hodnoty atribútu metódu dajAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde dajAtribút)

Návratová hodnota:

objekt typu Farba alebo null

farbaCiary

public Farba farbaCiary(int index)

Alias pre farbaČiary.

náterČiary

public Paint náterČiary(int index)

Pokúsi sa zistiť typ náteru čiary tvaru asociovaného so zadaným indexom. Možnosti metódy sú obmedzené na zisťovanie lineárneho alebo radiálneho gradientu (inak povedané: priamočiareho alebo kruhového farebného prechodu) alebo čiary kreslenej plnou farbou. V podstate ak sa nepodarí identifikovať jeden z uvedených gradientov, tak metóda zavolá príbuznú metódu farbaČiary.

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na zistenie hodnoty atribútu metódu dajAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde dajAtribút)

Návratová hodnota:

objekt typu Paint alebo null

naterCiary

public Paint naterCiary(int index)

Alias pre náterČiary.

hrúbkaČiary

public double hrúbkaČiary(int index)

Pokúsi sa zistiť hrúbku čiary tvaru asociovaného so zadaným indexom. Možnosti metódy sú obmedzené (pozri informácie v opise triedy). Ak sa hrúbku nepodarí zistiť, tak metóda vráti hodnotu Double.NaN.

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na zistenie hodnoty atribútu metódu dajAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde dajAtribút)

Návratová hodnota:

objekt typu Farba alebo null

hrubkaCiary

public double hrubkaCiary(int index)

Alias pre hrúbkaČiary.

prepíšAtribút

public void prepíšAtribút(int index,
                          String meno,
                          Object hodnota)

Prepíše, vloží novú alebo odstráni hodnotu atribútu asociovaného s tvarom so zadaným indexom. Ak je index záporný, metóda bude hľadať tvar od konca zásobníka, to znamená, že index -1 označuje posledný tvar vložený do vnútorného zásobníka. Okrem toho musia byť splnené nasledujúce podmienky: index musí ukazovať na jestvujúci tvar (po úprave prípadnej zápornej hodnoty) a meno nesmie byť null ani prázdny reťazec, inak nebude mať volanie tejto metódy žiadny efekt. Ak je hodnota rovná null, tak je atribút odstránený, v opačnom prípade je za novú hodnotu považovaný reťazec vytvorený z objektu volaním metódy hodnota.toString().

Pozor! Atribúty, ktoré sú kľúčové pri vyjadrení konkrétneho tvaru (napr. cx, cy, r pri kružnici, points pri polygóne, d pri ceste a podobne) sú počas prevodu do XML/SVG tvaru nahradené konkrétnymi hodnotami. Preto ich nastavenie/prepísanie/vymazanie touto metódou nemá zmysel.

Parametre:

index – index tvaru vo vnútornom zásobníku

meno – názov atribútu asociovaného s tvarom

hodnota – nová hodnota atribútu alebo null

prepisAtribut

public void prepisAtribut(int index,
                          String meno,
                          Object hodnota)

Alias pre prepíšAtribút.

nahraďAtribút

public void nahraďAtribút(int index,
                          String meno,
                          Object hodnota)

Alias pre prepíšAtribút.

nahradAtribut

public void nahradAtribut(int index,
                          String meno,
                          Object hodnota)

Alias pre prepíšAtribút.

nastavAtribút

public void nastavAtribút(int index,
                          String meno,
                          Object hodnota)

Alias pre prepíšAtribút.

nastavAtribut

public void nastavAtribut(int index,
                          String meno,
                          Object hodnota)

Alias pre prepíšAtribút.

farbaVýplne

public void farbaVýplne(int index,
                        Color farba)

Nastaví novú farbu výplne tvaru asociovanému so zadaným indexom. (Metóda nastavuje asociovanému tvaru atribúty fill a fill-opacity.)

Poznámka: Inštancia farby žiadna má špeciálny význam – nastavuje hodnotu SVG atribútu fill na "none".

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na vloženie hodnoty atribútu metódu prepíšAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde prepíšAtribút)

farba – nová farba výplne; ak je zadaná hodnota null tak sú atribúty fill a fill-opacity tvaru odstránené, inak sú na prevod farby do reťazcovej podoby použité metódy farbaNaReťazec(farba, ignorujAlfu) (pre atribút fill a alfaNaReťazec(farba) (pre atribút fill-opacity); neprítomnosť atribútov výplne má za následok použitie predvolenej výplne pri kreslení SVG tvarov; nevyplnený tvar musí mať hodnotu atribútu výplne (fill) nastavenú na "none", čo sa dá dosiahnuť zadaním inštancie farby žiadna do tohto parametra

farbaVyplne

public void farbaVyplne(int index,
                        Color farba)

Alias pre farbaVýplne.

farbaČiary

public void farbaČiary(int index,
                       Color farba)

Nastaví novú farbu čiary tvaru asociovanému so zadaným indexom. (Metóda nastavuje asociovanému tvaru atribúty stroke a stroke-opacity.)

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na vloženie hodnoty atribútu metódu prepíšAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde prepíšAtribút)

farba – nová farba čiary; ak je zadaná hodnota null tak sú atribúty stroke a stroke-opacity tvaru odstránené, inak sú na prevod farby do reťazcovej podoby použité metódy farbaNaReťazec(farba, ignorujAlfu) (pre atribút stroke a alfaNaReťazec(farba) (pre atribút stroke-opacity)

farbaCiary

public void farbaCiary(int index,
                       Color farba)

Alias pre farbaČiary.

hrúbkaČiary

public void hrúbkaČiary(int index,
                        double hrúbka)

Nastaví novú hrúbku čiary tvaru asociovanému so zadaným indexom. (Metóda nastavuje asociovanému tvaru atribút stroke-width.)

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na vloženie hodnoty atribútu metódu prepíšAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde prepíšAtribút)

hrúbka – nová hrúbka čiary

hrubkaCiary

public void hrubkaCiary(int index,
                        double hrúbka)

Alias pre hrúbkaČiary.

transformácie

public SVGPodpora.Transformácia[] transformácie(int index)

Vráti zoznam transformácií v poli objektov typu Transformácia, ktoré sú priradené k indexom určenému tvaru prostredníctvom vnútorného atribútu ‚transform‘.

Parametre:

index – index tvaru v rámci vnútorného zásobníka (pre hodnotu indexu platí to isté ako pre hodnotu indexu pri metóde dajAtribút; aj keď táto metóda uvedenú metódu vnútorne nepoužíva)

Návratová hodnota:

pole údajov o transformáciách reprezentovaných objektmi Transformácia s dĺžkou rovnou počtu transformácií, ktoré sa podarilo rozpoznať vo vnútornom atribúte ‚transform‘ (pole môže mať aj nulovú dĺžku, ak by sa nepodarilo rozpoznať ani jednu transformáciu) alebo null, ak požadovaný tvar nejestvuje alebo ak tvar nemá definovaný atribút ‚transform‘

transformacie

public SVGPodpora.Transformacia[] transformacie(int index)

Alias pre transformácie.

transformácie

public void transformácie(int index,
                          String transformácia,
                          String... transformácie)

Nastaví alebo odstráni vnútorný atribút transformácií (‚transform‘) tvaru určeného indexom podľa hodnoty zadaného reťazca alebo série reťazcov.

Poznámka: Hodnota null nemá žiadny údajový typ. Je akoby „spoločná pre všetky údajové typy.“ Táto hodnota vyjadruje neprítomnosť žiadneho objektu, neprítomnosť žiadnej inštancie. V skutočnosti nie je a nikdy nebude možné určiť jej typ. Pri volaní metódy musí byť pretypovanie prítomné preto, aby kompilátor dokázal určiť, ktorú verziu z preťažených metód má volať.

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na vloženie hodnoty atribútu metódu prepíšAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde prepíšAtribút)

transformácia – povinný reťazec určujúci novú transformáciu alebo transformácie vkladané do atribútu ‚transform‘; ak je zadaná pretypovaná hodnota (String)null a nie sú zadané nepovinné parametre transformácie, tak sú transformácie tvaru odstránené

transformácie – nepovinné transformácie (do tohto parametra môže byť zadaná aj pretypovaná hodnota (String[])null – výsledok potom závisí od hodnoty povinného parametra transformácia)

transformacie

public void transformacie(int index,
                          String transformácia,
                          String... transformácie)

Alias pre transformácie.

transformácie

public void transformácie(int index,
                          String[] transformácie)

Nastaví alebo odstráni vnútorný atribút transformácií (‚transform‘) tvaru určeného indexom podľa hodnôt prvkov zadaného poľa reťazcov.

Poznámka: Hodnota null nemá žiadny údajový typ. Je akoby „spoločná pre všetky údajové typy.“ Táto hodnota vyjadruje neprítomnosť žiadneho objektu, neprítomnosť žiadnej inštancie. V skutočnosti nie je a nikdy nebude možné určiť jej typ. Pri volaní metódy musí byť pretypovanie prítomné preto, aby kompilátor dokázal určiť, ktorú verziu z preťažených metód má volať.

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na vloženie hodnoty atribútu metódu prepíšAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde prepíšAtribút)

transformácie – pole reťazcov určujúcich novú hodnotu atribútu transformácií; ak je zadaná pretypovaná hodnota (String[])null, tak sú transformácie tvaru odstránené

transformacie

public void transformacie(int index,
                          String[] transformácie)

Alias pre transformácie.

transformácie

public void transformácie(int index,
                          AffineTransform transformácia,
                          AffineTransform... transformácie)

Nastaví alebo odstráni vnútorný atribút transformácií (‚transform‘) tvaru určeného indexom podľa zadaného objektu alebo série objektov afinných transformácií. Táto metóda používa vnútorne na prevod metódu transformáciuNaReťazec, takže platia aj informácie z opisu uvedenej metódy (najmä to o prevode do maticového tvaru – matrix(…)). (Na spôsob výstupu tejto metódy má vplyv aj hodnota príznaku Transformácia.SVG2.)

Poznámka: Hodnota null nemá žiadny údajový typ. Je akoby „spoločná pre všetky údajové typy.“ Táto hodnota vyjadruje neprítomnosť žiadneho objektu, neprítomnosť žiadnej inštancie. V skutočnosti nie je a nikdy nebude možné určiť jej typ. Pri volaní metódy musí byť pretypovanie prítomné preto, aby kompilátor dokázal určiť, ktorú verziu z preťažených metód má volať.

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na vloženie hodnoty atribútu metódu prepíšAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde prepíšAtribút)

transformácia – povinný objekt určujúci novú transformáciu vkladanú do atribútu ‚transform‘; ak je zadaná pretypovaná hodnota (AffineTransform)null a nie sú zadané nepovinné parametre transformácie, tak je atribút tvaru ‚transform‘ odstránený

transformácie – nepovinné transformácie (do tohto parametra môže byť zadaná aj pretypovaná hodnota (AffineTransform[])null – výsledok potom závisí od hodnoty povinného parametra transformácia)

transformacie

public void transformacie(int index,
                          AffineTransform transformácia,
                          AffineTransform... transformácie)

Alias pre transformácie.

transformácie

public void transformácie(int index,
                          AffineTransform[] transformácie)

Nastaví alebo odstráni vnútorný atribút transformácií (‚transform‘) tvaru určeného indexom podľa hodnôt prvkov zadaného poľa objektov afinných transformácií. Táto metóda používa vnútorne na prevod metódu transformáciuNaReťazec, takže platia aj informácie z opisu uvedenej metódy (najmä to o prevode do maticového tvaru – matrix(…)). (Na spôsob výstupu tejto metódy má vplyv aj hodnota príznaku Transformácia.SVG2.)

Poznámka: Hodnota null nemá žiadny údajový typ. Je akoby „spoločná pre všetky údajové typy.“ Táto hodnota vyjadruje neprítomnosť žiadneho objektu, neprítomnosť žiadnej inštancie. V skutočnosti nie je a nikdy nebude možné určiť jej typ. Pri volaní metódy musí byť pretypovanie prítomné preto, aby kompilátor dokázal určiť, ktorú verziu z preťažených metód má volať.

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na vloženie hodnoty atribútu metódu prepíšAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde prepíšAtribút)

transformácie – pole objektov transformácií určujúcich novú hodnotu atribútu transformácií; ak je zadaná pretypovaná hodnota (AffineTransform[])null, tak je atribút tvaru ‚transform‘ odstránený

transformacie

public void transformacie(int index,
                          AffineTransform[] transformácie)

Alias pre transformácie.

transformácie

public void transformácie(int index,
                          SVGPodpora.Transformácia transformácia,
                          SVGPodpora.Transformácia... transformácie)

Nastaví alebo odstráni vnútorný atribút transformácií (‚transform‘) tvaru určeného indexom podľa zadaného objektu alebo série objektov afinných transformácií. Táto metóda používa vnútorne na prevod metódu transformáciuNaReťazec, takže platia aj prípadné relevantné informácie z opisu uvedenej metódy. (Na spôsob výstupu tejto metódy má vplyv aj hodnota príznaku Transformácia.SVG2.)

Poznámka: Hodnota null nemá žiadny údajový typ. Je akoby „spoločná pre všetky údajové typy.“ Táto hodnota vyjadruje neprítomnosť žiadneho objektu, neprítomnosť žiadnej inštancie. V skutočnosti nie je a nikdy nebude možné určiť jej typ. Pri volaní metódy musí byť pretypovanie prítomné preto, aby kompilátor dokázal určiť, ktorú verziu z preťažených metód má volať.

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na vloženie hodnoty atribútu metódu prepíšAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde prepíšAtribút)

transformácia – povinný objekt určujúci novú transformáciu vkladanú do atribútu ‚transform‘; ak je zadaná pretypovaná hodnota (Transformácia)null a nie sú zadané nepovinné parametre transformácie, tak je atribút tvaru ‚transform‘ odstránený

transformácie – nepovinné transformácie (do tohto parametra môže byť zadaná aj pretypovaná hodnota (Transformácia[])null – výsledok potom závisí od hodnoty povinného parametra transformácia)

transformacie

public void transformacie(int index,
                          SVGPodpora.Transformácia transformácia,
                          SVGPodpora.Transformácia... transformácie)

Alias pre transformácie.

transformácie

public void transformácie(int index,
                          SVGPodpora.Transformácia[] transformácie)

Nastaví alebo odstráni vnútorný atribút transformácií (‚transform‘) tvaru určeného indexom podľa hodnôt prvkov zadaného poľa objektov afinných transformácií. Táto metóda používa vnútorne na prevod metódu transformáciuNaReťazec, takže platia aj prípadné relevantné informácie z opisu uvedenej metódy. (Na spôsob výstupu tejto metódy má vplyv aj hodnota príznaku Transformácia.SVG2.)

Poznámka: Hodnota null nemá žiadny údajový typ. Je akoby „spoločná pre všetky údajové typy.“ Táto hodnota vyjadruje neprítomnosť žiadneho objektu, neprítomnosť žiadnej inštancie. V skutočnosti nie je a nikdy nebude možné určiť jej typ. Pri volaní metódy musí byť pretypovanie prítomné preto, aby kompilátor dokázal určiť, ktorú verziu z preťažených metód má volať.

Parametre:

index – index tvaru v rámci vnútorného zásobníka (táto metóda používa na vloženie hodnoty atribútu metódu prepíšAtribút, takže pre hodnotu indexu pri tejto metóde platí to isté ako pre hodnotu indexu pri metóde prepíšAtribút)

transformácie – pole objektov transformácií určujúcich novú hodnotu atribútu transformácií; ak je zadaná pretypovaná hodnota (Transformácia[])null, tak je atribút tvaru ‚transform‘ odstránený

transformacie

public void transformacie(int index,
                          SVGPodpora.Transformácia[] transformácie)

Alias pre transformácie.

pridajTransformácie

public void pridajTransformácie(int index,
                                String transformácia,
                                String... transformácie)

Pridá k vnútornému atribútu transformácií (‚transform‘) tvaru určeného indexom transformácie podľa zadaného reťazca alebo série reťazcov.

Parametre:

index – index tvaru v rámci vnútorného zásobníka (pre hodnotu indexu platí to isté, čo pri iných metódach tejto triedy, napríklad prepíšAtribút)

transformácia – povinný reťazec určujúci transformáciu alebo transformácie pridávané do atribútu ‚transform‘

transformácie – ďalšie (nepovinné) transformácie na pridanie

pridajTransformacie

public void pridajTransformacie(int index,
                                String transformácia,
                                String... transformácie)

Alias pre pridajTransformácie.

pridajTransformácie

public void pridajTransformácie(int index,
                                String[] transformácie)

Pridá k vnútornému atribútu transformácií (‚transform‘) tvaru určeného indexom transformácie podľa hodnôt prvkov zadaného poľa reťazcov.

Parametre:

index – index tvaru v rámci vnútorného zásobníka (pre hodnotu indexu platí to isté, čo pri iných metódach tejto triedy, napríklad prepíšAtribút)

transformácie – pole reťazcov s transformáciami na pridanie

pridajTransformacie

public void pridajTransformacie(int index,
                                String[] transformácie)

Alias pre pridajTransformácie.

pridajTransformácie

public void pridajTransformácie(int index,
                                AffineTransform transformácia,
                                AffineTransform... transformácie)

Pridá k vnútornému atribútu transformácií (‚transform‘) tvaru určeného indexom transformácie podľa zadaného objektu alebo série objektov afinných transformácií. Táto metóda používa vnútorne na prevod metódu transformáciuNaReťazec, takže platia aj informácie z opisu uvedenej metódy (najmä to o prevode do maticového tvaru – matrix(…)). (Na spôsob výstupu tejto metódy má vplyv aj hodnota príznaku Transformácia.SVG2.)

Parametre:

index – index tvaru v rámci vnútorného zásobníka (pre hodnotu indexu platí to isté, čo pri iných metódach tejto triedy, napríklad prepíšAtribút)

transformácia – povinný objekt určujúci transformáciu pridávanú do atribútu ‚transform‘

transformácie – ďalšie (nepovinné) transformácie na pridanie

pridajTransformacie

public void pridajTransformacie(int index,
                                AffineTransform transformácia,
                                AffineTransform... transformácie)

Alias pre pridajTransformácie.

pridajTransformácie

public void pridajTransformácie(int index,
                                AffineTransform[] transformácie)

Pridá k vnútornému atribútu transformácií (‚transform‘) tvaru určeného indexom transformácie podľa hodnôt prvkov zadaného poľa objektov afinných transformácií. Táto metóda používa vnútorne na prevod metódu transformáciuNaReťazec, takže platia aj informácie z opisu uvedenej metódy (najmä to o prevode do maticového tvaru – matrix(…)). (Na spôsob výstupu tejto metódy má vplyv aj hodnota príznaku Transformácia.SVG2.)

Parametre:

index – index tvaru v rámci vnútorného zásobníka (pre hodnotu indexu platí to isté, čo pri iných metódach tejto triedy, napríklad prepíšAtribút)

transformácie – pole s afinnými transformáciami na pridanie

pridajTransformacie

public void pridajTransformacie(int index,
                                AffineTransform[] transformácie)

Alias pre pridajTransformácie.

pridajTransformácie

public void pridajTransformácie(int index,
                                SVGPodpora.Transformácia transformácia,
                                SVGPodpora.Transformácia... transformácie)

Pridá k vnútornému atribútu transformácií (‚transform‘) tvaru určeného indexom transformácie podľa zadaného objektu alebo série objektov afinných transformácií. Táto metóda používa vnútorne na prevod metódu transformáciuNaReťazec, takže platia aj prípadné relevantné informácie z opisu uvedenej metódy. (Na spôsob výstupu tejto metódy má vplyv aj hodnota príznaku Transformácia.SVG2.)

Parametre:

index – index tvaru v rámci vnútorného zásobníka (pre hodnotu indexu platí to isté, čo pri iných metódach tejto triedy, napríklad prepíšAtribút)

transformácia – povinný objekt určujúci transformáciu pridávanú do atribútu ‚transform‘

transformácie – ďalšie (nepovinné) transformácie na pridanie

pridajTransformacie

public void pridajTransformacie(int index,
                                SVGPodpora.Transformácia transformácia,
                                SVGPodpora.Transformácia... transformácie)

Alias pre pridajTransformácie.

pridajTransformácie

public void pridajTransformácie(int index,
                                SVGPodpora.Transformácia[] transformácie)

Pridá k vnútornému atribútu transformácií (‚transform‘) tvaru určeného indexom transformácie podľa hodnôt prvkov zadaného poľa objektov afinných transformácií. Táto metóda používa vnútorne na prevod metódu transformáciuNaReťazec, takže platia aj prípadné relevantné informácie z opisu uvedenej metódy. (Na spôsob výstupu tejto metódy má vplyv aj hodnota príznaku Transformácia.SVG2.)

Parametre:

index – index tvaru v rámci vnútorného zásobníka (pre hodnotu indexu platí to isté, čo pri iných metódach tejto triedy, napríklad prepíšAtribút)

transformácie – pole objektov transformácií na pridanie

pridajTransformacie

public void pridajTransformacie(int index,
                                SVGPodpora.Transformácia[] transformácie)

Alias pre pridajTransformácie.

zoznamAtribútov

public String[] zoznamAtribútov(int index)

Poskytne zoznam názvov atribútov asociovaných s tvarom so zadaným indexom. Ak je zadaný index záporný, tak metóda vytvorí zoznam atribútov pre tvar od konca vnútorného zásobníka tvarov. To znamená, že index -1 označuje posledný tvar vložený do vnútorného zásobníka tvarov. Ak požadovaný tvar nejestvuje, tak táto metóda namiesto zoznamu vráti hodnotu null, inak vráti pole reťazcov (hoci aj prázdne).

Poznámka: V rôznych fázach vývoja boli v tejto triede implementované dve rôzne metódy, ktorých výsledok je identický, len sa k nemu dopracúvajú iným spôsobom: dajAtribúty a zoznamAtribútov. Z dôvodu zachovania spätnej kompatibility boli obidve metódy v tejto triede ponechané.

Parametre:

index – index vyšetrovaného tvaru z vnútorného zásobníka

Návratová hodnota:

pole reťazcov s názvami atribútov asociovaných s vyšetrovaným tvarom alebo null

zoznamAtributov

public String[] zoznamAtributov(int index)

Alias pre zoznamAtribútov.

pridaj

public void pridaj(Shape tvar,
                   String... atribúty)

Vloží do vnútorného zásobníka tejto inštancie ďalší tvar s prípadnou sériou atribútov. Atribúty sú zadávané vo forme zoznamu parametrov atribúty, ktorý je vyhodnocovaný po dvojiciach prvkov. Prvý prvok znamená názov atribútu, druhý hodnotu. Trieda pri ukladaní tvarov do súboru nájde vhodnú reprezentáciu zadaného tvaru vo forme XML/SVG značky (pozri aj metódu dajSVG(index)), ku ktorej priradí sériu zadaných atribútov. (Atribúty bez mena alebo s hodnotou null sú ignorované.)

Pozor! Atribúty, ktoré sú kľúčové pri vyjadrení konkrétneho tvaru (napr. cx, cy, r pri kružnici, points pri polygóne, d pri ceste a podobne) sú počas prevodu do XML/SVG tvaru nahradené konkrétnymi hodnotami. Preto ich nastavenie touto metódou nemá zmysel.

Parametre:

tvar – inštancia tvaru na uloženie

atribúty – séria dvojíc reťazcov určujúca doplňujúce atribúty tvaru

početVymedzení

public int početVymedzení()

Vráti počet vymedzení, ktoré sú momentálne prítomné v tejto inštancii podpory SVG formátu. Vymedzenia mohli byť pridané počas čítania zo súboru alebo napríklad metódou pridajVymedzenie.

Definícia vymedzenia

Vymedzenia inštancie SVG podpory môžu byť ľubovoľné objekty, ku ktorým môžu byť asociované principiálne rovnaké skupiny atribútov ako je to pri tvaroch. Počas čítania SVG súboru sú medzi vymedzenia automaticky zaraďované napríklad lineárne alebo radiálne gradienty. (Tie sa potom dajú identifikovať prostredníctvom atribútu id, ale metódy náterVýplne.a náterČiary ich vyhľadávajú automaticky.)

Keďže vymedzenie môže byť objekt ľubovoľného typu, musí byť po prevzatí vymedzenia zo zásobníka vykonaná kontrola (operátorom instanceof) a pretypovanie podľa očakávaného a/alebo požadovaného typu objektu.

Počas zápisu obsahu SVG podpory do súboru môžu byť niektoré vymedzenia využité, ale nemusia. To závisí od toho, či sú od vymedzení závislé zapisované tvary.

Návratová hodnota:

aktuálny počet vymedzení tejto inštancie

pocetVymedzeni

public int pocetVymedzeni()

Alias pre početVymedzení.

vymažVymedzenie

public void vymažVymedzenie(int index)

Odstráni vymedzenie tejto inštancie so zadaným indexom. Táto metóda odstráni samotný objekt vymedzenia aj atribúty s ním asociované. Ako v ostatných prípadoch, index nula označuje prvé vymedzenie v zásobníku. Ak je zadaný index záporný, tak bude metóda brať do úvahy vymedzenie od konca zásobníka. To znamená, že index -1 označuje posledné vymedzenie v zásobníku. Ak index ani po úprave zo zápornej hodnoty na kladnú neukazuje na jestvujúce vymedzenie, to znamená, že jeho hodnota je mimo rozsahu 0 až počet() - 1, tak metóda vráti hodnotu null.

Upozornenie: Pozri definíciu vymedzenia v opise metódy početVymedzení.

Parametre:

index – index vymedzenia, ktoré má byť vymazané

vymazVymedzenie

public void vymazVymedzenie(int index)

Alias pre vymažVymedzenie.

dajVymedzenie

public Object dajVymedzenie(int index)

Poskytne objekt vymedzenia uložený vo vnútornom zásobníku tejto inštancie so zadaným „poradovým číslom,“ respektíve indexom. To znamená, že nula označuje prvé vymedzenie v zásobníku. Ak je zadaný index záporný, metóda bude hľadať vymedzenie od konca zásobníka. To znamená, že index -1 označuje posledné vymedzenie vložené do vnútorného zásobníka. Ak index ani po úprave zo zápornej hodnoty na kladnú neukazuje na jestvujúce vymedzenie, to znamená, že jeho hodnota je mimo rozsahu 0 až počet() - 1, tak metóda vráti hodnotu null.

Upozornenie: Pozri definíciu vymedzenia v opise metódy početVymedzení.

Parametre:

index – index požadovaného vymedzenia z vnútorného zásobníka

Návratová hodnota:

objekt vymedzenia uložený vo vnútornom zásobníku pod zadaným indexom alebo null

prepíšVymedzenie

public void prepíšVymedzenie(int index,
                             Object vymedzenie)

Prepíše objekt vymedzenia určený indexom v rámci vnútorného zásobníka vymedzení. Všetky atribúty asociované s vymedzením zostanú zachované. Ak je zadaný index záporný, tak metóda prepíše objekt vymedzenia počítaného od konca zásobníka. To znamená, že index -1 označuje posledné vymedzenie v zásobníku. Ak kladný alebo záporný index ukáže na vymedzenie mimo zásobníka, tak metóda nevykoná žiadnu akciu. Ak je hodnota argumentu vymedzenie rovná null, tak metóda tiež nevykoná žiadnu akciu – vymedzenie nesmie byť nedefinované; na vymazanie vymedzenia (aj s atribútmi) treba použiť metódu vymažVymedzenie.

Upozornenie: Pozri definíciu vymedzenia v opise metódy početVymedzení.

Parametre:

index – index vymedzenia vo vnútornom zásobníku (hodnoty mimo platného rozsahu sú ignorované)

vymedzenie – nové vymedzenie – objekt, ktorým má byť nahradené jestvujúce vymedzenie vo vnútornom zásobníku vymedzení (hodnota null je ignorovaná)

prepisVymedzenie

public void prepisVymedzenie(int index,
                             Object vymedzenie)

Alias pre prepíšVymedzenie.

nahraďVymedzenie

public void nahraďVymedzenie(int index,
                             Object vymedzenie)

Alias pre prepíšVymedzenie.

nahradVymedzenie

public void nahradVymedzenie(int index,
                             Object vymedzenie)

Alias pre prepíšVymedzenie.

nastavVymedzenie

public void nastavVymedzenie(int index,
                             Object vymedzenie)

Alias pre prepíšVymedzenie.

dajAtribútVymedzenia

public String dajAtribútVymedzenia(int index,
                                   String meno)

Poskytne hodnotu atribútu asociovaného s objektom vymedzenia so zadaným indexom. Ak je zadaný index záporný, metóda bude hľadať atribút pre vymedzenie od konca zásobníka. To znamená, že index -1 označuje posledné vymedzenie vložené do vnútorného zásobníka. Ak požadovaný atribút (alebo vymedzenie) nejestvuje, tak metóda vráti hodnotu null.

Upozornenie: Pozri definíciu vymedzenia v opise metódy početVymedzení.

Pozor! Atribúty, ktoré sú kľúčové pri vyjadrení konkrétneho vymedzenia (napr. cx, cy, r atď. pri radiálnom gradiente, x1, y1 atď. pri lineárnom gradiente a podobne) sú použité ešte počas konštrukcie objektu vymedzenia, ktorý je nemenný (angl. immutable), čiže jeho dodatočná úprava na základe zmien hodnôt týchto atribútov nie je možná. Avšak rôzne úpravy týchto atribútov zakázané nie sú, preto ich prečítanie touto metódou nemusí poskytovať výsledky konzistentné so stavom objektu vymedzenia. Odporúčame kľúčovéh hodnoty overovať priamo v objekte vymedzenia, napríklad metódami gradientov: getCenterPoint(), getRadius(), getStartPoint()… Naopak, atribúty ako je identifikátor id má zmysel čítať len touto metódou.

Parametre:

index – index požadovaného vymedzenia z vnútorného zásobníka

meno – názov požadovaného atribútu asociovaného s vymedzením

Návratová hodnota:

reťazec s hodnotou požadovaného atribútu alebo null

dajAtributVymedzenia

public String dajAtributVymedzenia(int index,
                                   String meno)

Alias pre dajAtribútVymedzenia.

dajAtribútyVymedzenia

public String[] dajAtribútyVymedzenia(int index)

Poskytne zoznam názvov atribútov asociovaných s vymedzením so zadaným indexom. Ak je zadaný index záporný, tak metóda vytvorí zoznam atribútov pre vymedzenie od konca vnútorného zásobníka vymedzení. To znamená, že index -1 označuje posledné vymedzenie vložené do vnútorného zásobníka vymedzení. Ak požadované vymedzenie nejestvuje, tak táto metóda namiesto zoznamu vráti hodnotu null, inak vráti pole reťazcov (hoci aj prázdne).

Upozornenie: Pozri definíciu vymedzenia v opise metódy početVymedzení.

Poznámka: V rôznych fázach vývoja boli v tejto triede implementované dve rôzne metódy na vytváranie zoznamov atribútov tvarov: dajAtribúty a zoznamAtribútov (pozri aj ich opisy). Z dôvodu zachovania konzistentnosti boli definované dve obdobné metódy aj na tvorbu zoznamov atribútov vymedzení: dajAtribútyVymedzenia a zoznamAtribútovVymedzenia.

Parametre:

index – index vymedzenia, pre ktoré chceme získať zoznam názvov atribútov

Návratová hodnota:

pole reťazcov s názvami atribútov asociovaných s požadovaným vymedzením alebo null

dajAtributyVymedzenia

public String[] dajAtributyVymedzenia(int index)

Alias pre dajAtribútyVymedzenia.

prepíšAtribútVymedzenia

public void prepíšAtribútVymedzenia(int index,
                                    String meno,
                                    Object hodnota)

Prepíše, vloží novú alebo odstráni hodnotu atribútu asociovaného s vymedzením so zadaným indexom. Ak je index záporný, metóda bude hľadať vymedzenie od konca zásobníka. To znamená, že index -1 označuje posledné vymedzenie vložené do vnútorného zásobníka. Okrem toho musia byť splnené nasledujúce podmienky: index musí ukazovať na jestvujúce vymedzenie (po úprave prípadnej zápornej hodnoty) a meno nesmie byť null ani prázdny reťazec, inak nebude mať volanie tejto metódy žiadny efekt. Ak je hodnota rovná null, tak je atribút odstránený, v opačnom prípade je za novú hodnotu považovaný reťazec vytvorený z objektu volaním metódy hodnota.toString().

Upozornenie: Pozri definíciu vymedzenia v opise metódy početVymedzení.

Pozor! Atribúty, ktoré sú kľúčové pri vyjadrení konkrétneho vymedzenia (napr. cx, cy, r atď. pri radiálnom gradiente, x1, y1 atď. pri lineárnom gradiente a podobne) sú použité ešte počas konštrukcie objektu vymedzenia, ktorý je nemenný (angl. immutable), preto ich dodatočná úprava, nastavenie alebo vymazanie touto metódou nemá zmysel. (Pozri aj upozornenie v opise metódy dajAtribútVymedzenia.)

Parametre:

index – index vymedzenia vo vnútornom zásobníku

meno – názov atribútu asociovaného s vymedzením

hodnota – nová hodnota atribútu alebo null

prepisAtributVymedzenia

public void prepisAtributVymedzenia(int index,
                                    String meno,
                                    Object hodnota)

Alias pre prepíšAtribútVymedzenia.

nahraďAtribútVymedzenia

public void nahraďAtribútVymedzenia(int index,
                                    String meno,
                                    Object hodnota)

Alias pre prepíšAtribútVymedzenia.

nahradAtributVymedzenia

public void nahradAtributVymedzenia(int index,
                                    String meno,
                                    Object hodnota)

Alias pre prepíšAtribútVymedzenia.

nastavAtribútVymedzenia

public void nastavAtribútVymedzenia(int index,
                                    String meno,
                                    Object hodnota)

Alias pre prepíšAtribútVymedzenia.

nastavAtributVymedzenia

public void nastavAtributVymedzenia(int index,
                                    String meno,
                                    Object hodnota)

Alias pre prepíšAtribútVymedzenia.

zoznamAtribútovVymedzenia

public String[] zoznamAtribútovVymedzenia(int index)

Poskytne zoznam názvov atribútov asociovaných s vymedzením so zadaným indexom. Ak je zadaný index záporný, tak metóda vytvorí zoznam atribútov pre vymedzenie od konca vnútorného zásobníka vymedzení. To znamená, že index -1 označuje posledné vymedzenie vložené do vnútorného zásobníka vymedzení. Ak požadované vymedzenie nejestvuje, tak táto metóda namiesto zoznamu vráti hodnotu null, inak vráti pole reťazcov (hoci aj prázdne).

Upozornenie: Pozri definíciu vymedzenia v opise metódy početVymedzení.

Poznámka: V rôznych fázach vývoja boli v tejto triede implementované dve rôzne metódy na vytváranie zoznamov atribútov tvarov: dajAtribúty a zoznamAtribútov (pozri aj ich opisy). Z dôvodu zachovania konzistentnosti boli definované dve obdobné metódy aj na tvorbu zoznamov atribútov vymedzení: dajAtribútyVymedzenia a zoznamAtribútovVymedzenia.

Parametre:

index – index vymedzenia, pre ktoré chceme získať zoznam názvov atribútov

Návratová hodnota:

pole reťazcov s názvami atribútov asociovaných s požadovaným vymedzením alebo null

zoznamAtributovVymedzenia

public String[] zoznamAtributovVymedzenia(int index)

Alias pre zoznamAtribútovVymedzenia.

pridajVymedzenie

public void pridajVymedzenie(Object vymedzenie,
                             String... atribúty)

Vloží do vnútorného zásobníka tejto inštancie ďalšie vymedzenie s prípadnou sériou atribútov. Atribúty sú zadávané vo forme zoznamu parametrov atribúty, ktorý je vyhodnocovaný po dvojiciach prvkov. Prvý prvok znamená názov atribútu, druhý hodnotu.

Upozornenie: Pozri definíciu vymedzenia v opise metódy početVymedzení.

(Atribúty bez mena alebo s hodnotou null sú ignorované.)

Pozor! Atribúty, ktoré sú kľúčové pri vyjadrení konkrétneho vymedzenia (napr. cx, cy, r atď. pri radiálnom gradiente, x1, y1 atď. pri lineárnom gradiente a podobne) sú prevzaté priamo z objektu vymedzenia, preto ich nastavenie touto metódou nemá zmysel. (Pozri aj upozornenie v opise metódy dajAtribútVymedzenia.)

Parametre:

vymedzenie – inštancia objektu vymedzenia na uloženie

atribúty – séria dvojíc reťazcov určujúca doplňujúce atribúty vymedzenia

konverziaDoubleNaString

public String konverziaDoubleNaString(double hodnota)

Prevedie hodnotu z údajového typu double do reťazcového tvaru. Toto je pracovná verzia metódy, ktorá je v súčasnosti používaná vnútorne. Pri prevode používa mapy jednotiek a výsledok uvádza v jednotkách px.

Parametre:

hodnota – vstupná hodnota

Návratová hodnota:

výsledný reťazec v px

pridaj

public void pridaj(Shape tvar,
                   GRobot tvorca,
                   String... atribúty)

Vloží do vnútorného zásobníka tejto inštancie ďalší tvar so základnými atribútmi (ťah a/alebo výplň) nastavenými podľa zadaného tvorcu a s prípadnou doplňujúcou sériou atribútov. Táto metóda kombinuje správanie metód pridaj(tvar, atribúty) a pridajText(text, tvorca, atribúty). Základné atribúty nastaví podľa tvorcu, ale umožní programátorovi pridať ďalšie, prípadne eliminovať tie, ktoré táto metóda pridáva predvolene.

Trieda pri ukladaní tvarov do súboru nájde vhodnú reprezentáciu zadaného tvaru vo forme XML/SVG značky (pozri aj metódu dajSVG(index)), ku ktorej priradí sériu zadaných atribútov.

Poznámky: Atribúty bez mena sú ignorované a na rozdiel od metódy pridaj(tvar, atribúty) sú v tejto metóde atribúty s hodnotou null pri spracovaní odstránené, čo sa dá využiť na úpravu niektorých predvolene vytváraných atribútov – napríklad na odstránenie predvolenej výplne – fill, fill-opacity alebo reset predvoleného pootočenia, ktoré sa ukladá vo forme transformácie otočenia do atribútu transform. Atribút transform má pritom špeciálny spôsob spracovania. Ak jeho hodnota nie je rovná null, tak je pripojená k pôvodnej (hoci aj vygenerovanej) hodnote. To znamená, že v prípade tohto atribútu má zmysel i jeho opakovaný výskyt v zozname atribútov.

Poznámky: Na rozdiel od SVG štandardu sú touto metódou považované za predvolené tieto hodnoty nasledujúcich dvoch atribútov: round pre stroke-linecap a rovnako pre stroke-linejoin. Dôvodom je predvolené nastavenie v preddefinovanej SVG šablóne, ktoré zodpovedá predvolenému nastaveniu čiar robotov. Ak má čiara tvorcu nastavené tieto hodnoty, tak metóda tieto atribúty nenastaví. Ak programátor šablónu zmení a potrebuje tieto atribúty pre niektorý objekt nastaviť, tak ich musí uviesť zvlášť (v zozname doplňujúcich atribútov tejto metódy).

Pozor! Atribúty, ktoré sú kľúčové pri vyjadrení konkrétneho tvaru (napr. cx, cy, r pri kružnici, points pri polygóne, d pri ceste a podobne) sú počas prevodu do XML/SVG tvaru nahradené konkrétnymi hodnotami. Preto ich nastavenie touto metódou nemá zmysel.

Parametre:

tvar – inštancia tvaru na uloženie

tvorca – robot, z ktorého budú prevzaté niektoré parametre užitočné počas vytvárania tvaru

atribúty – séria dvojíc reťazcov určujúca doplňujúce atribúty tvaru

dajOrezanie

public String dajOrezanie(Shape klip)

Vráti odkaz na orezanie, ktoré je definované v špeciálnych definíciách tejto SVG inštancie podľa zadaného tvaru. Ak orezanie nejestvuje a ani nemohlo byť podľa zadaného tvaru vytvorené nové, tak metóda vráti hodnotu null.

Parametre:

klip – tvar určujúci orezanie

Návratová hodnota:

odkaz na orezanie zo zoznamu špeciálnych definícií (alebo null)

pridajÚsečku

public void pridajÚsečku(GRobot tvorca,
                         String... atribúty)

Pridá úsečku vymedzenú posledným navštíveným bodom tvorcu a jeho aktuálnou polohou. Táto metóda bola pridaná na zjednodušenie pridávania úsečiek do inštancie SVG podpory. Principiálne používa nasledujúci algoritmus:

double x0 = Svet.prepočítajX(tvorca.poslednáPolohaX());
double y0 = Svet.prepočítajY(tvorca.poslednáPolohaY());

double x1 = Svet.prepočítajX(tvorca.polohaX());
double y1 = Svet.prepočítajY(tvorca.polohaY());

svgPodpora.pridaj(new Line2D.Double(x0, y0, x1, y1), tvorca, atribúty);

Z toho vyplýva, že pri použití tejto metódy sú relevantné všetky informácie uvedené v opise metódy pridaj(tvar, tvorca, atribúty).

Ak potrebujete pridať iný typ čiary (napríklad oblúk), tak použite principiálne nasledujúci algoritmus (ale zabezpečte, aby mal tvorca vypnuté vypĺňanie tvarov – to je síce predvolené nastavenie robota, ale ak ste ho zmenili, treba ho pred týmto algoritmom vrátiť do pôvodného stavu; mimochodom, metóda pridajÚsečku tento stav vnútorne automaticky zálohuje, nastavuje a obnovuje):

začniCestu();
choďNaPoOblúku(poloha);
svgPodpora.pridaj(cesta(), this);

Parametre:

tvorca – robot, z ktorého budú prevzaté niektoré parametre užitočné počas vytvárania tvaru

atribúty – séria dvojíc reťazcov určujúca doplňujúce atribúty tvaru

pridajUsecku

public void pridajUsecku(GRobot tvorca,
                         String... atribúty)

Alias pre pridajÚsečku.

definície

public Vector<String> definície()

Vráti aktuálny zoznam (zásobník) špeciálnych definícií tejto SVG inštancie. Vrátený zoznam je úplne modifikovateľný a všetky zásahy do neho znamenajú priamy zásah do vnútorného zásobníka tejto inštancie (vrátená inštancia zoznamu je tá istá, ktorá je vnútornou inštanciou tejto SVG inštancie). Obsah tohto zoznamu bude vložený na miesto rezervovaného reťazca $DEFINÍCIE (resp. $DEFS) v SVG alebo HTML šablóne. Obsah tohto zoznamu upravujú tieto metódy: náterNaReťazec a vymaž.

Odporúčané zdroje:

• SVGElements/defs – HTML Wiki (cit. 7. 5. 2022).
• <defs> SVG : Scalable Vector Graphics | MDN (cit. 7. 5. 2022).
• SVG defs Element – JavaTPoint (cit. 7. 5. 2022).

Návratová hodnota:

odkaz na vnútornú inštanciu špeciálnych SVG definícií

definicie

public Vector<String> definicie()

Alias pre definície.

štýl

public Vector<String> štýl()

Vráti aktuálny zoznam (zásobník) definícií štýlov (CSS) tejto SVG inštancie. Vrátený zoznam je úplne modifikovateľný a všetky zásahy do neho znamenajú priamy zásah do vnútorného zásobníka tejto inštancie (vrátená inštancia zoznamu je tá istá, ktorá je vnútornou inštanciou tejto SVG inštancie). Obsah tohto zoznamu bude vložený na miesto rezervovaného reťazca $ŠTÝL (resp. $STYLE) v SVG alebo HTML šablóne.

Príklad použitia:

svgPodpora.štýl().add("svg { background: " + SVGPodpora.
    farbaNaReťazec(Svet.farbaPozadia(), true) + "; }");

Odporúčané zdroje:

• <style> – SVG : Scalable Vector Graphics | MDN (cit. 30. 10. 2022).

Návratová hodnota:

odkaz na vnútornú inštanciu zoznamu CSS definícií

styl

public Vector<String> styl()

Alias pre štýl.

náterNaReťazec

public String náterNaReťazec(Paint náter)

Pokúsi sa previesť zadaný náter do reťazcovej podoby – do definície podľa štandardu SVG. Ak je zadaný náter jeden z podporovaných typov, tak metóda vráti jeho textový tvar. Ak náter vyžaduje pridanie novej (špeciálnej) SVG definície, tak ju metóda automaticky vloží do zoznamu definícií. V prípade neúspechu vráti metóda hodnotu null.

• Gradients in SVG – SVG: Scalable Vector Graphics. MDN Web Docs. (cit. 8. 5. 2022).
• Gradients and Patterns – SVG 1.1 (Second Edition). W3Schools Online Web Tutorials. (cit. 8. 5. 2022).
• Working GradientPaint Trieda in Java. C# Corner – Community of Software and Data Developers. (cit. 8. 5. 2022).
• SVG Gradients – Linear. W3Schools Online Web Tutorials. (cit. 8. 5. 2022).
• SVG Gradients – Radial. W3Schools Online Web Tutorials. (cit. 8. 5. 2022).
• GradientPaint. Java Platform SE 8. (cit. 8. 5. 2022).
• LinearGradientPaint. Java Platform SE 8. (cit. 8. 5. 2022).
• RadialGradientPaint. Java Platform SE 8. (cit. 8. 5. 2022).

Parametre:

náter – inštancia náteru (Paint), ktorá má byť prevedená do reťazcovej (SVG) podoby

Návratová hodnota:

reťazec obsahujúci SVG definíciu náteru alebo null, ak bol náter neznámeho typu (alebo nejestvuje)

naterNaRetazec

public String naterNaRetazec(Paint náter)

Alias pre náterNaReťazec.

náterPodľaObrázka

public String náterPodľaObrázka(Image obrázok)

Zatiaľ neimplementované! Tento opis sa vzťahuje na plánovanú funkčnosť.

Vytvorí zo zadaného obrázka novú (špeciálnu) SVG definíciu a vráti odkaz na ňu. Definícia bude obsahovať obrázkový náter kódovaný algorimom Base64 a transformovaný podľa aktuálnych transformačných nastavení obrázkových náterov sveta: posunutia, mierky a otočenia.

Parametre:

obrázok – obrázok, ktorý bude pridaný medzi (špeciálne) SVG definície ako nový náter

Návratová hodnota:

odkaz na vytvorenú (špeciálnu) SVG definíciu

naterPodlaObrazka

public String naterPodlaObrazka(Image obrázok)

Alias pre náterPodľaObrázka.

pridajText

public void pridajText(String text,
                       GRobot tvorca,
                       String... atribúty)

Vloží do vnútorného zásobníka tejto inštancie nový tvar reprezentujúci text (znaky, textovú informáciu) s prípadnou sériou atribútov. Pri kreslení (až vo fáze kreslenia, čiže text zostáva v SVG reprezentácii vo forme textu a dá sa dodatočne upravovať) je zo zadaného textu vytvorený obrys podľa niektorých parametrov, ktoré sú pri procese pridávania textu prevzaté zo zadaného robota (konkrétne písmo, poloha, spôsob kreslenia textov a pootočenie robota, ktoré určia vlastnosti písma, polohu kreslenia a pootočenie kresleného textu; farba robota, ktorá je použitá na určenie predvolenej farby výplne textu – čiže predvolene nie je nakreslený vygenerovaný obrys textu, ale jeho výplň).

Trieda pri ukladaní tvarov do súboru použije XML/SVG značku <text>, ku ktorej priradí sériu základných a zadaných atribútov. Obsahom značky <text> bude zadaný text.

Poznámky: Atribúty bez mena sú ignorované a na rozdiel od metódy pridaj(tvar, atribúty) sú v tejto metóde atribúty s hodnotou null pri spracovaní odstránené, čo sa dá využiť na úpravu niektorých predvolene vytváraných atribútov – napríklad na odstránenie predvolenej výplne – fill, fill-opacity alebo reset predvoleného pootočenia, ktoré sa ukladá vo forme transformácie otočenia do atribútu transform. Atribút transform má pritom špeciálny spôsob spracovania. Ak jeho hodnota nie je rovná null, tak je pripojená k pôvodnej (hoci aj vygenerovanej) hodnote. To znamená, že v prípade tohto atribútu má zmysel i jeho opakovaný výskyt v zozname atribútov.

Pozor! Základné atribúty textu (to jest poloha: x, y a vlastnosti písma: font-family, font-size, font-weight a font-style) sú v prípade ich platnosti počas prevodu do XML/SVG tvaru prepísané konkrétnymi hodnotami, preto ich nastavenie touto metódou buď nemá zmysel (v prípade polohy), alebo sa ich efekt nemusí prejaviť (v prípade vlastností písma).

Parametre:

text – text, z ktorého bude pri kreslení vytvorený obrys (predvolene je obrys vyplnený, takže vizuálne vyzerá ako klasický text)

tvorca – robot, z ktorého budú prevzaté niektoré parametre užitočné počas vytvárania prislúchajúcej SVG definície tvaru

atribúty – séria dvojíc reťazcov určujúca doplňujúce atribúty výsledného SVG tvaru (textu)

pridajText

public void pridajText(String text,
                       String... atribúty)

Vloží do vnútorného zásobníka tejto inštancie nový tvar reprezentujúci text (znaky, textovú informáciu) s prípadnou sériou atribútov.

Metóda funguje rovnako ako metóda pridajText(text, tvorca, atribúty) s tým, že na doplnenie chýbajúcich atribútov (poloha, písmo…) je použitý hlavný robot.

Parametre:

text – text, ktorý má byť pridaný k ostatným SVG tvarom

atribúty – séria dvojíc reťazcov určujúca doplňujúce atribúty textu

Pozri tiež:

pridajText(String, GRobot, String[])

pridajObrázok

public void pridajObrázok(Image obrázok,
                          GRobot tvorca,
                          String... atribúty)

Zatiaľ neimplementované! Tento opis sa vzťahuje na plánovanú funkčnosť.

Vloží do vnútorného zásobníka tejto inštancie nový tvar reprezentujúci obrázok (bitovú mapu) s prípadnou sériou atribútov. Pri procese pridávania sú zo zadaného robota prevzaté niektoré atribúty, ktoré spresnia spôsob kreslenia obrázka (konkrétne poloha, mierky, spôsob kreslenia obrázokov a pootočenie robota).

Trieda pri ukladaní tvarov do súboru použije XML/SVG značku <image>, ku ktorej priradí sériu základných a zadaných atribútov. Obsahom značky <image> bude zadaný obrázok kódovaný algoritmom Base64.

Poznámky: Atribúty bez mena sú ignorované a na rozdiel od metódy pridaj(tvar, atribúty) sú v tejto metóde atribúty s hodnotou null pri spracovaní odstránené, čo sa dá využiť na úpravu niektorých predvolene vytváraných atribútov – napríklad na reset predvoleného pootočenia, ktoré sa ukladá vo forme transformácie otočenia do atribútu transform. Atribút transform má pritom špeciálny spôsob spracovania. Ak jeho hodnota nie je rovná null, tak je pripojená k pôvodnej (hoci aj vygenerovanej) hodnote. To znamená, že v prípade tohto atribútu má zmysel i jeho opakovaný výskyt v zozname atribútov.

Pozor! Základné atribúty obrázka (to jest poloha: x, y, obsah: href a rozmery: width, height) sú v prípade ich platnosti počas prevodu do XML/SVG tvaru prepísané konkrétnymi hodnotami, preto ich nastavenie touto metódou buď nemá zmysel (najmä v prípade obsahu), alebo sa ich efekt nemusí prejaviť.

Parametre:

obrázok – rastrový obrázok, ktorý bude pridaný do SVG kódu

tvorca – robot, z ktorého budú prevzaté niektoré parametre užitočné počas vytvárania prislúchajúcej SVG definície tvaru

atribúty – séria dvojíc reťazcov určujúca doplňujúce atribúty výsledného SVG tvaru (obrázka)

pridajObrazok

public void pridajObrazok(Image obrázok,
                          GRobot tvorca,
                          String... atribúty)

Alias pre pridajObrázok.

pridajObrázok

public void pridajObrázok(Image obrázok,
                          String... atribúty)

Zatiaľ neimplementované! Tento opis sa vzťahuje na plánovanú funkčnosť.

Vloží do vnútorného zásobníka tejto inštancie nový tvar reprezentujúci obrázok (bitovú mapu) s prípadnou sériou atribútov.

Metóda funguje rovnako ako metóda pridajObrázok(obrázok, tvorca, atribúty) s tým, že na doplnenie chýbajúcich atribútov (poloha, orientácia…) je použitý hlavný robot.

Parametre:

obrázok – obrázok, ktorý má byť pridaný k ostatným SVG tvarom

atribúty – séria dvojíc reťazcov určujúca doplňujúce atribúty obrázka

Pozri tiež:

pridajObrázok(Image, GRobot, String[])

pridajObrazok

public void pridajObrazok(Image obrázok,
                          String... atribúty)

Alias pre pridajObrázok.

zapíš

public int zapíš(String meno,
                 String titulok,
                 boolean prepísať)

Táto metóda slúži na export tvarov uložených vo vnútornom zásobníku tejto inštancie do formátu SVG. Podľa zadanej prípony súboru (povolené sú len tieto: .htm, .html a .svg) bude na export použitá šablóna HTML (pozri aj htmlŠablóna) alebo SVG (pozri aj svgŠablóna). Pre každý tvar, ktorý bol vložený do vnútorného zásobníka tejto inštancie bude nájdená vhodná reprezentácia v rámci štandardu SVG (pozri aj metódy dajSVG(index) a pridajText(tvar, tvorca, atribúty)).

Exportované tvary sú prepočítané tak, aby mohli byť spracúvané v predvolenom súradnicovom priestore Javy, v ktorom sa „nula“ (to jest počiatok súradnicovej sústavy) nachádza v ľavom hornom rohu plátna a y-ová súradnica stúpa smerom nadol. Tento súradnicový priestor je bežne používaný v oblasti 2D počítačovej grafiky a používa ho aj formát SVG. (V skutočnosti táto konverzia prebieha už počas vytvárania tvarov Javy.)

Poznámka: Pri exporte nie sú využité vlastnosti SVG 2.0, najmä takzvaný „bearing“ – aktuálne pootočenie, ktorý má v budúcnosti slúžiť na implementáciu korytnačej grafiky v rámci štandardu SVG. Dôvodom nepoužitia novšej verzie štandardu je to, že súčasný softvér tento štandard nie je schopný spracovať. To znamená, že takto exportované údaje by neboli v praxi použiteľné.

Parametre:

meno – názov súboru (s príponou .htm, .html alebo .svg), do ktorého majú byť zapísané tvary vo formáte SVG

titulok – titulok súboru; ak je zadaná hodnota null, tak sa použije predvolený tvar titulku: SVG tvary generované programovacím rámcom GRobot «verzia», © «roky vývoja», «hlavný vývojár»

prepísať – príznak prepísania jestvujúceho súboru; ak je zadaná hodnota true, tak v prípade, že cieľový súbor jestvuje, je prepísaný; ak je zadaná hodnota false, tak v prípade, že cieľový súbor jestvuje, vráti metóda hodnotu -1

Návratová hodnota:

počet zapísaných (exportovaných) tvarov alebo -1 ak bol pokus o zápis neúspešný

Výnimky:

GRobotException – ak nastane chyba počas zápisu súboru

zapis

public int zapis(String meno,
                 String titulok,
                 boolean prepísať)

Alias pre zapíš.

zapíš

public int zapíš(String meno,
                 String titulok)

Metóda exportuje tvary uložené vo vnútornom zásobníku tejto inštancie do formátu SVG.

Ďalšie podrobnosti si prečítajte v opise metódy zapíš(meno, titulok, prepísať).

Táto metóda sa správa tak, ako keby bola uvedená metóda volaná s nasledujúcimi hodnotami argumentov: zapíš(meno, titulok, false).

Parametre:

meno – názov súboru, do ktorého majú byť zapísané tvary vo formáte SVG

titulok – titulok súboru (alebo null)

Návratová hodnota:

počet zapísaných (exportovaných) tvarov alebo -1 ak bol pokus o zápis neúspešný

zapis

public int zapis(String meno,
                 String titulok)

Alias pre zapíš.

zapíš

public int zapíš(String meno)

Metóda exportuje tvary uložené vo vnútornom zásobníku tejto inštancie do formátu SVG.

Ďalšie podrobnosti si prečítajte v opise metódy zapíš(meno, titulok, prepísať).

Táto metóda sa správa tak, ako keby bola uvedená metóda volaná s nasledujúcimi hodnotami argumentov: zapíš(meno, null, false).

Parametre:

meno – názov súboru, do ktorého majú byť zapísané tvary vo formáte SVG

Návratová hodnota:

počet zapísaných (exportovaných) tvarov alebo -1 ak bol pokus o zápis neúspešný

zapis

public int zapis(String meno)

Alias pre zapíš.

dajSVG

public String dajSVG(String formát,
                     String titulok)

Táto metóda slúži na export všetkých tvarov uložených vo vnútornom zásobníku tejto inštancie do formátu SVG. Podľa zadaného formátu (povolené sú: HTML a SVG) bude na export použitá šablóna HTML (pozri aj htmlŠablóna) alebo SVG (pozri aj svgŠablóna) a výsledok je vrátený vo forme reťazca v návratovej hodnote tejto metódy. Inak táto metóda funguje rovnako ako metóda zapíš.

Parametre:

formát – formát exportovaného SVG reťazca; povolené sú dva formáty: HTML a SVG

titulok – obsah značky <title>; ak je zadaná hodnota null, tak sa použije predvolený tvar: SVG tvary generované programovacím rámcom GRobot «verzia», © «roky vývoja», «hlavný vývojár»

Návratová hodnota:

buď reťazec s exportovaným SVG v požadovanom formáte, alebo prázdny reťazec (""), ak export zlyhal

Výnimky:

GRobotException – ak nastane chyba počas zápisu súboru

dajSVG

public String dajSVG(String formát)

Metóda exportuje tvary uložené vo vnútornom zásobníku tejto inštancie do formátu SVG.

Ďalšie podrobnosti si prečítajte v opise metódy dajSVG(formát, titulok).

Táto metóda sa správa tak, ako keby bola uvedená metóda volaná s nasledujúcimi hodnotami argumentov: dajSVG(formát, null).

Parametre:

formát – formát exportovaného SVG reťazca; povolené sú dva formáty: HTML a SVG

Návratová hodnota:

buď reťazec s exportovaným SVG v požadovanom formáte, alebo prázdny reťazec (""), ak export zlyhal

dajSVG

public String dajSVG()

Metóda exportuje tvary uložené vo vnútornom zásobníku tejto inštancie do formátu SVG.

Ďalšie podrobnosti si prečítajte v opise metódy dajSVG(formát, titulok).

Táto metóda sa správa tak, ako keby bola uvedená metóda volaná s nasledujúcimi hodnotami argumentov: dajSVG("SVG", null).

Návratová hodnota:

buď reťazec s exportovaným SVG v požadovanom formáte, alebo prázdny reťazec (""), ak export zlyhal

pridajSVG

public int pridajSVG(String xmlSVG)

Spracuje zadaný reťazec ako súčasť SVG definície a v prípade, že sú nájdené korektné XML/SVG údaje tvarov, pribudnú podľa nich do vnútorného zásobníka tejto inštancie ďalšie tvary. (Pozri aj metódy čítaj(meno), pridaj(tvar, atribúty), pridajText(tvar, tvorca, atribúty) a dajSVG(index).)

Parametre:

xmlSVG – vstupné XML/SVG údaje

Návratová hodnota:

počet tvarov, ktoré sa podarilo vo vstupných údajoch rozpoznať alebo -1 ak analýza údajov zlyhá

Výnimky:

GRobotException – ak nastane chyba počas spracovania vstupných údajov

čítaj

public int čítaj(String meno)

Metóda postupne analyzuje XML údaje v zadanom SVG súbore (meno) a do vnútorného zásobníka uloží všetky tvary, ktoré v rámci analyzovaných údajov nájde a to bez ohľadu na ich umiestnenie vo vrstvách, skupinách alebo v rámci definícií takzvaných značiek (angl. marker) a podobne. Ak boli čítanie súboru a jeho analýza úspešné, tak metóda vráti počet spracovaných tvarov (ktoré pribudli do vnútorného zásobníka inštancie), inak vráti hodnotu -1.

Importované tvary sú spracúvané v predvolenom súradnicovom priestore Javy, v ktorom „nula“ (to jest počiatok súradnicovej sústavy) sa nachádza v ľavom hornom rohu plátna a y-ová súradnica stúpa smerom nadol. Tento súradnicový priestor je bežne používaný v oblasti 2D počítačovej grafiky a používa ho aj formát SVG.

Všetky tvary uložené vo vnútornom zásobníku a/alebo niektoré ich atribúty (súvisiace s ich vizuálnymi vlastnosťami) je možné získať metódami: daj(index), dajAtribút(index, meno), farbaVýplne(index), farbaČiary(index), hrúbkaČiary(index) atď.

Parametre:

meno – názov súboru, z ktorého majú byť prečítané (importované) SVG tvary

Návratová hodnota:

počet prečítaných tvarov (z množiny podporovaných tvarov) alebo -1 ak sa čítanie tvarov ani nemohlo začať (napríklad preto, že súbor nejestvuje)

Výnimky:

GRobotException – ak nastane chyba počas spracovania súboru

citaj

public int citaj(String meno)

Alias pre čítaj.