- Hlavní stránka
- Balíky
- Třídy
- Soubory

- Seznam souborů

# Tabulka.java

Zobrazit dokumentaci tohoto souboru.

    00001 /******************************************************************************
    00002  * Název projektu: Aplet pro demonstraci Boyerova-Mooreova algoritmu
    00003  * Balíček: boyermooredemo
    00004  * Soubor: Tabulka.java
    00005  * Datum:  11.4.2008
    00006  * Poslední změna: 18.4.2008
    00007  * Autor:  Jaroslav Dytrych xdytry00
    00008  *
    00009  * Popis: Třída pro vytvoření tabulky, která má záhlaví v jednotlivých řádcích
    00010  *        prvního sloupce, nebo vůbec.
    00011  *             V případě, že se text nevejde do buňky tabulky, buňky jsou
    00012  *        automaticky rozšířeny. První a poslední sloupec mohou mít jinou šířku,
    00013  *        než sloupce ve zbytku tabulky.
    00014  *             Rozměry tabulky lze za běhu měnit. Tabulka by měla být umístěna
    00015  *        ve skrolovacím panelu, jehož skrolovatelnou oblast a krok skrolování
    00016  *        nastavuje v rámci implementace rozhraní Scrollable.
    00017  *
    00018  ******************************************************************************/
    00019
    00020 /**
    00021  * @file Tabulka.java
    00022  *
    00023  * @brief Třída Tabulka - vytvoření tabulky se záhlavími řádků
    00024  */
    00025
    00026 package boyermooredemo;
    00027
    00028 import java.awt.BasicStroke;
    00029 import java.awt.Color;
    00030 import java.awt.Dimension;
    00031 import java.awt.Font;
    00032 import java.awt.FontMetrics;
    00033 import java.awt.Graphics;
    00034 import java.awt.Graphics2D;
    00035 import java.awt.Rectangle;
    00036
    00037 import javax.swing.JPanel;
    00038 import javax.swing.Scrollable;
    00039
    00040 /**
    00041  * Třída pro vytvoření tabulky, která má záhlaví v jednotlivých řádcích prvního
    00042  * sloupce, nebo vůbec.
    00043  *      V případě, že se text nevejde do buňky tabulky, buňky jsou automaticky
    00044  * rozšířeny. První a poslední sloupec mohou mít jinou šířku, než sloupce
    00045  * ve zbytku tabulky.
    00046  *      Rozměry tabulky lze za běhu měnit. Tabulka by měla být umístěna
    00047  * ve skrolovacím panelu, jehož skrolovatelnou oblast a krok skrolování
    00048  * nastavuje v rámci implementace rozhraní Scrollable.
    00049  *
    00050  * @brief Třída pro vytvoření tabulky se záhlavími řádků
    00051  */
    00052 public class Tabulka extends JPanel implements Scrollable {
    00053   /**
    00054    * Proměnná pro počet řádků tabulky
    00055    */
    00056   private int pocetRadku = 0;
    00057   /**
    00058    * Proměnná pro počet sloupců tabulky
    00059    */
    00060   private int pocetSloupcu = 0;
    00061   /**
    00062    * Tloušťka ohraničení buněk tabulky,
    00063    * kolem celé tabulky bude ohraničení dvojnásobné.
    00064    */
    00065   private int ohraniceni = 0;
    00066   /**
    00067    * pole s obsahy buněk tabulky
    00068    */
    00069   private String[][] bunky;
    00070   /**
    00071    * Pole s barvami buněk
    00072    *
    00073    * 3. rozměr rozlišuje barvu písma [0] a barvu pozadí [1]
    00074    */
    00075   private Color[][][] barvyBunek;
    00076   /**
    00077    * Barva pozadí tabulky
    00078    */
    00079   private Color barvaPozadi;
    00080   /**
    00081    * Barva písma v tabulce
    00082    */
    00083   private Color barvaPisma;
    00084   /**
    00085    * Šířka plátna, na kterém bude tabulka vykreslena
    00086    */
    00087   private int sirkaPlatna = 0;
    00088   /**
    00089    * Výška plátna, na kterém bude tabulka vykreslena
    00090    */
    00091   private int vyskaPlatna = 0;
    00092   /**
    00093    * Okraje buňky
    00094    */
    00095   private int okrajeBunky = 4;
    00096   /**
    00097    * Šířka prázdného řetězce v px
    00098    */
    00099   private int sirkaPrazdneho = 5;
    00100   /**
    00101    * Šířka buňky tabulky
    00102    */
    00103   private int sirkaBunky = 5;
    00104   /**
    00105    * Výška buňky tabulky
    00106    */
    00107   private int vyskaBunky = 10;
    00108   /**
    00109    * Metrika fontu - obsahuje metody pro zjišťování šířky a výšky řetězce
    00110    */
    00111   private FontMetrics metrikaFontu = null;
    00112   /**
    00113    * Proměnná, která určuje, zda bude 1. sloupec hlavička tabulky,
    00114    * tedy zda mít 1. sloupec jinou šířku
    00115    */
    00116   private boolean prvniHlavicka = false;
    00117   /**
    00118    * Šířka 1. sloupce tabulky
    00119    */
    00120   private int sirkaPrvniho = 5;
    00121   /**
    00122    * Proměnná, která určuje, zda bude mít poslední sloupec tabulky jinou šířku
    00123    */
    00124   private boolean posledniJiny = false;
    00125   /**
    00126    * Šířka posledního sloupce tabulky
    00127    */
    00128   private int sirkaPosledniho = 5;
    00129
    00130   /**
    00131    * Konstanta pro směr posunu vlevo
    00132    */
    00133   public static final int POSUN_VLEVO = 0;
    00134   /**
    00135    * Konstanta pro směr posunu vpravo
    00136    */
    00137   public static final int POSUN_VPRAVO = 1;
    00138
    00139   /**
    00140    * Konstruktor třídy, vytvoří tabulku a provede inicializaci
    00141    *
    00142    * @param radky Počet řádků tabulky
    00143    * @param sloupce Počet sloupců tabulky
    00144    * @param ohraniceniTabuky Tloušťka ohraničení buněk tabulky a současně
    00145    *                          1/2 tloušťky ohraničení celé tabulky
    00146    * @param okrajeBunkyTab Okraje buňky v tabulce
    00147    * @param barvaPozadiTab Barva pozadí tabulky
    00148    * @param barvaPismaTab Barva písma v tabulce
    00149    * @param prvniHlavickaTab Určuje, zda bude 1. sloupec sloužit jako hlavička tabulky
    00150    * @param posledniSlJiny Určuje, zda bude mít poslední sloupec tabulky jinou šířku
    00151    */
    00152   public Tabulka (int radky, int sloupce, int ohraniceniTabuky, int okrajeBunkyTab,
    00153                   Color barvaPozadiTab, Color barvaPismaTab,
    00154                   boolean prvniHlavickaTab, boolean posledniSlJiny)
    00155   {
    00156     this.setDoubleBuffered(true);  // zapne double-buffer
    00157     this.ohraniceni = ohraniceniTabuky;  // nastaví ohraničení tabulky
    00158     this.barvaPozadi = barvaPozadiTab;  // nastaví nbarvu pozadí
    00159     this.barvaPisma = barvaPismaTab;  // nastaví nbarvu písma
    00160     this.okrajeBunky = okrajeBunkyTab;  // nastaví okraje buňky
    00161     this.prvniHlavicka = prvniHlavickaTab;  // nastaví chování 1. sloupce
    00162     this.posledniJiny = posledniSlJiny;  // nastaví chování posledního sloupce
    00163     // nastaví rozměry tabulky
    00164     this.pocetRadku = radky;
    00165     this.pocetSloupcu = sloupce;
    00166     // zjistí metriku fontu
    00167     this.setFont(new Font("Arial",Font.PLAIN,12));
    00168     this.metrikaFontu = this.getFontMetrics(this.getFont());
    00169     if (prvniHlavickaTab)
    00170     {  // pokud první sloupec bude tvořit hlavičku tabulky
    00171       // upraví šířku 1. sloupce (přidá šířku 2. ohraničovací čáry)
    00172       this.sirkaPrvniho += 2 * this.ohraniceni;
    00173     }
    00174
    00175     // nastaví výchozí rozměry plátna
    00176     this.sirkaPlatna = 10;
    00177     this.vyskaPlatna = 10;
    00178
    00179     this.vyskaBunky = this.metrikaFontu.getMaxAscent();  // určí výšku buňky
    00180
    00181     this.bunky = new String[radky][sloupce];  // inicializace pole obsahů buněk
    00182     this.barvyBunek = new Color[radky][sloupce][2];  // inicializace pole barev buněk
    00183
    00184     for (int i = 0; i < radky; i++)
    00185     {  // procházení tabulky po řádcích
    00186       for (int j = 0; j < sloupce; j++)
    00187       {  // procházení tabulky po sloupcích
    00188         this.bunky[i][j] = "";  // nastaví obsah buňky
    00189         this.barvyBunek[i][j][0] = barvaPismaTab;  // nastaví barvu písma
    00190         this.barvyBunek[i][j][1] = barvaPozadiTab;  // nastaví barvu pozadí
    00191       }
    00192     }
    00193
    00194     // vypočítá rozměry plátna
    00195     // (vnější rámeček má dvojnásobný okraj, kolem tabulky je okraj 5 px)
    00196     this.sirkaPlatna = sloupce * (this.sirkaBunky + ohraniceniTabuky + this.okrajeBunky * 2)
    00197                        + 4 * ohraniceniTabuky + 10;
    00198     this.vyskaPlatna = radky * (this.vyskaBunky + ohraniceniTabuky + this.okrajeBunky * 2)
    00199                        + 4 * ohraniceniTabuky + 10;
    00200   }  // public Tabulka
    00201
    00202   /**
    00203    * Metoda pro vyprázdnění tabulky a nastavení výchozí barvy všech buněk
    00204    *
    00205    * @param vcetnePrvniho Pokud je false, první sloupec se ponechá beze změny
    00206    */
    00207   public void vyprazdniTabulku(boolean vcetnePrvniho)
    00208   {
    00209     int zacatek;
    00210     if (vcetnePrvniho)
    00211     {  // pokud se má vymazat vše
    00212       zacatek = 0;
    00213       if (this.prvniHlavicka)
    00214       {  // pokud je 1. sloupec hlavička
    00215         this.sirkaPrvniho = this.sirkaPrazdneho + 2 * this.ohraniceni;  // šířka 1. buňky
    00216       }
    00217       else
    00218       {  // pokud poslední sloupec není hlavička
    00219         this.sirkaPrvniho = this.sirkaPrazdneho;  // šířka 1. buňky
    00220       }
    00221     }  // pokud se má vymazat vše
    00222     else
    00223     {  // pokud se má 1. sloupec ponechat
    00224       zacatek = 1;
    00225     }
    00226     this.sirkaBunky = this.sirkaPrazdneho;  // nastaví výchozí šířku buněk
    00227     this.sirkaPosledniho = this.sirkaPrazdneho;  // nastaví šířku posledního sloupce
    00228
    00229     for (int i = 0; i < this.pocetRadku; i++)
    00230     {  // procházení tabulky po řádcích
    00231       for (int j = zacatek; j < this.pocetSloupcu; j++)
    00232       {  // procházení tabulky po sloupcích
    00233         this.bunky[i][j] = "";  // nastaví obsah buňky
    00234         this.barvyBunek[i][j][0] = this.barvaPisma;  // nastaví barvu písma
    00235         this.barvyBunek[i][j][1] = this.barvaPozadi;  // nastaví barvu pozadí
    00236       }
    00237     }
    00238     // přepočítá rozměry plátna
    00239     // (vnější rámeček má dvojnásobný okraj, kolem tabulky je okraj 5 px)
    00240     this.sirkaPlatna = (this.pocetSloupcu - 2) * (this.sirkaBunky + this.ohraniceni + this.okrajeBunky * 2)
    00241       + this.sirkaPrvniho + this.sirkaPosledniho + 2 * this.ohraniceni + this.okrajeBunky * 4
    00242       + 4 * this.ohraniceni + 10;
    00243     this.vyskaPlatna = this.pocetRadku * (this.vyskaBunky + this.ohraniceni + this.okrajeBunky * 2)
    00244       + 4 * this.ohraniceni + 10;
    00245     this.prekresliTabulku();  // překreslí tabulku
    00246   }  // public void vyprazdniTabulku()
    00247
    00248   /**
    00249    * Metoda pro nastavení obsahu buňky
    00250    *
    00251    * @param radek Řádek, na kterém se buňka nachází
    00252    * @param sloupec Sloupec, na kterém se buňka nachází
    00253    * @param hodnota Nová hodnota v buňce
    00254    */
    00255   public void nastavObsah(int radek, int sloupec, String hodnota)
    00256   {
    00257     int sirkaObsahu;
    00258     int porovnavanaSirka;
    00259     if (this.prvniHlavicka && sloupec == 0)
    00260     {  // pokud se bude aktualizovat šířka 1. sloupce
    00261       porovnavanaSirka = this.sirkaPrvniho;
    00262     }
    00263     else if (this.posledniJiny && sloupec == (this.pocetSloupcu - 1))
    00264     {  // pokud se bude aktualizovat šířka posledního sloupce
    00265       porovnavanaSirka = this.sirkaPosledniho;
    00266     }
    00267     else
    00268     {  // pokud se bude aktualizovat šířka buňky
    00269       porovnavanaSirka = this.sirkaBunky;
    00270     }
    00271     this.bunky[radek][sloupec] = hodnota;  // nastaví obsah buňky
    00272     if (hodnota.length() > 0)
    00273     {  // pokud bnka není prázdná
    00274       sirkaObsahu = metrikaFontu.stringWidth(hodnota);  // zjistí šířku řetězce
    00275     }
    00276     else
    00277     {  // pokud je buňka prázdná
    00278       sirkaObsahu = this.sirkaPrazdneho;
    00279     }
    00280     if (sirkaObsahu > porovnavanaSirka)
    00281     {  // pokud je třeba rozšířit buňky
    00282       if (this.prvniHlavicka && sloupec == 0)
    00283       {  // pokud se jedná o buňku hlavičky
    00284         this.sirkaPrvniho = sirkaObsahu;  // hozšíří hlavičku
    00285         // upraví šířku 1. sloupce (přidá šířku 2. ohraničovací čáry)
    00286         this.sirkaPrvniho += 2 * this.ohraniceni;
    00287       }
    00288       else if (this.posledniJiny && sloupec == (this.pocetSloupcu - 1))
    00289       {  // pokud se jedná o buňku posledního sloupce
    00290         this.sirkaPosledniho = sirkaObsahu;  // hozšíří buňky
    00291       }
    00292       else
    00293       {  // pokud se jedná o obecnou buňku
    00294         this.sirkaBunky = sirkaObsahu;  // hozšíří buňky
    00295         if (!this.prvniHlavicka)
    00296         {  // pokud 1. sloupec obsahuje obecné buňky
    00297           this.sirkaPrvniho = sirkaObsahu;
    00298         }
    00299         if (!this.posledniJiny)
    00300         {  // pokud poslední sloupec obsahuje obecné buňky
    00301           this.sirkaPosledniho = sirkaObsahu;
    00302         }
    00303       }  // pokud se jedná o obecnou buňku
    00304       // přepočítá rozměry plátna
    00305       // (vnější rámeček má dvojnásobný okraj, kolem tabulky je okraj 5 px)
    00306       this.sirkaPlatna = (this.pocetSloupcu - 2) * (this.sirkaBunky + this.ohraniceni + this.okrajeBunky * 2)
    00307         + this.sirkaPrvniho + this.sirkaPosledniho + 2 * this.ohraniceni + this.okrajeBunky * 4
    00308         + 4 * this.ohraniceni + 10;
    00309       this.vyskaPlatna = this.pocetRadku * (this.vyskaBunky + this.ohraniceni + this.okrajeBunky * 2)
    00310         + 4 * this.ohraniceni + 10;
    00311     }
    00312     this.prekresliTabulku();  // překreslí tabulku
    00313   }  // public void nastavObsah()
    00314
    00315   /**
    00316    * Metoda pro nastavení barev buňky
    00317    *
    00318    * @param radek Řádek, na kterém se buňka nachází
    00319    * @param sloupec Sloupec, na kterém se buňka nachází
    00320    * @param barvaPozadiB Nová barva pozadí buňky
    00321    * @param barvaPismaB Nová barva písma v buňce
    00322    */
    00323   public void nastavBarvu(int radek, int sloupec, Color barvaPozadiB, Color barvaPismaB)
    00324   {
    00325     this.barvyBunek[radek][sloupec][0] = barvaPismaB;  // nastaví barvu buňky
    00326     this.barvyBunek[radek][sloupec][1] = barvaPozadiB;  // nastaví barvu písma
    00327     this.prekresliTabulku();  // překreslí tabulku
    00328   }
    00329
    00330
    00331   /**
    00332    * Metoda pro minimalizaci šířky buňky tabulky
    00333    */
    00334   public void minimalizaceSirky()
    00335   {
    00336     int minSirka = this.sirkaPrazdneho;
    00337     int sirkaObsahu;
    00338     int zacatek;  // pomocná proměnná
    00339     if (this.prvniHlavicka)
    00340     {  // pokud je 1. sloupec hlavička
    00341       zacatek = 1;
    00342       for (int i = 0; i < this.pocetRadku; i++)
    00343       {  // nalezení nejširší buňky sloupce hlavičky
    00344         sirkaObsahu = this.metrikaFontu.stringWidth(bunky[i][0]);
    00345         if (sirkaObsahu > minSirka)
    00346         {
    00347           minSirka = sirkaObsahu;
    00348         }
    00349       }
    00350       this.sirkaPrvniho = minSirka;  // nastaví novou šířku hlavičky
    00351       // upraví šířku 1. sloupce (přidá šířku 2. ohraničovací čáry)
    00352       this.sirkaPrvniho += 2 * this.ohraniceni;
    00353     }
    00354     else
    00355     {  // pokud 1. sloupec není hlavička
    00356       zacatek = 0;
    00357     }
    00358     int konec = this.pocetSloupcu;
    00359     if (this.posledniJiny)
    00360     {  // pokud má poslední sloupec jinou šířku
    00361       konec--;  // poslední sloupec se nebude procházet
    00362       for (int i = 0; i < this.pocetRadku; i++)
    00363       {  // nalezení nejširší buňky posledního sloupce
    00364         sirkaObsahu = this.metrikaFontu.stringWidth(bunky[i][konec]);
    00365         if (sirkaObsahu > minSirka)
    00366         {
    00367           minSirka = sirkaObsahu;
    00368         }
    00369       }
    00370       this.sirkaPosledniho = minSirka;  // nastaví novou šířku posledního sloupce
    00371     }
    00372     // nalezení nejširšího obsahu buňky
    00373     for (int i = 0; i < this.pocetRadku; i++)
    00374     {  // procházení po řádcích
    00375       for (int j = zacatek; j < konec; j++)
    00376       {
    00377         sirkaObsahu = this.metrikaFontu.stringWidth(bunky[i][j]);
    00378         if (sirkaObsahu > minSirka)
    00379         {
    00380           minSirka = sirkaObsahu;
    00381         }
    00382       }
    00383     }  // procházení po řádcích
    00384     this.sirkaBunky = minSirka;  // nastaví novou šířku buňky
    00385     if (!this.prvniHlavicka)
    00386     {  // pokud 1. sloupec netvoří hlavičku
    00387       this.sirkaPrvniho = minSirka;
    00388     }
    00389     if (!this.posledniJiny)
    00390     {  // pokud poslední sloupec není jiný
    00391       this.sirkaPosledniho = minSirka;
    00392     }
    00393     // přepočítá rozměry plátna
    00394     // (vnější rámeček má dvojnásobný okraj, kolem tabulky je okraj 5 px)
    00395     this.sirkaPlatna = (this.pocetSloupcu - 2) * (this.sirkaBunky + this.ohraniceni + this.okrajeBunky * 2)
    00396       + this.sirkaPrvniho + this.sirkaPosledniho + 2 * this.ohraniceni + this.okrajeBunky * 4
    00397       + 4 * this.ohraniceni + 10;
    00398     this.vyskaPlatna = this.pocetRadku * (this.vyskaBunky + this.ohraniceni + this.okrajeBunky * 2)
    00399       + 4 * this.ohraniceni + 10;
    00400     this.prekresliTabulku();  // překreslí tabulku
    00401   }  // public void minimalizaceSirky
    00402
    00403
    00404   /**
    00405    * Metoda pro změnu rozměrů tabulky
    00406    *
    00407    * @param novyPocetRadku
    00408    * @param novyPocetSloupcu
    00409    */
    00410   public void zmenRozmery (int novyPocetRadku, int novyPocetSloupcu)
    00411   {
    00412     String[][] noveBunky;  // pomocná pole
    00413     Color[][][] noveBarvyBunek;
    00414
    00415     if (novyPocetRadku > this.pocetRadku)
    00416     {  // pokud má být počet řádků větší, je nutné upravit pole
    00417       // inicializace nového pole obsahů buněk
    00418       noveBunky = new String[novyPocetRadku][this.pocetSloupcu];
    00419       // inicializace nového pole barev buněk
    00420       noveBarvyBunek = new Color[novyPocetRadku][this.pocetSloupcu][2];
    00421       // uložení obsahu a barev buněk do nového pole
    00422       for (int i = 0; i < this.pocetRadku; i++)
    00423       {  // procházení tabulky po řádcích
    00424         for (int j = 0; j < this.pocetSloupcu; j++)
    00425         {  // procházení tabulky po sloupcích
    00426           noveBunky[i][j] = this.bunky[i][j];  // nastaví obsah buňky
    00427           noveBarvyBunek[i][j][0] = this.barvyBunek[i][j][0];  // nastaví barvu písma
    00428           noveBarvyBunek[i][j][1] = this.barvyBunek[i][j][1];  // nastaví barvu pozadí
    00429         }
    00430       }
    00431       // nastaví výchozí stav nových buněk
    00432       for (int i = this.pocetRadku; i < novyPocetRadku; i++)
    00433       {  // procházení tabulky po řádcích
    00434         for (int j = 0; j < this.pocetSloupcu; j++)
    00435         {  // procházení tabulky po sloupcích
    00436           this.bunky[i][j] = "";  // nastaví obsah buňky
    00437           this.barvyBunek[i][j][0] = this.barvaPisma;  // nastaví barvu písma
    00438           this.barvyBunek[i][j][1] = this.barvaPozadi;  // nastaví barvu pozadí
    00439         }
    00440       }
    00441       this.pocetRadku = novyPocetRadku;  // aktualizije počet řádků
    00442       // záměna polí
    00443       this.bunky = noveBunky;
    00444       this.barvyBunek = noveBarvyBunek;
    00445     }  // pokud má být počet řádků větší, je nutné upravit pole
    00446     else if (novyPocetRadku < this.pocetRadku)
    00447     {  // pokud má být počet menší, stačí jej pouze nastavit
    00448       this.pocetRadku = novyPocetRadku;
    00449     }
    00450
    00451     if (novyPocetSloupcu > this.pocetSloupcu)
    00452     {  // pokud má být počet sloupců větší, je nutné upravit pole
    00453       // inicializace nového pole obsahů buněk
    00454       noveBunky = new String[this.pocetRadku][novyPocetSloupcu];
    00455       // inicializace nového pole barev buněk
    00456       noveBarvyBunek = new Color[this.pocetRadku][novyPocetSloupcu][2];
    00457       // uložení obsahu a barev buněk do nového pole
    00458       for (int i = 0; i < this.pocetRadku; i++)
    00459       {  // procházení tabulky po řádcích
    00460         for (int j = 0; j < this.pocetSloupcu; j++)
    00461         {  // procházení tabulky po sloupcích
    00462           noveBunky[i][j] = this.bunky[i][j];  // nastaví obsah buňky
    00463           noveBarvyBunek[i][j][0] = this.barvyBunek[i][j][0];  // nastaví barvu písma
    00464           noveBarvyBunek[i][j][1] = this.barvyBunek[i][j][1];  // nastaví barvu pozadí
    00465         }
    00466       }
    00467       // nastaví výchozí stav nových buněk
    00468       for (int i = 0; i < this.pocetRadku; i++)
    00469       {  // procházení tabulky po řádcích
    00470         for (int j = this.pocetSloupcu; j < novyPocetSloupcu; j++)
    00471         {  // procházení tabulky po sloupcích
    00472           noveBunky[i][j] = new String("");  // nastaví obsah buňky
    00473           noveBarvyBunek[i][j][0] = this.barvaPisma;  // nastaví barvu písma
    00474           noveBarvyBunek[i][j][1] = this.barvaPozadi;  // nastaví barvu pozadí
    00475         }
    00476       }
    00477       this.pocetSloupcu = novyPocetSloupcu;  // aktualizije počet řádků
    00478       // záměna polí
    00479       this.bunky = noveBunky;
    00480       this.barvyBunek = noveBarvyBunek;
    00481     }  // pokud má být počet sloupců větší, je nutné upravit pole
    00482     else if (novyPocetSloupcu < this.pocetSloupcu)
    00483     {  // pokud má být počet menší, stačí jej pouze nastavit
    00484       this.pocetSloupcu = novyPocetSloupcu;
    00485     }
    00486
    00487     // přepočítá rozměry plátna
    00488     // (vnější rámeček má dvojnásobný okraj, kolem tabulky je okraj 5 px)
    00489     this.sirkaPlatna = (this.pocetSloupcu - 2) * (this.sirkaBunky + this.ohraniceni + this.okrajeBunky * 2)
    00490       + this.sirkaPrvniho + this.sirkaPosledniho + 2 * this.ohraniceni + this.okrajeBunky * 4
    00491       + 4 * this.ohraniceni + 10;
    00492     this.vyskaPlatna = this.pocetRadku * (this.vyskaBunky + this.ohraniceni + this.okrajeBunky * 2)
    00493       + 4 * this.ohraniceni + 10;
    00494     this.prekresliTabulku();  // překreslí tabulku
    00495   }  // private void zmenRozmery()
    00496
    00497   /**
    00498    * Metoda pro posun obsahu buněk v řádku tabulky
    00499    * - pouze pro tabulky bez zvláštního prvního a posledního sloupce
    00500    * - zleva (zprava) přidá prázdná políčka, zprava (zleva) přebytečná políčka zahodí
    00501    * - neovlivňuje barvy buněk, posouvá pouze obsah
    00502    *
    00503    * @param radek Řádek tabulky
    00504    * @param smer Směr posuvu: POSUN_VLEVO - vlevo, POSUN_VPRAVO - vpravo
    00505    * @param pocet Počet posuvů
    00506    */
    00507   public void posunRadek(int radek, int smer, int pocet)
    00508   {
    00509     if (smer == this.POSUN_VLEVO)
    00510     {  // pokud se má posouvat vlevo
    00511       for (int i = 0; i < (this.pocetSloupcu - pocet); i++)
    00512       {  // posun
    00513           this.bunky[radek][i] = this.bunky[radek][i+pocet];
    00514       }
    00515       for (int i = (this.pocetSloupcu - pocet); i < this.pocetSloupcu; i++)
    00516       {  // doplnění prázdných buněk
    00517           this.bunky[radek][i] = "";
    00518       }
    00519     }
    00520     else
    00521     {  // pokud se má posouvat vpravo
    00522       for (int i = (this.pocetSloupcu - 1); (i - pocet) >= 0; i--)
    00523       {  // posun
    00524           this.bunky[radek][i] = this.bunky[radek][i-pocet];
    00525       }
    00526       for (int i = 0; i < pocet; i++)
    00527       {  // doplnění prázdných buněk
    00528           this.bunky[radek][i] = "";
    00529       }
    00530     }
    00531   }  // public void posunRadek()
    00532
    00533   /**
    00534    * Metoda pro překreslení tabulky
    00535    */
    00536   private void prekresliTabulku()
    00537   {
    00538     // nastavení rozměrů skrolované oblasti
    00539     this.setMinimumSize(new Dimension(this.sirkaPlatna,this.vyskaPlatna));
    00540     this.setPreferredSize(new Dimension(this.sirkaPlatna,this.vyskaPlatna));
    00541     this.setSize(this.sirkaPlatna,this.vyskaPlatna);
    00542     this.revalidate();  // vyhodnocení rozměrů
    00543     this.repaint();  // překreslení
    00544   }
    00545
    00546   /**
    00547    * Metoda pro vykreslení tabulky
    00548    *
    00549    * @param g Grafický objekt
    00550    */
    00551   public void paintComponent(Graphics g)
    00552   {
    00553     int zacatek;  // pomocná proměnná
    00554     if (this.prvniHlavicka)
    00555     {  // pokud je 1. sloupec hlavička
    00556       zacatek = 1;
    00557     }
    00558     else
    00559     {  // pokud 1. sloupec není hlavička
    00560       zacatek = 0;
    00561     }
    00562     int konec;  // pomocná proměnná
    00563     if (this.posledniJiny)
    00564     {  // pokud je poslední sloupec jiný
    00565       konec = this.pocetSloupcu - 1;
    00566     }
    00567     else
    00568     {  // pokud poslední sloupec není jiný
    00569       konec = this.pocetSloupcu;
    00570     }
    00571     super.paintComponent(g);
    00572     Graphics2D g2 = (Graphics2D)g;  // přetypování na vylepšenou grafiku
    00573     int invariant1 = 5 + 2 * this.ohraniceni - this.okrajeBunky;  // invariant cyklu
    00574     int invariant1P = 5 + 2 * this.ohraniceni - this.okrajeBunky
    00575       + zacatek * (this.sirkaPrvniho - this.sirkaBunky);  // invariant cyklu
    00576     // 2. invariant cyklu (šířka/výška okrajů v buňce)
    00577     int invariant2 = 2 * this.okrajeBunky;
    00578     // 3. invariant cyklu (šířka buňky bez okrajů včetně ohraničení)
    00579     int invariant3 = this.sirkaBunky + this.ohraniceni;
    00580     // 4. invariant cyklu (výška buňky bez okrajů včetně ohraničení)
    00581     int invariant4 = this.vyskaBunky + this.ohraniceni;
    00582     // 5. invariant cyklu (šířka buňky včetně okrajů a ohraničení)
    00583     int invariant5 = this.sirkaBunky + this.ohraniceni + invariant2;
    00584     // 6. invariant cyklu (výška buňky včetně okrajů a ohraničení)
    00585     int invariant6 = this.vyskaBunky + this.ohraniceni + invariant2;
    00586     for (int i = 0; i < this.pocetRadku; i++)
    00587     {  // vykreslení jednotlivých řádků tabulky
    00588       for (int j = zacatek; j < konec; j++)
    00589       {  // vykreslení jednotlivých buněk v řádku tabulky
    00590         // vykreslí pozadí buňky
    00591         g2.setColor(this.barvyBunek[i][j][1]);
    00592         g2.fillRect(invariant1P + this.okrajeBunky + j * invariant5,
    00593                     invariant1 + this.okrajeBunky + i * invariant6,
    00594                     this.sirkaBunky + invariant2,
    00595                     this.vyskaBunky + invariant2);
    00596         // vykreslí obsah buňky
    00597         g2.setColor(this.barvyBunek[i][j][0]);
    00598         g2.drawString(this.bunky[i][j],
    00599                       invariant1P + (j + 1) * invariant2 + j * invariant3,
    00600                       invariant1 + (i + 1) * invariant2 + i * invariant4 + this.vyskaBunky);
    00601       }
    00602     }  // vykreslení jednotlivých řádků tabulky
    00603     if (this.prvniHlavicka)
    00604     {  // pokud je 1. sloupec hlavička, vykreslí jej
    00605       for (int i = 0; i < this.pocetRadku; i++)
    00606       {
    00607         // vykreslí pozadí buňky
    00608         g2.setColor(this.barvyBunek[i][0][1]);
    00609         g2.fillRect(invariant1 + this.okrajeBunky,
    00610                     invariant1 + this.okrajeBunky + i * invariant6,
    00611                     this.sirkaPrvniho + invariant2,
    00612                     this.vyskaBunky + invariant2);
    00613         // vykreslí obsah buňky
    00614         g2.setColor(this.barvyBunek[i][0][0]);
    00615         g2.drawString(this.bunky[i][0],
    00616                       invariant1 + invariant2,
    00617                       invariant1 + (i + 1) * invariant2 + i * invariant4 + this.vyskaBunky);
    00618
    00619       }
    00620     }  // pokud je 1. sloupec hlavička, vykreslí jej
    00621     if (this.posledniJiny)
    00622     {  // pokud je poslední sloupec jiný, vykreslí jej
    00623       for (int i = 0; i < this.pocetRadku; i++)
    00624       {  // procházení řádků
    00625         // vykreslí pozadí buňky
    00626         g2.setColor(this.barvyBunek[i][konec][1]);
    00627         g2.fillRect(invariant1P + this.okrajeBunky + konec * invariant5,
    00628                     invariant1 + this.okrajeBunky + i * invariant6,
    00629                     this.sirkaPosledniho + invariant2,
    00630                     this.vyskaBunky + invariant2);
    00631         // vykreslí obsah buňky
    00632         g2.setColor(this.barvyBunek[i][konec][0]);
    00633         g2.drawString(this.bunky[i][konec],
    00634                       invariant1P + (konec + 1) * invariant2 + konec * invariant3,
    00635                       invariant1 + (i + 1) * invariant2 + i * invariant4 + this.vyskaBunky);
    00636       }  // procházení řádků
    00637     }  // pokud je poslední sloupec jiný, vykreslí jej
    00638
    00639     if (this.ohraniceni > 0)
    00640     {  // pokud má tabulka ohraničení
    00641       g2.setColor(new Color(0,0,0));  // ohraničení tabulky bude černé
    00642       g2.setStroke(new BasicStroke(this.ohraniceni * 2));  // dvojnásobná tloušťka čáry
    00643       // vykreslí ohraničení celé tabulky
    00644       g2.drawRect(5 + this.ohraniceni,
    00645                   5 + this.ohraniceni,
    00646                   this.sirkaPlatna - 10 - 2 * this.ohraniceni,
    00647                   this.vyskaPlatna - 10 - 2 * this.ohraniceni);
    00648       g2.setStroke(new BasicStroke(this.ohraniceni));  // nastaví tloušťku čáry
    00649
    00650       invariant1 = 5 + 2 * this.ohraniceni;  // invariant cyklu
    00651       invariant1P = 5 + 2 * this.ohraniceni + zacatek * (this.sirkaPrvniho - this.sirkaBunky);  // invariant cyklu
    00652       if (this.ohraniceni > 1)
    00653       {  // pokud je třeba posun na střed čáry
    00654         invariant1 -= this.ohraniceni / 2;
    00655         invariant1P -= this.ohraniceni / 2;
    00656       }
    00657       // 2. invariant cyklu (mezera mezi čarami)
    00658       invariant2 = 2 * this.okrajeBunky + this.vyskaBunky + this.ohraniceni;
    00659       // 3. invariant cyklu (x-ová souřadnice konce čáry)
    00660       invariant3 = this.sirkaPlatna - 5 - 2 * this.ohraniceni;
    00661       for (int i = 1; i < this.pocetRadku; i++)
    00662       {  // vykreslí čáry mezi řádky
    00663         g2.drawLine(invariant1,
    00664                     invariant1 + i * invariant2,
    00665                     invariant3,
    00666                     invariant1 + i * invariant2);
    00667       }
    00668       // 2. invariant cyklu (mezera mezi čarami)
    00669       invariant2 = 2 * this.okrajeBunky + this.sirkaBunky + this.ohraniceni;
    00670       // 3. invariant cyklu (y-ová souřadnice konce čáry)
    00671       invariant3 = this.vyskaPlatna - 5 - 2 * this.ohraniceni;
    00672       for (int i = 1 + zacatek; i < this.pocetSloupcu; i++)
    00673       {  // vykreslí čáry mezi sloupci
    00674         g2.drawLine(invariant1P + i * invariant2,
    00675                     invariant1,
    00676                     invariant1P + i * invariant2,
    00677                     invariant3);
    00678       }
    00679       if (this.prvniHlavicka)
    00680       {  // pokud je 1. sloupec hlavička, vykreslí jeho oddělení od zbytku tabulky
    00681         g2.drawLine(invariant1 + 1 * 2 * this.okrajeBunky + this.sirkaPrvniho + this.ohraniceni,
    00682                     invariant1,
    00683                     invariant1 + 1 * 2 * this.okrajeBunky + this.sirkaPrvniho + this.ohraniceni,
    00684                     invariant3);
    00685         g2.drawLine(invariant1 + 1 * 2 * this.okrajeBunky + this.sirkaPrvniho - this.ohraniceni,
    00686                     invariant1,
    00687                     invariant1 + 1 * 2 * this.okrajeBunky + this.sirkaPrvniho - this.ohraniceni,
    00688                     invariant3);
    00689       }
    00690     }  // pokud má tabulka ohraničení
    00691   }  // public void paintComponent()
    00692
    00693   /**
    00694    * Metoda pro zjištění aktuálního obsahu buňky
    00695    *
    00696    * @param radek Řádek, na kterém se buňka nachází
    00697    * @param sloupec Sloupec, na kterém se buňka nachází
    00698    * @return Vrací obsah požadované buňky
    00699    */
    00700   public String vratObsah(int radek, int sloupec)
    00701   {
    00702     return this.bunky[radek][sloupec];
    00703   }
    00704
    00705   /**
    00706    * Metoda pro zjištění aktuální barvy buňky
    00707    *
    00708    * @param radek Řádek, na kterém se buňka nachází
    00709    * @param sloupec Sloupec, na kterém se buňka nachází
    00710    * @param pismoPozadi 0 - barva písma v buňce
    00711    *                    1 - barva pozadí buňky
    00712    * @return Vrací požadovanou barvu
    00713    */
    00714   public Color vratBarvu(int radek, int sloupec,int pismoPozadi)
    00715   {
    00716     return this.barvyBunek[radek][sloupec][pismoPozadi];
    00717   }
    00718
    00719   /**
    00720    * Metoda pro zjištění počtu řádků tabulky
    00721    *
    00722    * @return Vrací počet řádků tabulky
    00723    */
    00724   public int vratPocetRadkuTabulky()
    00725   {
    00726     return this.pocetRadku;
    00727   }
    00728
    00729   /**
    00730    * Metoda pro zjištění počtu sloupců tabulky
    00731    *
    00732    * @return Vrací počet sloupců tabulky
    00733    */
    00734   public int vratPocetSloupcuTabulky()
    00735   {
    00736     return this.pocetSloupcu;
    00737   }
    00738
    00739   /**
    00740    * Metoda pro zjištění zobrazované oblasti ve skrolovacím panelu
    00741    *
    00742    * @return Vrací rozměry oblasti s tabulkou
    00743    */
    00744   public Dimension getPreferredScrollableViewportSize() {
    00745     return new Dimension(this.sirkaPlatna,this.vyskaPlatna);
    00746   }
    00747
    00748   /**
    00749    * Metoda pro nastavení jednotky skrolování
    00750    *
    00751    * @param visibleRect Viditelný obdélník
    00752    * @param orientation Orientace
    00753    * @param direction Směr
    00754    * @return Vrací jednotku skrolování
    00755    */
    00756   public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation,
    00757                                         int direction) {
    00758     return this.sirkaBunky + this.ohraniceni + 2 * this.okrajeBunky;
    00759   }
    00760
    00761   /**
    00762    * Metoda pro nastavení bloku skrolování
    00763    *
    00764    * @param visibleRect Viditelný obdélník
    00765    * @param orientation Orientace
    00766    * @param direction Směr
    00767    * @return Vrací jednotku skrolování
    00768    */
    00769   public int getScrollableBlockIncrement(Rectangle visibleRect,
    00770                                          int orientation, int direction) {
    00771     return 5 * (this.sirkaBunky + this.ohraniceni + 2 * this.okrajeBunky);
    00772   }
    00773
    00774   /**
    00775    * Metoda pro získání šířky pohledu skrolovací stopy
    00776    *
    00777    * @return Vrací šířku pohledu skrolovací stopy
    00778    */
    00779   public boolean getScrollableTracksViewportWidth() {
    00780     return false;
    00781   }
    00782
    00783   /**
    00784    * Metoda pro získání výšky pohledu skrolovací stopy
    00785    *
    00786    * @return Vrací výšku pohledu skrolovací stopy
    00787    */
    00788   public boolean getScrollableTracksViewportHeight() {
    00789     return false;
    00790   }
    00791 } // public class Tabulka
    00792
    00793 /*** Konec souboru Tabulka.java ***/