• 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 ***/

Generováno čt 3. bře 2011 13.55:32 pro projekt Aplet pro demonstraci Boyerova-Mooreova algoritmu - programem  doxygen 1.7.1