Tvorba grafického uživatelského rozhraní v jazyce Java

Transkript

1 MASARYKOVA UNIVERZITA FAKULTA INFORMATIKY P <?A Tvorba grafického uživatelského rozhraní v jazyce Java DIPLOMOVÁ PRÁCE Bc. Petr Kučera Brno, podzim 2005

2 Prohlášení Prohlašuji, že tato diplomová práce je mým původním autorským dílem, které jsem vypracoval samostatně. Všechny zdroje, prameny a literaturu, které jsem při vypracování používal nebo z nich čerpal, v práci řádně cituji s uvedením úplného odkazu na příslušný zdroj. Vedoucí práce: RNDr. Tomáš Pitner, Ph.D. 11

3 Poděkování Děkuji panu RNDr. Tomáši Pitnerovi, Ph.D. za cenné připomínky k mé práci. m

4 Shrnutí Tato práce představuje tutoriál ke tvorbě grafického uživatelského rozhraní při použití grafického prostředí SWT v jazyce Java.

5 Klíčová slova Java, Swing, Awt, SWT, GUI

6 Obsah 1 Úvod 5 2 Začínáme s SWT Co je to SWT? Principy této práce Založení nového projektu 3 Tvorba hlavního okna aplikace Display Shell Způsoby tvorby hlavního okna aplikace 12 4 Manažery pro rozmístění komponent a práce s panely FillLayout RowLayout GridLayout FormLayout Komponenty Composite a Group 27 5 Základní Komponenty SWT Label - práce s fonty a vkládání obrázků Button a práce s posluchači Combo List 48 6 Textové komponenty Text StyledText 56 7 Tvorba menu a tlačítkových lišt Menu - lišta a rozbalovací nabídky Menultem - položky menu a nastavování zkratek ToolBar a Toolltem CoolBar a Coolltem 72 8 Závěr 76 A Práce s dialogy v SWT 78 A.l MessageBox - programová hlášení 78 A.2 FileDialog a načítání souborů 81 A.3 ColorDialog 84 A.4 FontDialog 85 B Ostatní komponenty SWT 88 B.l TabFolder a Tabltem-tvorba záložek 88 B.2 SashForm 90 B.3 Tree, Treeltem a TreeColumn - tvorba stromů 91 B.4 Table, Tableltem a TableColumn - práce s tabulkami 96 B.5 Slider a Spinner - nastavování hodnot 99 B.6 ProgressBar - zobrazení průběhu operace 102 B.7 Browser - webový prohlížeč 104 1

7 C Prohlížeč ukázkových příkladů 106 2

8 Seznam obrázků 2.1 Přidání balíku swt.jar Ukázka hlavního okna programu FillLayout - horizontální typ FillLayout - vertikální typ RowLayout RowLayout - vertikální typ Speciální nastavení manažeru RowLayout Gridlayout - implicitní nastavení GridLayout - zarovnání a roztažení komponent 4.8 GridLayout - komplexní využití manažeru FormLayout - základní použití Použití komponenty Composite Label - základní použití komponenty Label - změna fontů Button - zpracování základních událostí Button - styl SWT.CHECK Button - styl SWT.RADIO Button - styl SWT.TOGGLE Button - styl SWT.ARROW Combo - změna vlastností návěští List - výběr z možností Text - použití různých stylů Text - implicitní popup menu StyledText - původní nastavení StyledText - nastavení různých stylů Menu - tvorba položek Menu - tvorba pop-up nabídky ToolBar - tlačítková lišta 70 7A ToolBar - použití tlačítek s popisky CoolBar - komplexní lišta pro komponenty CoolBar - zadávání hodnot 73 A.l MessageBox - zobrazení hlášení 79 A.2 MessageBox - zpracování odpovědi 80 A.3 FileDialog - otevření souboru 82 A.4 ColorDialog - změna barvy písma textu 85 A.5 FontDialog - nastavování fontů v textové oblasti B.l TabFolder - tvorba záložek 89 B.2 SashForm - změna velikosti panelů 91 B.3 Tree - organizace ukázkových příkladů 93 B.4 Tree - použití více sloupců 95

9 B.5 Table - zobrazování informací 98 B.6 Slider - nastavení hodnoty z rozsahu 200 B.7 Spinner - použití komponenty 202 B.8 ProgressBar - vizualizace průběhu operace 203 B.9 Ukázka webového prohlížeče 205 4

10 Kapitola 1 Úvod Programovací jazyk Java je stále více populární především z důvodu jednoduché přenositelnosti zdrojových kódů mezi dostupnými platformami. V posledních letech se tato skutečnost netýká jen přenositelnosti mezi různými operačními systémy, ale také podporou pro různá zařízení (například J2ME pro mobilní telefony). Vzhledem k tomu, že v dnešní době si snad už ani neumíme představit aplikace bez grafického uživatelského rozhraní (dále jen GUI), tak je zřejmé, že návrh a tvorba tohoto rozhraní tvoří naprosto nedílnou součást každé dnešní vyvíjené aplikace. K těmto účelům nám Java nabízí hned dvě grafická prostředí, kterým je dnes již silně nedostačující AWT a moderní, stále se vyvíjející prostředí s názvem Swing. Právě s příchodem JDK 5.0 doznalo toto prostředí četných (nejen) vizuálních změn a GUI vytvořená jeho komponentami mají implicitně nastavený nový vizuální styl (barvy, tvary komponent apod.). Přestože samozřejmě spíše záleží na vkusu uživatele, můj subjektivní dojem z těchto změn je velmi kladný. S vývojovým prostředím Eclipse od firmy IBM se nám do rukou dostává další možnost pro tvorbu GUI v jazyce Java. Touto "alternativou" je právě předmět této práce, balík SWT. Podobně jako je tomu u balíku Swing ve standardní Jávě, jedná se o stále se rozvíjející prostředí, které se svou každou novou verzí přináší několik vylepšení a změn. Práce s tímto prostředím zahrnuje spoustu specifických rysů oproti standardním prostředím v jazyce Java. A vzhledem k tomu, že na našem trhu neexistuje žádná dostupná literatura k tomuto zajímavému prostředí (v zahraničí je situace v podstatě stejná), vzniká tato práce s hlavním účelem poskytnout všem zájemcům základní informace pro práci s SWT. Z dostupných zdrojů na Internetu jsou použitelné snad jen ukázkové příklady (tzv. snippets), které se dají najít na domovských stránkách SWT. Co však citelně chybí je nějaký ucelený tutoriál k tomuto prostředí a právě tuto mezeru se snaží zaplnit tato práce. Vzhledem k tomu, že vysvětlování práce s jednotlivými komponentami je prováděno prostřednictvím ukázkových příkladů, je nedílnou součástí práce přiložený prohlížeč příkladů, který navíc slouží také jako prohlížeč samotné práce a také webových stránek. Jeho hlavním cílem je umožnit čtenáři jednoduchou orientaci v příkladech s možností jejich spouštění. U čtenářů předpokládám dobrou znalost programovacího jazyka Java. Samotná práce je určena jak pro zkušenější uživatele standardních grafických prostředí jazyka Java, tak pro začínající programátory bez dřívějších zkušeností s tvorbou GUI. Nicméně, znalost některého standardního prostředí může být v jistých situacích výhodou a orientace (nejen) v terminologii této práce bude pro čtenáře jednodušší. Dále jsou pro dřívější uživatele komponentního systému Delphi zahrnuty také srovnání s ekvivalentními komponentami, které jsou obsaženy v SWT. 5

11 Kapitola 2 Začínáme s SWT V této kapitole se nejprve seznámíme se samotným modulem SWT a stylem, kterým budou v následujících kapitolách vysvětlovány jednotlivé komponenty. Přestože se tato práce rozhodně nesnaží být tutoriálem k vývojovému prostředí Eclipse, podíváme se také na základní použití tohoto prostředí pro vytvoření jednoduché SWT aplikace, protože by to mohlo uživatelům, kteří se zatím s Eclipse nesetkali, působit zbytečné problémy. 2.1 Co je to SWT? Standard Widget Toolkit (dále jen SWT) pro vývojové prostředí Eclipse představuje jednu z možností pro tvorbu grafických uživatelských rozhraní (dále jen GUI). Programovací jazyk Java nám pro tyto účely nabízí dvě standardní grafická prostředí: AWT (obsažené v balíku java. awt), které se objevilo jako první z javovských prostředí a v současné době již není samo o sobě ve větší míře využíváno. Nicméně znalost postupů, které se při tvorbě v AWT používají nám podstatně usnadní orientaci při používání balíku Swing (a ostatně také při použití SWT). Swing (balík j avax. swing), který v podstatě představuje nástupce dnes již zastaralého AWT. Toto prostředí podstatně rozšiřuje možnosti komponent AWT (přičemž je možné k základní práci používat známé posluchače z AWT) a navíc přidává velkou porci speciálních komponent, které nebyly v AWT obsaženy (například JTable, JTree atd.). K těmto standardním prostředím nám tedy právě díky Eclipse přibývá další velmi zajímavá alternativa, zaměřená na tvorbu nativních GUI, které se plně "přizpůsobí" platformě, na které zdrojový kód spustíme. 2.2 Principy této práce Tato práce je tutoriálem k použití SWT při tvorbě GUI v jazyce Java. Přestože předpokládám, že se čtenář již dříve s některým standardním grafickým prostředím setkal, budeme si jednotlivé komponenty vysvětlovat tak, aby i začátečník byl schopen porozumět jejich funkcionalitě. Navíc, komponenty, které budeme používat v SWT budou srovnávány s jejich případnými ekvivalenty jak v jazyce Java (AWT, Swing), tak v jazyce Delphi. Tyto srovnání budou sloužit k tomu, aby si dřívější uživatelé zmíněných grafických prostředí mohli lépe představit podobné a případné rozdílné rysy. Samotný popis SWT tedy zahájíme tradičně několika postupy pro vytvoření hlavního okna aplikace a tyto postupy dále srovnáme s tvorbou při použití balíků AWT a 6

12 2.3. ZALOŽENÍ NOVÉHO PROJEKTU Swing. Následuje popis použití dostupných manažerů pro rozmístění komponent (layout managers), po kterém následuje hlavní část celé práce, kterou je popis komponent, dostupných v SWT. Jednotlivé komponenty tedy budou probírány následujícím způsobem: Stručný popis funkcionality a porovnání s případnými ekvivalentními komponentami v balících AWT, Swing a případně v jazyce Delphi. Seznam a popis nejpoužívanějších konstruktorů a metod. Formulace a výňatek z řešení ukázkového příkladu, jehož kompletní zdrojový kód se nachází v přiloženém balíku příkladů. Zhodnocení vlastností komponenty a případně také (ne)vhodnost jejího použití. Princip práce s danou komponentou tedy bude vysvětlen především prostřednictvím výňatku z ukázkového příkladu, který je vždy zvolen tak, aby co nejlépe vystihoval (i přes svou jednoduchost) použití probírané komponenty v praxi. 2.3 Založení nového projektu Před samotným popisem tvorby GUI prostřednictvím komponent, poskytovaných modulem SWT se nejprve seznámíme s prostředím, ve kterém budeme dále pracovat. Ukážeme si posloupnost kroků, které nám (i v případě, že nemáme s nástrojem Eclipse žádné zkušenosti) umožní, abychom byli schopní vytvářet vlastní SWT aplikace. Pro jistotu si připomeňme, že všechny postupy, které se týkají samotného prostředí Eclipse se mohou mírně lišit podle používané verze. Aby tedy nedošlo k nedorozumění, veškeré postupy, uvedené v této práci jsou popsány pro verzi 3.1 RC2. Nejprve si tedy ukážeme postup, jak založit nový projekt: 1. Z nabídky File vybereme položku New a v ní zvolíme položku Pro ject V zobrazené nabídce (jejíž rozsah se liší podle modulů, které máme v našem Eclipse nainstalované) vybereme položku Java Pro ject 3. V další nabídce zadáme název celého vytvářeného projektu a přestože bychom již mohli tvorbu nového projektu ukončit (kliknutím na tlačítko Finish), klikneme na tlačítko Next > 4. V zobrazené nabídce je pro naše účely zajímavá pouze záložka Libraries, která umožňuje nastavení knihoven a případně balíků jazyka Java (souborů *.jar), které bude náš projekt potřebovat pro kompilaci a následné spuštění. Implicitně v této záložce nalezneme například položku JRE System Library. Naším cílem je přidat balík, který nám umožní používat třídy pro tvorbu v grafickém prostředí SWT: (a) Zvolíme tlačítko Add External JARs... (b) Nyní musíme zadat cestu ke hledanému balíku. Typicky pro systém Windows nalezneme potřebný balík v adresářové struktuře: EclipseDir\plugins\org.eclipse.swt.win32_3.1.0\ws\win32\swt.jar 5. Pokud se v záložce Libraries objevil hledaný balík swt.jar, tak jak ukazuje obrázek 2.1, zakládání nového projektu je hotovo. 7

13 2.3. ZALOŽENI NOVÉHO PROJEKTU Source \3 Projects S Libraries \ order and Export JARs and class Folders on the build path: El- l swt.jar - D:\Java\Eclipse_3. l.g\plugins\org.eclipse.swt.win32 0-ÖÜ JRE System Library [jre 1.5.0] Add External JARs.,. Add Variable. Add Library, Add Class Folder. Edit,, Remove il Obrázek 2.1: Přidání balíku swt.jar V založeném projektu si dále vytvoříme balík (standardně s názvem src) a do něj umístíme novou třídu. Nyní jsme již tedy konečně připraveni začít programovat GUI s použitím modulu SWT. Pro lepší představu, jak takový zdrojový kód GUI vypadá, si ukážeme následující příklad velmi jednoduchého okna s jedním návěštím (bez ohledu na skutečnost, že zatím neznáme v příkladu použité komponenty): package src; import org.eclipse.swt.swt; import org.eclipse.swt.widgets.*; public class FirstSWT { public static void main(string[] args) { Display display = new Display(); Shell shell = new Shell(display); shell.settext("first SWT"); Label label = new Label(shell, SWT.NONE); label.settext("first SWT application"); shell.pack(); label.pack(); shell.open (); while(!shell.isdisposed()) if (!display.readanddispatch display.sleep(); ) { 8

14 2.3. ZALOŽENÍ NOVÉHO PROJEKTU display.dispose (); label.dispose (); Proč jsme si vlastně ukázali zdrojový kód, ve kterém se vyskytují dosud neznámé komponenty? Hlavním důvodem je skutečnost, že pokud se náš příklad nyní pokusíme spustit, obdržíme následující výjimku: java.lang.unsatisfiedlinkerror: no swt-win in java.library.path Napsaný kód je tedy možné zkompilovat, ale pro jeho spuštění potřebujeme provést ještě několik akcí. Naším cílem je spouštěnému programu zprostředkovat potřebné runtime elementy (pro systém Windows v knihovně swt-win32-31xx.dll). Na rozdíl od samotného kódu jsou tyto soubory závislé na použité platformě (a tudíž se cesta, kterou si dále ukážeme bude na jiné platformě mírně lišit). Zprostředkování potřebné knihovny je možné hned několika způsoby: 1. První možností je nastavení parametru -D (používaného pro nastavení tzv. system property) při spouštění samotné Virtual Machine. Nejjednodušším způsobem je možné tento parametr nastavit v položce Run..., kde v záložce Arguments zadáme do pole VM arguments následující nastavení: -Djava.librarypath= EclipseDir\plugins\org.eclipse.swt.win32_3.1.0\os\win32\x86\ 2. Další možností (pod systémem Windows) je nakopírovat knihovnu swt-win dll přímo do složky Windows\System32. Tuto možnost bych doporučil obzvláště v případě, kdy budeme často spouštět větší množství SWT aplikací (což při studiu SWT nebude nic zvláštního) a nebudeme tedy nuceni nastavovat cestu pro každý program zvlášť. 3. Poslední možností, kterou si zde uvedeme je zkopírovat knihovnu swt-win dll přímo do kořenového adresáře založeného projektu. Přičemž je opět nutné (pod jiným systémem než Windows) nastavit parametr java.librarypath. S použitím libovolného z výše uvedených způsobů se nám tedy konečně podaří ukázkový příklad spustit a obrázek 2.2 nám ukazuje výsledek našeho snažení: First Swt application Obrázek 2.2: Ukázka hlavního okna programu Nyní, když už víme jak založit, zkompilovat a spustit kód aplikace, která je napsána v SWT, nám již nic nebrání začít se učit, jak s využitím tohoto modulu psát vlastní grafická uživatelská rozhraní. V následující kapitole si tedy vysvětlíme, jak vytvořit základní stavební kámen celého GUI, kterým je právě hlavní okno celé aplikace. 9

15 Kapitola 3 Tvorba hlavního okna aplikace V této kapitole se zaměříme na nezbytný základ celého GUI, kterým je vytváření hlavního okna aplikace. Pro dřívější uživatele AWT i balíku Swing si upozorníme na nejdůležitější rozdíly. Oproti těmto grafickým prostředím je v SWT rozdíl patrný již na první pohled, neboť místo vytvoření instance jedné třídy (Frame v AWT, popřípadě JFr ame v balíku Swing) zde potřebujeme instance hned dvě. První třídou, jejíž instanci potřebujeme vytvořit je Display a druhou třídou, která představuje samotné okno je Shell. 3.1 Display Tato třída v podstatě představuje "prostředníka" mezi SWT a konkrétním operačním systémem, na kterém naši aplikaci spouštíme. V podstatě pro libovolně velké GUI (tvořené i několika okny) budeme vždy potřebovat pouze jedinou instanci této třídy. Za jednu z nejdůležitějších funkcí této třídy lze považovat to, že se sama stará o převod událostí, které používáme v naší SWT aplikaci, na události srozumitelné konkrétnímu operačnímu systému. Dále si zde můžeme zmínit, že se tato třída používá k přístupu k informacím o naší platformě a dále automaticky spravuje zdroje, které jsou naší aplikací alokovány. Pro naše základní účely si vystačíme s jediným konstruktorem: Display () -vytváří instanci třídy Display. Z dostupných metod této třídy si zmíníme alespoň ty nejdůležitější: dispose () - zcela nezbytná metoda, která slouží k uvolnění zdrojů operačního systému, které jsou drženy naší instancí třídy Display. V případě, pokud bychom na tuto metodu ve zdrojovém kódu zapomněli, na většině podporovaných platforem (včetně OS Windows) se naše GUI vůbec nezobrazí. Právě z těchto důvodů musí být každá vytvořená instance třídy Display "uzavřena" právě touto metodou. Widget findwidget (int handle) -vrací specifikovanou komponentu z aktuálně běžící aplikace. V případě, že tato komponenta neexistuje, vrací null. Display getcurrento -vrací běžící instanci třídy Display. Shell [] getshellso - vrací běžící instance třídy Shell, které obsahuje aktuální třída Display. Color getsystemcolor (int id) - vrací odpovídající barvu (pro konkrétní platformu), specifikovanou zadanou konstantou, obsaženou v SWT (například SWT.COLOR_RED). 10

16 3.2. SHELL Cursor getsystemcursor (int id) - užitečná metoda pro nalezení systémového kurzoru, který odpovídá specifikované konstantě z SWT. boolean readanddispatch () - pro základní účely zcela nezbytná metoda. Jejím účelem je kontrolovat události z fronty událostí konkrétního operačního systému a vrací true, pokud jsou otevřené nějaké aktivní okna (instance třídy Shell). V opačném případě vrací false. Tuto metodu budeme využívat pro kontrolu, zda uživatel kliknul na tlačítko k zavření hlavního okna aplikace. Přestože jsme si zde ukázali pouze několik dostupných metod, je z nich na první pohled patrný charakter této třídy, tj. stát mezi operačním systémem a naší SWT aplikací. Ukázka použití instance této třídy v praxi by neměla větší smysl bez skutečného (viditelného) okna, představovaného třídou Shell. Použití obou tříd si ukážeme v závěru této kapitoly, kde jejich možnosti budeme prezentovat na několika způsobech vytvoření hlavního okna programu. 3.2 Shell Tato třída v podstatě představuje hlavní okno našeho GUI a její účel je tedy velmi podobný jako u tříd Frame v AWT, případně JFrame ve Swingu. Z hlediska funkcionality nám tedy poskytuje základní stavební kámen, na který následně umísťujeme další potřebné komponenty (prakticky se jedná o instance tříd z balíku org.eclipse.swt.widgets). Konstruktorů nabízí tato třída hned několik: Shell () - vytvoří novou instanci třídy Shell. Shell (Display display) - umožňuje zadání instance třídy Display, kterou bude tato instance využívat. Shell (Display display, int style) - oproti předchozímu konstruktorů umožňuje navíc specifikovat potřebný SWT styl (pro základní specifikaci chování komponenty a jejího vzhledu). Z dostupných konstant si uveďme alespoň SWT. BORDER, SWT. CLOSE, SWT. MIN pro minimalizaci okna, SWT. MAX pro maximalizaci okna. Shell (int style) - umožňuje pouze zadání stylu. Shell (Shell parent) - podobně jako můžeme specifikovat Display, pro který naši instanci vytváříme, tak nám tento konstruktor umožňuje zadat jinou (rodičovskou) instanci třídy Shell. Shell (Shell parent, int style) - tento poslední konstruktor umožňuje oproti předchozímu navíc zadat požadovaný styl. Nyní si uveďme několik metod této třídy: Shell [ ] get Shells () - vrací pole, obsahující všechny potomky našeho okna. boolean isvisible () - vrací true, je-li okno viditelné. V opačném případě vrací false. 11

17 3.3. ZPŮSOBY TVORBY HLAVNÍHO OKNA APLIKACE open () - zcela nezbytná metoda. Provádí zobrazení okna tím, že jej dostane do popředí pod danou instancí třídy Display. Dále provede několik důležitých akcí, mezi kterými jsou například nastavení viditelnosti na hodnotu true okna a přidělení fokusu. setminimumsize (Point size) - umožňuje specifikovat minimální velikost okna. setvisible (boolean visible) - umožňuje zobrazit okno (true), nebo jej skrýt (false). Nyní jsme již dospěli do stádia, kdy si můžeme ukázat několik možných způsobů, kterými docílíme zobrazení hlavního okna aplikace. 3.3 Způsoby tvorby hlavního okna aplikace Podobně jako v obou standardních grafických prostředích v jazyce Java, máme i v SWT několik implementačních možností pro zobrazení hlavního okna. Abychom mohli lépe analyzovat přítomné rozdíly, nejprve si ukážeme nejpoužívanější způsob tvorby z balíku Swing: import javax.swing.*; public class MainWindow extends JFrame { public MainWindow() { // zde si nastavíme název okna this.settitle("main Window"); public static void main(string[] args){ // zde vytvoříme instanci naší třídy MainWindow frame = new MainWindow(); // zde nastavíme velikost okna podle // velikosti komponent na něm umístěných frame.pack(); // zobrazení okna frame.setvisible(true) ; // nastavení operace pro zavření okna frame.setdefaultcloseoperation(exit_on_close); Jak vidíme ve zdrojovém kódu, v metodě main () si vytváříme instanci "sebe sama", provedeme nastavení velikosti podle umístěných komponent. Dále provedeme samotné zobrazení okna a nastavíme akci, která zabezpečí jeho uzavření. Analogická situace je v AWT, kde však (kromě toho, že musíme pochopitelně použít třídu Frame) navíc musíme implementovat posluchač pro uzavření okna, protože elegantní metoda setdef aultcloseoperation (int operation) zde není k dispozici. Samotný princip však zůstává v podstatě stejný. 12

18 3.3. ZPŮSOBY TVORBY HLAVNÍHO OKNA APLIKACE Jak tedy vytvoříme hlavní okno v prostředí SWT? Abychom si prezentovali zobrazené okna (které budou vypadat tak, jak je známe z běžného života), budeme potřebovat na ně umístit nějakou jednoduchou komponentu. Pokud bychom do vytvořených oken nic neumístili, zobrazovali by se nám pouze horní lišty oken, což není pro naši prezentaci úplně nejvhodnější. Pro naše účely tedy výborně poslouží jednoduché návěští, jehož instanci si vytvoříme například konstruktorem Label (Composite parent, int style). Kompletní popis návěští (hlavně možnosti nastavení konstruktoru pomocí dostupných stylů) si ukážeme až v kapitole, zaměřené na používání jednotlivých základních komponent SWT. Nyní si tedy ukážeme několik způsobů vytvoření hlavního aplikačního okna: 1. První možností je případ, který jsme si již uvedli dříve. Tento způsob, kdy se veškerá tvorba instancí komponent provádí v metodě main (), je sice poměrně rozšířený (zvláště v dostupných zdrojových kódech, ve kterých je použito SWT), ale určitě mi dáte za pravdu, že nepatří mezi příliš přehledné. Postup ukazuje zdrojový kód: // nejprve importování potřebných tříd import org.eclipse.swt.swt; import org.eclipse.swt.widgets.*; public class FirstSWT { public static void main(string[] args) { // vytvoříme instanci třídy Display Display display = new Display (); // zde vytvoříme instanci okna pro daný display Shell shell = new Shell (display); // zde nastavíme titulek okna shell.settext("first SWT"); // vytvoříme si návěští a nastavíme jeho text Label label = new Label (shell, SWT.NONE); label.settext("first SWT application"); // provedeme nastavení velikostí okna shell.pack(); label.pack(); // zde provedeme otevření našeho okna shell.open(); // cyklus kontroly, zda nebylo okno zavřeno while(!shell.isdisposed()) if(!display.readanddispatch()){ // pokud bylo zavřeno okno, "uspíme" display display.sleep(); 13

19 3.3. ZPŮSOBY TVORBY HLAVNÍHO OKNA APLIKACE // nakonec uvolníme držené zdroje display.dispose(); Tento postup nebudeme v našich ukázkových příkladech využívat a raději se přikloníme ke druhému způsobu, který je známý ze zdrojových kódu, napsaných v grafickém prostředí Swing. 2. Druhou možností je způsob, který nám připomene nejčastěji využívaný postup v balíku Swing. Jedná se o standardní vytvoření instance naší třídy v metodě main (), přičemž tvorba jednotlivých komponent, obsažených v našem GUI se provádí v konstruktoru. Postup ukazuje zdrojový kód: import import org.eclipse.swt.swt; org.eclipse.swt.widgets.*; public class FirstSWT_2 { // tvorbu GUI provedeme v konstruktoru public FirstSWT_2() { Display display = new Display (); Shell shell = new Shell(display); shell.settext("first SWT"); Label label = new Label (shell, SWT.NONE); label.settext("first SWT application 2"); label.pack(); shell.pack(); shell.open(); while(!shell.isdisposed()) if(!display.readanddispatch()){ display.sleep(); display.dispose(); public static void main(string[] args) { // zde si vytvoříme instanci naší třídy FirstSWT_2 frame = new FirstSWT_2(); Vise zmíněný postup budeme využívat pro naše ukázkové příklady, na kterých si budeme prezentovat práci s jednotlivými komponentami SWT. 14

20 3.3. ZPŮSOBY TVORBY HLAVNÍHO OKNA APLIKACE Všimněme si, že především oproti Swingu nemáme v SWT možnost použít nějakou metodu, která by se sama postarala o uzavření okna a uvolnění držených systémových prostředků. Kromě komponenty Display se dále seznámíme také s dalšími, jejichž prostředky jsme nuceni uvolňovat explicitně (zejména se jedná o fonty, obrázky a barvy). Za povšimnutí již v tomto okamžiku také stojí tvar konstruktorů a možnosti specifikace stylů. V podstatě konstruktor každé z vizuálních komponent SWT vyžaduje specifikovat rodičovskou komponentu (typicky instance třídy Shell, případně instance některého panelu) a také použitý styl. Dostupné styly se samozřejmě liší podle dané komponenty a budeme se na ně zaměřovat v popisech konstruktorů u jednotlivých komponent. Právě díky přítomnosti stylů obsahuje SWT "opticky" mnohem méně komponent, než je tomu v balíku Swing. Pro lepší představu si uveďme komponentu Button, která při nastavení odpovídajícího stylu získá vzhled a chování například dvoustavového přepínače, které v balíku Swing představuje samostatnou komponentu. Smyslem stylů v SWT tedy není jen vizuální modifikace komponenty (přestože samozřejmě i takové zde najdeme), ale také jejího celkového chování. V další kapitole nás čeká prohlídka manažerů pro rozmísťování komponent, neboť pochopení principů práce s nimi bude pro nás naprostým základem v dalších kapitolách, zaměřených na jednotlivé komponenty SWT. 15

21 Kapitola 4 Manažery pro rozmístění komponent a práce s panely V předchozích kapitolách jsme si ukazovali naprosté základy při tvorbě GUI, kterými byli především způsoby tvorby hlavního okna naší aplikace. Nyní se pomalu dostáváme do situace, kdy budeme do našeho okna umísťovat komponenty. Právě manažery rozmístění komponent jsou zodpovědné za to, kde se komponenta, kterou do okna přidáme, zobrazí (a také například jaká bude její velikost atd.). Naším cílem bude vždy vytvářet uživatelsky příjemná GUI a právě výběr správných manažerů je v této problematice zcela klíčový. Programátoři, kteří dříve využívali ke tvorbě GUI balíky AWT či Swing se již zajisté s podobnými postupy setkali u manažerů, obsažených ve standardní Jávě. Právě z tohoto důvodu se v následujících popisech zaměříme na hledání případných podobných rysů jednotlivých manažerů. V SWT se k použití nabízí následující manažery, jejichž použití, výhody a nevýhody si hned vzápětí ukážeme: FillLayout RowLayout GridLayout FormLayout Pro začátek si uvedeme, že všechny manažery se nachází v balíku: org.eclipse.swt.layout a k nastavení jednotlivých manažerů k použití budeme využívat metodu: setlayout(layout layout) Tato metoda pro naši instanci třídy Shell nastaví zadaný manažer. Ideální komponentou pro prezentaci jednotlivých manažerů bude pro nás standardní tlačítko. Přestože se touto komponentou budeme zabývat až v následující kapitole (kde si s její pomocí zároveň také vysvětlíme princip posluchačů v SWT), zatím si vystačíme s tím, že tlačítko v SWT je instancí třídy Button, kterou vytvoříme konstruktorem Button (Composite parent, int style), tj. v našem případě se pro zjednodušení bude vždy jednat o Button (shell, SWT. NONE). Jak postupně v jednotlivých sekcích uvidíme, každý manažer je (svým způsobem) rozšířením předchozího, jednoduššího manažeru. Nyní si tedy jednotlivé manažery důkladně rozebereme. 16

22 4.1 FillLayout 4.1. FILLLAYOUT Tento manažer představuje nástroj, který zabezpečí vyplnění celého dostupného prostoru (jak již napovídá anglický název fill). V praxi pracuje tak, že přidáme-li do okna jednu komponentu, pak bude mít tato komponenta maximální možnou velikost. V případě, že přidáme další komponentu, je dostupný prostor rozdělen a na každou komponentu připadá tedy přesně 50% (podobně např. 33% pro tři komponenty,...). Je důležité si uvědomit, že tento manažer nezachovává velikosti komponent (jako tomu je například u manažeru FlowLayout v balíku Swing), ale zabezpečí přizpůsobení velikosti největší komponentě. V základním režimu (implicitní nastavení je SWT. HORIZONTAL pro řazení přidávaných komponent horizontálně do jednoho řádku) si jeho funkci můžeme představit tak, že funguje stejně, jako manažer GridLayout v balíku Swing, pokud bychom použili jeho nastavení pro umísťování pouze do jednoho řádku. Podobně při použití typu SWT.VERTICAL (pro řazení vertikálně do jednoho sloupce) je výsledek činnosti manažeru FillLayout shodný s manažerem GridLayout s nastavením jediného sloupce. K vytvoření instance se nabízí následující konstruktory: Fi 1 llayout () - vytvoří novou instanci, která má implicitně nastaveno umísťování do řádku (typ SWT. HORIZONTAL). FillLayout (int type) -umožňuje navíc specifikovat požadovaný typ. V podstatě se hodí jen v případě, kdy máme v plánu použít typ SWT. VERT ICAL, který není implicitní. Nyní si tedy ukážeme příklad, který nám výše uvedený princip ukáže v praxi: // provedeme nastavení manažeru shell.setlayout(new FillLayout ( )); // dále již jen jednoduše přidáváme tlačítka Button buttonl = new Button(shell, SWT.NONE); buttonl.settext("tlačítko 1") ; Button button2 = new Button(shell, SWT.NONE); button2.settext("velké Tlačítko 2"); Button button3 = new Button(shell, button3.settext("tlačítko 3"); Button button4 = new Button(shell, button4.settext("4"); SWT.NONE); SWT.NONE); Jak je patrné z výše uvedeného kódu, použití tohoto manažeru je vskutku velmi jednoduché. Je vhodné si uvědomit, že pořadí zadávání jednotlivých komponent zároveň určuje, v jaké posloupnosti se tyto komponenty v okně objeví (což samozřejmě není 17

23 4.1. FILLLAYOUT FillLayoutDemo Tlačítko 1 Velké Tlačítko 2 Tlačítko 3-101*1 4 Obrázek 4.1: FillLayout - horizontální typ nikterak překvapivé, neboťjednotlivé komponenty jsou přidávány do řádku. Výsledek ukazuje obrázek 4.1. Podobně si můžeme jednoduše vyzkoušet vertikální typ tohoto manažeru: 1. Nastavením vertikálního směru jako parametru přímo v konstruktoru: // nejjednodušší možností je nastavení // přímo prostřednictvím konstruktoru shell.setlayout(new FillLayout(SWT.VERTICAL)); 2. Postupem, který ukazuje následující zdrojový kód: // vytvoření instance manažeru FillLayout fill = new FillLayout(); // nastavení vertikální orientace filllayout.type = SWT.VERTICAL; // nastavení manažeru pro naši instanci shell.setlayout(filllayout); Je zřejmé, že tento způsob nemá v podstatě žádný smysl používat, pokud s instancí manažeru nebudeme provádět žádné další operace a tudíž jsme si jej uvedli jen z důvodu, že u dalších manažerů budeme podobný postup využívat pro nastavování jejich speciálních parametrů. r FillLayoutVerDemo f _ n x Tlačítko 1 i Velké Tlačítko 2 Tlačítko 3 ; 4 Obrázek 4.2: FillLayout - vertikální typ V obou výše zmíněných případech docílíme výsledku, který ukazuje obrázek 4.2. Přestože se jedná o jednoduchý manažer, který nám neumožňuje provádět žádná speciální nastavení, jistě jej budeme občas při tvorbě GUI využívat. Dále se již podíváme na mnohem komplexnější (a zároveň také komplikovanější) manažery, které SWT nabízí. 18

24 4.2. ROWLAYOUT 4.2 RowLayout Tento manažer představuje (ve svém implicitním nastavení) v podstatě obdobu manažeru FlowLayout z balíku Swing. V praxi tedy pracuje tak, že umísťuje komponenty v původní velikosti do řádku. Nesnaží se tedy nutně vyplnit celý dostupný prostor, jak to provádí manažer FillLayout. Na rozdíl od výše zmíněného manažeru FlowLayout však v případě, kdy je řádek zaplněn (respektive další komponenta by přesáhla šířku zobrazeného okna), založí řádek nový, do kterého začne umísťovat další komponenty. Na rozdíl od manažeru FillLayout umožňuje navíc nastavit některé zajímavé parametry, které způsobí značně variabilní chování při rozmísťování komponent, což si v závěru této kapitoly ukážeme. Ke vzniku instance se používají následující konstruktory: RowLayout () -vytvoří novou instanci manažeru RowLayout. RowLayout (int type) - umožňuje navíc specifikovat typ (implicitní je horizontální, SWT.VERTICAL pro vertikální). Jeho základní použití je v podstatě shodné s manažerem FillLayout, což ukazuje zdrojový kód: // vytvoření instance a nastavení manažeru shell.setlayout(new RowLayout()); // přidávání jednotlivých tlačítek Button buttonl = new Button(shell, SWT.NONE); buttonl.settext("tlačítko 1") ; Při stejných tlačítkách, které jsme použili u předchozího manažeru dostáváme výsledek, který ukazuje obrázek 4.3: Obrázek 4.3: RowLayout Pokud bychom okno, které ukazuje obrázek ručně zmenšili, dojde k založení nového řádku, kam budou přesunuty přebývající tlačítka. V krajním případě tedy může nastat situace, kdy budou tlačítka umístěna ve sloupci pod sebou. Nicméně, navzdory svému názvu i tento manažer umožňuje umísťovat komponenty do sloupců, čehož je možné docílit podobně jako u manažeru FillLayout v konstruktoru, tj. uvedeme RowLayout (SWT.VERTICAL). Ale je nutné si uvědomit, že díky tomu, že manažer RowLayout zachovává velikosti, vznikne nám (obzvláště v našem případě) nevzhledný sloupec různě velkých tlačítek, jak ukazuje obrázek 4.4. Výše zmíněné založení nového řádku je možné také v případě potřeby deaktivovat a zamezit tím nechtěnému přeuspořádání komponent, ovšem za cenu, kdy při zmenšení 19

25 4.3. GRIDLAYOUT Obrázek 4.4: RowLayout - vertikální typ okna nebudou některé komponenty, v něm obsažené, viditelné. Deaktivaci provedeme následujícím způsobem: // vytvoření instance manažeru RowLayout rowl = new RowLayout(); // deaktivace zakládání nových řádků rowl.wrap = false; // nastavení manažeru pro daný shell shell.setlayout(rowl); Podobně jako zakládání nových řádků při minimalizaci můžeme také deaktivovat implicitně zapnuté zachovávání velikostí, čímž v podstatě docílíme podobných výsledků jako s použitím manažeru FillLayout. Podobně jako u výše uvedeného kódu provedeme vypnutí: // deaktivace různých velikostí rowl.pack = false; Z výše uvedených nastavení je vidět, že komplexnější layout manažery v SWT jsou značně variabilní a změnou parametrů dosáhneme podstatných změn ve výsledku, což ukazuje následující obrázkek 4.5. Levý nám ukazuje vypnutí "zalamování" komponent a pravý v podstatě simuluje práci manažeru FillLayout: Obrázek 4.5: Speciální nastavení manažeru RowLayout 4.3 GridLayout Tato třída představuje již vskutku komplexní manažer, jehož činnost je (zvláště když modifikujeme implicitní nastavení) velmi podobná stejnojmennému manažeru z balíku 20

26 4.3. GRIDLAYOUT Swing, avšak s tím rozdílem, že při jeho specifikaci zadáváme pouze počet sloupců (a tedy nikoliv počet řádků i sloupců, jak je tomu v balíku Swing). Při dalších modifikacích dokonce dosáhneme v podstatě stejných funkcí, které nám umožňuje vůbec nejkomplexnější manažer balíku Swing s názvem Gr idbaglayout. Umísťované komponenty jsou přidávány po řádcích do jednotlivých sloupců a velikost sloupce je přizpůsobena největší komponentě (v našem případě tlačítku s nejdelším textem). Podobně jako u manažeru RowLayout je v implicitním nastavením založen nový řádek dle potřeby a není tedy nutné předem specifikovat, kolik řádků budeme vyžadovat. Jeho chování v jednotlivých sloupcích je opět totožné s manažerem RowLayout v tom smyslu, že například v případě třech sloupců nepřipadá pro každý z nich 33% z dostupného místa, ale právě tolik místa, které je určeno největší komponentou, která je ve sloupci obsažena. Tato skutečnost představuje poměrně závažný rozdíl oproti manažeru GridLayout z balíku Swing, protože při jeho použití byly všechny sloupce stejně široké. Z hlediska použití se jedná o velmi užitečný manažer, jehož vlastnosti oceníme tam, kde potřebujeme systém řádků a sloupců o stejné velikosti (například systém pro zadávání parametrů, kde je obsaženo několik textových polí a jim odpovídajících tlačítek apod.). Navíc dále umožňuje řadu speciálních nastavení, které si v závěru kapitoly ukážeme. Právě tato nastavení jej dělají mnohem více variabilní, než je jeho (názvový) ekvivalent v balíku Swing. K vytvoření instance je možné využít následující konstruktory: GridLayout () - vytvoří instanci manažeru. GridLayout (int numcolumns, boolean columns)-navíc nám umožňuje specifikovat počet sloupců a také nastavení identické šířky všech sloupců podle celkově největší komponenty (zadáním hodnoty true). Základní použití je opět velmi jednoduché a samozřejmě si jej ukážeme na příkladě se stejnými tlačítky, jako tomu bylo u předchozích manažerů. Především nesmíme zapomenout specifikovat počet sloupců, neboťv implicitním nastavení bychom docílili stejného chování, jako u manažeru RowLayout: // nejprve si vytvoříme instanci manažeru GridLayout gridl = new GridLayout(); // nezbytné je specifikovat počet sloupců gridl.numcolumns = 2; // nakonec nastavíme manažer pro naši instanci třídy Shell shell.setlayout(gridl); // standardním způsobem přidáváme tlačítka Button buttonl = new Button(shell, SWT.NONE); buttonl.settext("tlačítko 1") ; Obrázek 4.6 ukazuje výsledek našeho zdrojového kódu a je na něm na první pohled vidět rozdíl oproti použití stejnojmenného manažeru z balíku Swing: Nyní si dále ukážeme speciální nastavení tohoto manažeru. K přístupu k těmto nastavením budeme potřebovat instanci třídy GridData (což nám mírně připomene 21

27 4.3. GRIDLAYOUT GridLayoutD. 1*1 Tlačítko 1 I Velké Tlačítko 2 Tlačítko 3 JJ Obrázek 4.6: Gridlayout - implicitní nastavení nastavování parametrů manažeru GridBagLayout v balíku Swing), kterou vytvoříme konstruktorem GridDataO, případně při nastavování roztažení komponent GridData (int style). Pomocí této třídy můžeme pro náš manažer nastavit následující užitečné vlastnosti: Horizontální zarovnání komponenty v buňce - důležité v případě, pokud je komponenta menší a potřebujeme změnit její umístění vzhledem ke sloupci. Samotné nastavení provedeme specifikací vlastnosti horizontalalignment a možné hodnoty jsou SWT. BEGINNING (zarovnání vlevo, které je nastaveno implicitně), SWT. CENTER (zarovnání na střed) a SWT. END (zarovnání vpravo). Například tedy zarovnáme malé tlačítko na střed sloupce: // nejprve vytvoříme instanci třídy GridData GridData gd = new GridDataO; // nastavíme si zarovnání na střed gd.horizontalalignment = GridData.CENTER; // a nakonec toto nastavení použijeme pro naše // nejmenší tlačítko button4.setlayoutdata(gd); Roztažení komponenty v buňce - umožňuje přizpůsobit menší komponenty největší velikosti ve sloupci. Nastavení se provádí rovnou v konstruktoru a možné hodnoty jsou GridData.FILL_H0RIZ0NTAL (horizontální roztažení pro dosažení maximální šířky sloupce), GridData. FILL_VERTICAL (pro dosažení maximální výšky řádku) a GridData. BOTH (roztažení v obou směrech). Tato nastavení budeme dále také využívat při roztahování komponent přes několik řádků (sloupců). Je zřejmé, že pokud použijeme roztažení, nemá smysl nastavovat horizontální zarovnání. Například tedy opět modifikujeme naše nejmenší tlačítko: // vytvoříme instanci a provedeme nastavení GridData gd = new GridData(GridData.FILL_HORIZONTAL); // použijeme toto nastavení pro tlačítko button4.setlayoutdata(gd) ; 22

28 4.3. GRIDLAYOUT Obrázek 4.7: GridLayout - zarovnání a roztažení komponent Pro lepší představu nám obě výše provedené úpravy ukazuje obrázek 4.7. Další ze zajímavých a často používaných možností je v podstatě kombinace roztažení komponent a nastavení identické velikosti (pomocí druhého z výše uvedených konstruktorů této třídy) pro všechny sloupce, čímž dosáhneme naprosto stejného chování, jako u manažeru GridLayout v balíku Swing. V našem případě tedy bude velikost prvního sloupce přizpůsobena velikosti sloupce druhého, protože v něm se nachází největší komponenta. Za jistou nevýhodu lze považovat skutečnost, že následné roztažení všech menších komponent je nutné provést pro každou zvlášťa tudíž se nám při větším počtu komponent nepříjemně rozrůstá zdrojový kód. Poslední možností, kterou si zde uvedeme je roztažení komponenty přes několik buněk, které známe z manažeru GridBagLayout z balíku Swing. Toto nastavení se opět provádí pomocí instance třídy GridData. Opět tedy budeme modifikovat naše čtyři tlačítka. Tentokrát provedeme změnu v tom, že druhé tlačítko roztáhneme přes dva řádky a navíc čtvrté tlačítko přes dva sloupce. Postup modifikace pro zmíněná tlačítka ukazuje zdrojový kód: // nejprve si standardně vytvoříme instanci Button button2 = new Button(shell, SWT.NONE); button2.settext("velké Tlačítko 2"); // nyní vytvoříme instanci třídy GridData // a nastavíme vertikální roztažení GridData gd = new GridData(GridData.FILL_VERTICAL); // zde specifikujeme počet řádků roztažení gd.verticalspan = 2; // nakonec aplikujeme nastavení pro naše tlačítko button2.setlayoutdata(gd); Button button4 = new Button(shell, SWT.NONE); button4.settext("4"); // zde nastavíme horizontální roztažení gd = new GridData(GridData.FILL_HORIZONTAL); // následuje specifikace počtu sloupců gd.horizontalspan = 2; // na závěr nezbytná aplikace pro tlačítko button4.setlayoutdata(gd); Výsledek těchto nastavení nám ukazuje obrázek

29 4.4. FORMLAYOUT GridLayoutsJ 1*1 Tlačítko 1 Velké Tlačítko 2 Tlačítko 3 Obrázek 4.8: GridLayout - komplexní využití manažeru Samozřejmě je možné vytvářet ze všech dostupných možností velké množství kom binací, které se však zde již z prostorových důvodů nebudeme uvádět. V podstatě tedy můžeme o manažeru G r i d L a y o u t z SWT prohlásit, že je ekvivalentem hned dvou manažerů z balíku Swing. Právě z tohoto důvodu se jedná o velmi využívaný mana žer pro rozmístění komponent v praxi. Jak jsme tedy již viděli, manažery v SWT jsou vskutku neuvěřitelně variabilní a přesto je práce s nimi poměrně jednoduchá. 4.4 FormLayout Tato třída představuje poslední a zároveň také nejkomplexnější manažer pro rozmístění komponent v SWT. Jak již jeho název napovídá, je určen pro vytváření formulářů, ale lze jej samozřejmě také využít kdekoliv. Vyčerpávající popis tohoto manažeru by však byl příliš dlouhý, takže si ukážeme jen jeho základní použití. Právě díky své složitosti nám jistě připomene manažer G r i d B a g L a y o u t z balíku Swing. Princip jeho použití je však značně odlišný od manažerů, které jsme si probrali v minulých sekcích. Zatímco například využití třídy G r i d D a t a pro manažer G r i d L a y o u t není povinné a používá se pouze pokud potřebujeme modifikovat implicitní nastavení manažeru, zde budeme povinně pracovat rovnou se dvěmi pomocnými třídami, pomocí nich budeme nasta vovat přesné umístění každé komponenty. Použití těchto tříd je zcela nezbytné, neboť manažer sám neřadí komponenty za sebe (jako například G r i d L a y o u t do řádků) a při nespecifikování potřebných parametrů by se nám jednotlivé komponenty překrývaly. Ke vzniku instance je dostupný jediný konstruktor této třídy: FormLayout () - vytvoří novou instanci manažeru. První pomocnou třídou, kterou musíme využívat je třída FormData, jejíž instanci vytvoříme implicitním konstruktorem FormData ( ). Pro nastavování jejích parametrů slouží instance třídy FormAttachment. Důležité parametry třídy FormData slouží ke specifikaci všech čtyř stran naší komponenty: t o p, b o t t o m, l e f t a r i g h t. Sa motné nastavení těchto parametrů se provádí prostřednictvím samostatných instancí třídy FormAttachment. Z dostupných konstruktorů této třídy si pro naši základní prezentaci vystačíme s následujícími: FormAttachment ( C o n t r o l c o n t r o l, i n t of f s e t ) - umožňuje specifiko vat komponentu, ke které budeme novou komponentu vázat a dále offset (odskok v pixelech). FormAttachment ( i n t n u m e r a t o r, i n t o f f s e t ) - tento konstruktor bu deme používat většinou pro první komponentu a jeho parametry jsou umístění v % vzhledem k dostupnému místu. 24

30 4.4. FORMLAYOUT FormAttachment(Control control, int offset, int alignment) - dovoluje navíc oproti výše zmíněnému konstruktoru nastavit zarovnání vůči zadané komponentě. Nejlépe si princip těchto tříd představíme na samotném zdrojovém kódu. Nejprve si však trochu atypicky ukážeme obrázek a následně ve zdrojovém kódu toto rozmístění vytvoříme. Připomeňme si, že nám v tomto příkladu v žádném případě nejde o nějaké estetické rozmístění tlačítek, ale naším cílem je prezentovat různé možnosti manažeru. Příklad ukazuje obrázek 4.9: HB -Inlxl Tlačítko 1 Tlačítko 3 Velké Tlačítko 2 4 Obrázek 4.9: FormLayout - základní použití Jak si ukážeme, při použití tohoto manažeru nezáleží na pořadí přidávaných komponent, ale na nastavování parametrů v pomocných třídách. Postup ukazuje následující zdrojový kód: // nejprve si vytvoříme instanci manažeru Formlayout shell.setlayout(new FormLayout()); // standardně vytvoříme tlačítko Button buttonl = new Button(shell, SWT.NONE); buttonl.settext("tlačítko 1") ; 1/ nyní vytvoříme instanci třídy FormData FormData fd = new FormData( ); // zde nastavíme umístění horní strany prvního tlačítka // při našem případě se nastavení týká 10% velikosti okna // s odskokem 10 pixelů fd.top = new FormAttachment(10, 10); // podobně pro levý okraj, ale zvolíme jen odskok 10 pixelů fd.left = new FormAttachment(0, 10); // nakonec standardně aplikujeme nastavení pro tlačítko buttonl.setlayoutdata(fd); Button button2 = new Button(shell, SWT.NONE); button2.settext("velké Tlačítko 2"); fd = new FormData( ) ; // nyní nastavíme umístění horního okraje relativně vůči // prvnímu tlačítku a specifikujeme odskok 25

31 4.4. FORMLAYOUT fd.top = new FormAttachment(buttonl, 10); // odskok pro levý okraj je stejný jako v prvním případě fd.left = new FormAttachment(0, 10); button2.setlayoutdata(fd); Button button3 = new Button(shell, SWT.NONE); button3.settext("tlačítko 3"); f d = new FormData () ; // horní okraj třetího tlačítka nastavíme opět relativně // vůči prvnímu tlačítku a použijeme zarovnání na horní hranu fd.top = new FormAttachment(buttonl, 0, SWT.TOP); // levou stranu umístíme relativně k prvnímu tlačítku // s odskokem fd.left = new FormAttachment(buttonl, 10); button3.setlayoutdata(fd); Button button4 = new Button(shell, SWT.NONE); button4.settext("4"); fd = new FormData( ) ; // podobné nastavení provedeme pro poslední tlačítko, // ovšem s relativním umístěním vůči druhému tlačítku fd.top = new FormAttachment(button2, 0, SWT.TOP); fd.left = new FormAttachment(button2, 10); button4.setlayoutdata(fd); Již na první pohled je zřejmé, že se nám naskýtá nepřeberné množství umístění komponent, protože nejsme vázáni na předem definovanou mřížku, jako tomu je u manažeru GridLayout. Pochopení funkčnosti třídy FormAttachment je zcela nezbytné pro použití tohoto manažeru, protože právě díky ní musíme specifikovat potřebné parametry. Obecně tedy ve většině případů budeme dodržovat následující postup: 1. První přidávanou komponentu musíme umístit procentuálně dle dostupného prostoru, neboťnemáme komponentu, ke které bychom přidávanou komponentu umístili relativně. 2. Ostatní komponenty umísťujeme relativně k patřičným sousedním komponentám s definovaným odskokem v pixelech. Možností různých umístění je celá řada. Například pokud modifikujeme nastavení parametrů pro čtvrté tlačítko tak, že nebudeme specifikovat zarovnání na horní hranu, tj. zadáme pouze fd.top = new FormAttachment (button2, 0),bude horní hrana čtvrtého tlačítka umístěna vertikálně na stejné úrovni, jako spodní hrana druhého tlačítka. Jak je ze zdrojového kódu patrné, velký počet nastavení tohoto manažeru nám sice umožňuje přesné umístění komponent podle našich představ, ale ovšem za cenu velkého množství řádků. Právě z těchto důvodů nebudeme tento manažer v našich 26

32 4.5. KOMPONENTY COMPOSITE A GROUP ukázkových příkladech, ve kterých budeme prezentovat práci s jednotlivými komponentami, používat. 4.5 Komponenty Composite a Group Nyní, když už známe všechny dostupné manažery v SWT, se pomalu dostáváme do situace, kdy můžeme začít uvažovat o tvorbě rozsáhlejších GUI, než tomu bylo v ukázkových příkladech v minulých sekcích. Při prvním pohledu na libovolnou dnešní aplikaci, ve které je větší počet komponent, je jasné, že použít jediný manažer pro rozmístění všech prvků v okně je značně nepraktické, ne-li úplně nemožné. V takové situaci přichází k uplatnění třída Comp o s i t e, která představuje ekvivalent třídy JP ane 1 z balíku Swing. Používání panelů (respektive instancí třídy Composite) s sebou nese velkou spoustu výhod. Asi největším kladem je použití různých manažerů pro jednotlivé panely. Použití systému panelů je také přehledné a podstatně jednodušší, než umísťování pomocí jednoho manažeru, neboť si přímo ve zdrojovém kódu logicky seskupujeme související komponenty na stejné panely. Další obrovskou výhodou je snadná pozdější změna GUI, protože nás v tomto případě čeká pouze jistá změna uspořádání v daném panelu a nejsme tedy nuceni složitě přeuspořádávat všechny prvky v našem okně. Navíc, jak si vzápětí ukážeme, použití panelů je velmi snadné. Tedy základní idea je naprosto stejná, jako ve standardních grafických prostředích v jazyce Java, protože komponenty umísťujeme na panely a ty následně umísťujeme do samotného okna (které v podstatě taky obsahuje panel). Pro vytvoření instance je dostupný jediný konstruktor: Composite (Composite parent, int style) - vytvoří instanci a přidá ji do specifikované komponenty parent (přičemž většinou se jedná o instanci třídy Shell, případně další instanci třídy Composite) a nastaví zadaný styl. Z dostupných metod budeme využívat následující: Layout getlayouto - vrací manažer, nastavený pro naši instanci. setlayout (Layout layout) - velmi důležitá metoda, která nastaví zadaný manažer pro daný panel. Samozřejmě je možné použít libovolný manažer z dříve popsaných v minulých sekcích této kapitoly. Nyní se tedy podíváme, jak tento jednoduchý způsob funguje v praxi. Představme si situaci, že potřebujeme rozložení komponent tak, jak ukazuje obrázek 4.10 (přičemž použití tlačítek je opět pouze ilustrační):! CompositeDemo [ Tlačítko 1 Tlačítko Z Tlačítko 3 Tlačítko 4 Tlačítko 5 Tlačítko 6 Obrázek 4.10: Použití komponenty Composite 27

33 4.5. KOMPONENTY COMPOSITE A GROUP Na první pohled je zřejmé, že použití jednoho manažeru by bylo zbytečně komplikované (zřejmě bychom použili manažer GridLayout), protože můžeme výhodně využít dva panely tak, jak ukazuje zdrojový kód: // nejprve si nastavíme manažer pro hlavní okno shell.setlayout(new FillLayout( )); // vytvoříme první panel a umístíme ho do okna Composite compl = new Composite(shell, SWT.NONE); // nastavíme manažer pro první panel compl.setlayout(new FillLayout(SWT.VERTICAL)); // obdobně vytvoříme druhý panel Composite comp2 = new Composite(shell, comp2.setlayout(new RowLayout()); SWT.NONE); // a nyní jednoduše přidáváme tlačítka na příslušné panely Button buttonl = new Button(compl, SWT.NONE); Button button3 = new Button(comp2, SWT.NONE); Vidíme, že kombinací několika panelů s různými manažery můžeme vytvářet již libovolně rozsáhlá GUI s velkým počtem komponent. Na používání panelů je možné si velmi jednoduše zvyknout a toto používání efektivně v praxi využívat. Další třídou ke stejným účelům je v SWT komponenta Group. Práce s ní je naprosto identická, jako u výše zmíněné komponenty Composite jen s tím rozdílem, že nám umožňuje navíc definovat popisek tohoto panelu a sama nám poskytuje jeho orámování. Svými možnostmi je tedy spíše určena pro skupiny komponent, které spolu logicky souvisí. V této fázi jsme již tedy plně připraveni přejít k popisu jednotlivých komponent, které nám SWT nabízí. 28

34 Kapitola 5 Základní Komponenty SWT V této a následujících kapitolách, které tvoří hlavní část této práce, si postupně předvedeme jednotlivé komponenty balíku SWT, z nichž většina je obsažena v balíku org. eclipse. swt.widgets. Pokud se některá z komponent bude nacházet v jiném balíku, tak si na to pro jistotu upozorníme. Nicméně, díky (ve většině případů) dobře pracujícího automatického importování potřebných tříd a balíků, které Eclipse provádí, se nemusíme jejich umístěním nijak podrobně zajímat. Popis funkcionality jednotlivých komponent bude srovnáván s jejich ekvivalenty (ekvivalentem budeme rozumět komponentu, která má podobné vlastnosti, funkcionalitu a vzhled, ale samozřejmě nejde o identickou třídu) jak ve standardních grafických prostředích v jazyce Java, tak v programovacím jazyce Delphi a jak brzy uvidíme, prakticky každá z komponent v SWT je díky aplikaci různých stylů většinou ekvivalentem hned několika komponent ze srovnávaných komponentních systémů. Samotný popis bude doplněn o celou řadu nejrůznějších zásad, které jsme nuceni dodržovat a tipů pro ulehčení práce. První dvě komponenty (Label a Button) nám zároveň poslouží k vysvětlení několika důležitých vlastností balíku SWT, kterými jsou zejména práce s obrázky, barvou písma a pozadím komponent, práce s fonty a především systém událostí a použití posluchačů. V neposlední řadě si také ukážeme některé třídy, jejichž prostředky nejsou uvolněny při standardním zavření hlavního okna aplikace a je tedy nutné pro jejich instance volat metodu dispose (). Přesněji řečeno, v úvodních dvou sekcích budou nejen probrány dvě základní komponenty, ale zároveň si na nich ukážeme spoustu zajímavých vlastností balíku SWT. Jednotlivé ukázkové příklady jsou konstruovány tak, aby co nejlépe reflektovaly alespoň základní vlastnosti komponent a ukázaly především využití jejich metod. 5.1 Label - práce s fonty a vkládání obrázků První komponentou, se kterou se zde setkáme je klasické návěští. V podstatě tedy představuje pasivní text (což si lze představit tak, že tato komponenta nemůže získat fokus), který se nejčastěji používá k nejrůznějším popiskům jiných komponent (například si můžeme zmínit velmi časté využití pro popisek textového pole, které slouží pro vstup uživatelem zadávaných hodnot). Jedná se o tak základní komponentu, že její funkcionalita je v podstatě stejná, jako ve standardních grafických prostředích (přesně se jedná o komponenty Label v AWT a JLabel v balíku Swing). Navíc však oproti komponentě Label z AWT zde máme možnost vložení obrázku (o důležitosti tématicky správných obrázků v GUI se nemá smysl rozepisovat), jako tomu je v balíku Swing. Navíc oproti zmíněným ekvivalentním komponentám umožňuje vkládání separátorů (oddělovacích čar) a podobně jako ostatní komponenty v SWT dovoluje specifikovat požadovaný styl. Za jistou nevýhodu lze považovat skutečnost, že umožňuje pouze jednu z výše uvedených možností, tj. do jedné instance můžeme vložit text, obrázek, 29

35 5.1. LABEL - PRÁCE S FONTY A VKLÁDÁNÍ OBRÁZKŮ nebo vytvořit oddělovací čáru. Právě z tohoto důvodu je vytvoření návěští s obrázkem a textem poněkud složitější (prakticky tedy musíme vytvořit dvě instance) a ukážeme si jej na příkladě v této kapitole. Podíváme-li se do komponentního systému Delphi, tak v tomto jazyce můžeme považovat za ekvivalentní komponentu TLabel, ovšem s tím rozdílem, že v Delphi se návěští nepoužívá pro vkládání obrázku (k tomu slouží komponenta T Image). Pro vznik instance třída nabízí jediný konstruktor: Label (Composite parent, int style) -vytvoří instanci třídy Label. Všimněme si dvou parametrů konstruktoru, které se nám v podstatě budou opakovat i v následujících komponentách. První parametr specifikuje, na který panel (instanci třídy Composite), případě do kterého okna (instance třídy Shell) nově vytvořenou komponentu umístíme. Tento postup je poněkud odlišný od AWT i balíku Swing, protože při jejich použití nemáme k dispozici takový konstruktor a jsme tedy nuceni provést umístění explicitně (například pane. add (label), kde pane je instancí třídy JP ane 1). Podobně jako konstruktory jiných komponent v SWT nám neumožňuje zadat obsah komponenty přímo (jako například konstruktor JLabel (String text)), ale musíme využít patřičné metody. Druhým parametrem je použitý styl. Ze všech dostupných si jmenujme alespoň následující: - SWT. SEPARATOR - zajímavá možnost vytvoření oddělovací čáry. Při použití tohoto stylu pak ovšem není možné umístit do tohoto návěští zároveň text či obrázek. Výsledný efekt je podobný separátorům, používaných při tvorbě menu. - SWT.HORIZONTAL - důležité zvláště při používání separátom. Vzhledem k tomu, že implicitní separator je vertikální, je tento styl nezbytný pro tvorbu horizontálního separátoru. - SWT. VERT ICAL - nastavení vertikální orientace (implicitní nastavení). - SWT.WRAP - zajímavá volba, umožňující nastavení zalamování řádků textu v návěští. Vzhledem k tomu, že všechny styly jsou konstanty, obsažené v SWT, budeme si je dále často uvádět přímo jejich názvy (tj. například styl SEPARATOR), ale při samotném programování musíme samozřejmě uvést plný název konstanty. Pro jistotu si připomeňme, že při použití více stylů v jedné chvíli musíme využít oddělovač " ", který jsme například používali při specifikacích stylů fontů v balíku Swing. Například tedy: Label lab = new Label(shell, SWT.HORIZONTAL SWT.SEPARATOR); Z dostupných metod si zmíníme následující: int get Alignment () - vrací zarovnání textu (případně obrázku), který se nachází v návěští. Image get Image () - vrací obrázek obsažený v návěští. String gettext () -vrací popisek jako řetězec typu String. 30

36 5.1. LABEL - PRÁCE S FONTY A VKLÁDÁNÍ OBRÁZKŮ setalignment (int alignment) -umožňuje nastavit orientaci textu (obrázku), umístěného v návěští. Je vhodné si uvědomit, že takové nastavení se projeví pouze tehdy, je-li samotná instance třídy Label větší, než text či obrázek v ní umístěný (například pokud byla roztažena některým z manažerů). Při použití metody pack () tedy zřejmě toto nastavení nemá žádný efekt. Možné parametry JSOU SWT. LEFT (implicitní), SWT. CENTER a SWT. RIGHT. setbackground (Color color) -tato metoda nám umožní nastavit barvu pozadí. Samotný parametr color budeme nejčastěji zadávat jako například návratovou hodnotu metody display. getsystemcolor (SWT. COLOR_RED), která na pozadí nastaví červenou barvu. Není tedy možné používat konstanty barev jednoduchým způsobem, jako tomu je v balíku Swing, kde by nám stačilo specifikovat Color. RED. setforeground (Color color) - slouží ke změně barvy popředí návěští (tj. písma). set Image (Image image) - vloží do návěští zadaný obrázek. Princip si ukážeme na příkladě. settext (String string) -velmi často využívaná metoda, protože je jediným nástrojem pro vložení textu (popisku) do návěští. Vložení existujícího obrázku do návěští není nic složitého a jedná se o podobný princip jako ve standardních javových prostředích. Můžeme použít obrázek libovolného standardního formátu (BMP, PNG, GIF,...), přičemž si musíme uvědomit, že pokud budeme chtít používat průsvitnost, jsme omezeni pouze na formáty PNG a GIF. Musíme tedy vytvořit instanci třídy Image a pro naše základní účely si vystačíme s následujícím konstruktorem: Image (Device device, ImageData data) - vytvoří instanci třídy pro zadané zařízení (v našem případě půjde v podstatě vždy o instanci třídy Display) a druhým parametrem budeme rozumět cestu k obrázku (standardní řetězec). Pro zadání cesty můžeme použít obou typů lomítek (tedy normální i zpětné), takže v tomto případě nám nehrozí některá z chyb, které ze záměny lomítek ve standardních javových prostředích byly v podstatě na denním pořádku. Nicméně, při použití zpětných lomítek nesmíme zapomenout na jejich řídící význam a tedy musíme používat lomítka dvě. Například tedy: Image image = new Image(display, "e:\\java\\img\\image.png"); Při vkládání obrázků v projektech, na kterých pracujeme ve vývojovém prostředí Eclipse se nám bude hodit také zadávání relativní cesty od aktuálního adresáře (nyní například pro ilustraci použijeme normální lomítka): Image image = new Image(display, "./img/image.png"); Na rozdíl od běžných komponent je však u třídy Image jistý specifický rys. Při zavírání hlavního okna aplikace a zavolání metody display. dispose () nejsou uvolněny prostředky držené touto instancí. Je tedy nutné použít metodu pro uvolnění prostředků pro naši instanci, tj.: 31

37 5.1. LABEL - PRÁCE S FONTY A VKLÁDÁNÍ OBRÁZKŮ image.dispose() ; Nyní si tedy konečně ukážeme vlastnosti této komponenty na praktickém příkladě. Vytvoříme okno s několika různými návěštími, na kterých budeme prezentovat různé způsoby zobrazení této komponenty. Na první trojici návěští si ukážeme různé způsoby zarovnání obsaženého textu, změnu barvy písma a pozadí. Druhá trojice nám předvede vložení obrázku do návěští a vytvoření horizontální oddělovací čáry. Pro lepší představu nám tyto různá návěští ukazuje následující obrázek 5.1: Obrázek 5.1: Label - základní použití komponenty Práci s instancí třídy Label prezentuje zdrojový kód, ze kterého si především z důvodu procvičení práce s manažery ukážeme větší část: // vytvoříme si hlavní panel s manažerem GridLayout, // který je pro naše účely ideální Composite labelcomp = new Composite(shell, SWT.NONE); GridLayout gridl = new GridLayout(2, true); labelcomp.setlayout(gridl); GridData gd = new GridData(GridData.FILL_HORIZONTAL); // první návěští je obyčejný text Label lab_left = new Label(labelComp, SWT.NONE); lab_left.settext("zarovnání vlevo"); lab_left.setlayoutdata(gd) ; // nyní si musíme vytvořit další panel, abychom dosáhli // umístění obrázku a textu vedle sebe Composite imgcomp_left = new Composite(labelComp, SWT.NONE); // manažer RowLayout je v podstatě nutný, aby nedošlo // k nežádoucí deformaci obrázku imgcomp_left.setlayout(new RowLayout()); // na vytvořený panel umístíme návěští s obrázkem Label lab_imgl = new Label(imgComp_left, SWT.NONE); Image image = new Image(display, "./img/adrift.gif"); lab_imgl.setimage(image) ; // a následně také text Label lab_imgtext = new Label(imgComp_left, SWT.NONE); 32

38 5.1. LABEL - PRÁCE S FONTY A VKLÁDÁNÍ OBRÁZKŮ lab_imgtext.settext("návěští s obrázkem vlevo"); Label lab_center = new Label(labelComp, SWT.NONE); lab_center.settext("zarovnání na střed"); // tímto způsobem si nastavíme červenou barvu písma lab_center.setforeground( display.getsystemcolor(swt.color_red)); lab_center.setlayoutdata(gd) ; // následující řádky nám ukazují vytvoření horizontální // oddělovací čáry Label lab_separ = new Label( labelcomp, SWT.HOŘIZONTAL SWT.SEPARATOR); lab_separ.setlayoutdata(gd) ; Label lab_right = new Label(labelComp, SWT.NONE); lab_right.settext("zarovnání vpravo"); lab_right.setforeground( display.getsystemcolor(swt.color_red)); // tímto způsobem si nastavíme barvu pozadí naší komponenty lab_right.setbackground( display.getsystemcolor(swt.color_green)); lab_right.setalignment(swt.right) ; lab_right.setlayoutdata(gd) ; // a vytvoříme poslední návěští podobně jako předchozí // komponentu s obrázkem Composite imgcomp_right = new Composite(labelComp, SWT.NONE); imgcomp_right.setlayout(new RowLayout()); Label lab_imgtextr = new Label(imgComp_right, SWT.NONE); lab_imgtextr.settext("návěští s obrázkem vpravo"); Label lab_imgr = new Label(imgComp_right, SWT.NONE); lab_imgr.setimage(image) ; // uvolnění prostředků image.dispose() ; Pro jistotu si ještě jednou upozorníme na přítomnost příkazu image. dispose (), který je zcela nezbytný pro uvolnění prostředků, držených naší aplikací. Na závěr této kapitoly si ještě budeme prezentovat, jakým způsobem můžeme v případě potřeby změnit font textu, který je obsažen v návěští (což je samozřejmě použitelné i pro ostatní komponenty). Jednotlivé fonty jsou instance třídy Font a k naší základní práci si vystačíme s konstruktorem: Font (Device device, FontData fd) - prvním parametrem pro nás bude 33

39 5.1. LABEL - PRÁCE S FONTY A VKLÁDÁNÍ OBRÁZKŮ vždy instance třídy Display a druhý parametr umožňuje specifikovat instanci třídy FontData, kterou si vzápětí popíšeme. K nastavování typu fontu a jeho stylů budeme využívat třídu FontData. Ke vzniku instance nebudeme využívat konstruktor, ale pro jednoduchost využijeme následující kód: FontData[] fontdata = label.getfont().getfontdata(); Všimněme si, že takto definovaná proměnná f ontdata je pole díky návratovému typu metody getfontdata (). V prostředích Windows a Linux však vždy připadají jednomu fontu právě jedny f ontdata, takže se v našem případě bude vždy jednat o jednoprvkové pole (pro jistotu si uveďme, že toto pole je číslováno od nuly). Třída FontData nám umožňuje nastavovat důležité parametry pomocí následujících metod: setheight (int height) - umožňuje nastavení velikosti písma. setname (String name) - nastavení fontu, možné hodnoty jsou jména fontů (například Times, Tahoma, Arial,...). setstyle (int style) - důležitá metoda pro nastavení stylu. Možné hodnoty jsou S WT. NORMAL (implicitní), SWT.BOLD (tučné písmo) a S WT. ITALIC (kurzíva). Samozřejmě je také možné použít více stylů zároveň (což má ovšem smysl jen pro kombinaci tučné kurzívy, neboťnormální styl je implicitní). Podobně jako u výše zmíněná třídy Image nedojde ani u třídy Font ke zrušení prostředků při zavření hlavního okna aplikace. Je tedy opět nutné zavolat metodu font.dispose(). Změnu fontů v návěští si opět ukážeme na praktickém příkladě. Vytvoříme tři instance třídy Label s různými styly (normální, tučné a kurzíva) a ve čtvrtém návěští změníme typ písma na Times New Roman tak, jak ukazuje obrázek 5.2: Implicitní styl Kurzíva Tučné písmo Times New Roman Obrázek 5.2: Label - změna fontů Postup je velmi jednoduchý a ukazuje jej zdrojový kód: // nastavení stylu tučného písma FontDataf] fontdata = lab_bold.getfont().getfontdata() ; fontdata[0].setstyle(swt.bold); Font boldf = new Font(display, fontdata); lab_bold.setfont(boldf); // podobně nastavíme kurzívu 34

40 fontdata = lab_italic.getfont().getfontdata(); fontdata[0].setstyle(swt.italic); Font italicf = new Font(display, fontdata); lab_italic.setfont(italicf) ; // zde máme příklad změny fontu fontdata = lab_times.getfont().getfontdata(); fontdata[0].setname("times"); Font timesf = new Font(display, fontdata); lab_times.setfont(timesf); 5.2. BUTTON A PRÁCE S POSLUCHAČI // opět nezbytné uvolnění prostředků boldf.dispose() ; italicf.dispose(); timesf. dispose () ; Jak jsme v této sekci viděli, přestože se jedná o velmi podobnou komponentu jako v prostředích, se kterými provádíme srovnání, má třída Label svá specifika, které musíme při návrhu GUI brát v úvahu. Navíc jsme se setkali se dvěmi třídami (Font a Image), jejichž prostředky jsme nuceni uvolňovat explicitně. Všechny výše zmíněné postupy pro vkládání obrázku a práci s fonty jsou samozřejmě použitelné také pro ostatní komponenty, takže nám tato třída posloužila pro jejich prezentaci. Od následující sekce se již začneme zabývat komponentami, které již mohou získat fokus a tudíž se budeme muset seznámit také se systémem událostí a posluchačů v SWT. 5.2 Button a práce s posluchači Tato třída z balíku SWT představuje velmi komplexní komponentu, která neslouží jen k vytváření standardních tlačítek, jako je tomu u na první pohled ekvivalentních tříd Button a JButton ve standardních javovských prostředích a TButton v Delphi. Pomocí nastavování různých stylů si novou instanci této třídy můžeme upravit přesně podle svých představ. Tyto styly nám tedy například umožní vytvářet zaškrtávací políčka pro nastavování různých parametrů (což nám umožňují například třídy JCheckBox v balíku Swing a TCheckBox v Delphi) a také slouží jako nástroj pro výběr právě jedné z více možností (známé například při použití komponenty JRadioButton, případně TRadioButton v Delphi). Případě nám také v případě potřeby umožňují vytvořit tlačítko, které zůstane po stisknutí stlačené tak, jak je to možné použít v balíku Swing při použití třídy JToggleButt on. Jedná se tedy o velmi univerzální komponentu, jejíž použití je mnohem všestrannější než tomu je v balících AWT a Swing. Podobně jako v balíku Swing je i zde možnost umístění obrázku, jen s tím rozdílem, že podobně jako u komponenty Label, kterou jsme si popsali v minulé sekci, není možné (jednoduchým způsobem) ani na tuto komponentu umístit text i s obrázkem zároveň. Na této komponentě si zároveň budeme prezentovat práci s posluchači v SWT, které 35

41 5.2. BUTTON A PRÁCE S POSLUCHAČI najdeme v balíku org. eclipse. swt. events. Přestože implicitně předpokládám, že se čtenáři s posluchači ve standardních javovských prostředích už setkali, musíme si alespoň základní princip stručně popsat tak, aby nedocházelo v následujícím textu k případným nedorozuměním. Principy registrace posluchačů a práce s nimi, které si v této kapitole postupně ukážeme jsou samozřejmě korektní pro všechny ostatní komponenty SWT, které můžou získat fokus a tudíž po nich budeme požadovat, aby na vzniklé události adekvátně reagovaly. Takže základní princip je následující: 1. Vytvoříme si instanci komponenty prostřednictvím některého z jejích konstruktem. 2. Provedeme registraci požadovaného posluchače pomocí metody: addsomelistener(new SomeListener()) Parametr Some si zde uvádíme pouze z ilustračních důvodů. Například tedy registraci posluchačů pro naše tlačítka budeme provádět pomocí volání metody addselectionlistener(new SelectionAdapter( ) {... ). Způsobů práce s posluchači je hned několik a jen pro lepší představu jsme v tomto případě použili tzv. anonymní třídu. 3. Provedeme implementaci potřebných metod třídy posluchače, přičemž samozřejmě můžeme s výhodou využít adaptérů, pokud potřebujeme, aby naše komponenta reagovala jen na jistou podmnožinu možných událostí, na které posluchač reaguje. Za velkou výhodu můžeme považovat skutečnost, že nemusíme implementovat metody, které nebudeme pro naši komponentu potřebovat. 4. Pokud se dále stane událost (například je stisknuto tlačítko), pro kterou máme zaregistrovaný posluchač, je provedena reakce prostřednictvím námi implementovaného kódu v metodě (případně metodách) posluchače. Třída nabízí ke vzniku instance jediný konstruktor: Button (Composite parent, int style) - vytvoří novou instanci a umístí ji na specifikovaný panel. Z možných stylů, které můžeme zadat si zmíníme alespoň ty nejdůležitější, které slouží k zásadním změnám vlastností této komponenty (přičemž je nutné si uvědomit, že jsou některé styly navzájem výlučné a není možné je kombinovat navzájem): - ARROW - dvojice tlačítek pro zvyšování (snižování) určité hodnoty. - CHECK - zaškrtávací políčko, které slouží jako dvoustavový přepínač. - PUSH - standardní tlačítko, které po svém stisknutí provede určitou posloupnost akcí. Tento styl je implicitní a stejného výsledku dosáhneme použitím stylu SWT. NONE v konstruktoru této třídy. - RAD 10 - slouží k vytvoření systému přepínačů pro výběr právě jedné z více možností. Již nyní si uveďme, že tato tlačítka není možné sdružovat do skupin (jako například třída ButtonGroup v balíku Swing). Podrobně si tento styl popíšeme dále v této sekci. - TOGGLE - alternativní přepínače se stejnou funkcionalitou jako při použití Stylu SWT. CHECK. 36

42 5.2. BUTTON A PRÁCE S POSLUCHAČI Jak jsme si již uvedli výše, není možné kombinovat všechny dostupné styly navzájem. Například tedy není možné vytvořit jediné tlačítko, pracující jako checkbox (styl SWT. CHECK) a zároveň pracující jako přepínač (SWT. TOGGLE). Nicméně, je samozřejmě možné použití více stylů například pro checkbox s definovaným zarovnáním na střed v rámci použitého layout manažeru. Dostupných metod je celá řada, takže si zde zmíníme alespoň následující: addselectionlistener (SelectionListener listener) - přidá pro tlačítko posluchače SelectionListener, který slouží k zachycení událostí, vyvolávaných stiskem tlačítka. Možnými způsoby implementace se budeme zabývat v této sekci. int get Alignment () - vrací zarovnání textu (případně obrázku), který je umístěn na tlačítku. Možné návratové hodnoty představují standardní konstanty SWT. LEFT, SWT. CENTER a SWT. RIGHT. Pokud je pro tlačítko použit styl ARROW, tak můžeme navíc očekávat také hodnoty SWT. UP, případně SWT. DOWN. Image get Image () -vrací obrázek, umístěný na tlačítku, nebo null, pokud se na tlačítku žádný obrázek nenachází. boolean get Se lection () - vrací true, je-li tlačítko zaškrtnuto (případě zatlačeno, což závisí na použitém stylu). V opačném případě vrací false. String gettexto - vrací text, který je umístěn na tlačítku. V případě, že se na tlačítku text nenachází nebo byl pro tlačítko použit styl SWT. ARROW, vrací nul 1. setalignment (int alignment) -umožňuje specifikovat zarovnání textu (obrázku). Možné hodnoty jsou stejné jako ty, které jsme si uvedli výše u metody getalignment(). set Image (Image image) - umožňuje nastavení obrázku, který bude umístěn místo popisku na tlačítku. Pro práci s obrázky platí úplně stejná pravidla, která jsme si uvedli v předchozí sekci (pochopitelně včetně explicitního uvolňování zdrojů). setselection (boolean selected) - umožňuje nastavit zaškrtnutí (označení) tlačítka. Je zřejmé, že toto nastavení má smysl provádět pouze v případě, že máme pro naši instanci použit některý ze stylů SWT. CHECK, SWT. RADIO, nebo SWT. TOGGLE. set Text (String string) - slouží ke specifikaci textu jako popisku na tlačítku. settooltiptext (String text) - slouží k zadání rozbalovací nápovědy pro tlačítko. Přestože si samozřejmě postupně ukážeme tvorbu různých stylů tlačítek, nejprve se zaměříme na standardní tlačítka a budeme si na nich zároveň prezentovat různé možnosti implementace posluchačů. Jednotlivé principy jsou v podstatě identické s těmi, se kterými jsme běžně pracovali v balíku Swing (pochopitelně až na rozdílné názvy posluchačů). Těchto postupuje celá řada a vzhledem k tomu, že při používání posluchačů v podstatě vždy implementujeme rozhraní posluchače, případně využíváme adaptéru 37

43 5.2. BUTTON A PRÁCE S POSLUCHAČI (respektive vytváříme třídu, která je potomkem existujícího adaptéru), tak nám tyto postupy v podstatě jen reflektují standardní principy objektového programování. Ze všech dostupných principů si podrobně ukážeme dva postupy, se kterými si v praxi ve většině případů vystačíme a vytvoříme jednoduché okno se dvěmi instancemi třídy Button a jedním návěštím pro detekci stisku jednotlivých tlačítek tak, jak ukazuje obrázek 5.3: Bylo stisknuto: Tlačítko 1 Tlačítko 1 Tlačítko 2 ButtonDemo LOl_x Bylo stisknuto: Tlačítko 2 Tlačítko 1 Tlačítko 2 f Obrázek 5.3: Button - zpracování základních událostí Pro naše účely potřebujeme implementovat posluchač SelectionListener a protože potřebujeme pouze reagovat na stisk tlačítka, s výhodou využijeme třídu SelectionAdapter. Postupy, jejichž prostřednictvím dosáhneme požadovaného výsledku ukazují následující zdrojové kódy: 1. První způsob je použití tzv. anonymních tříd a budeme jej velmi často využívat v našich ukázkových příkladech především z důvodu kratšího zdrojového kódu. V případě, kdy zdrojový kód implementovaných metod posluchače je poněkud rozsáhlý, tak můžeme tento způsob označit za nepřehledný, ale při kratších zdrojových kódech se jeví jako velmi užitečný a jednoduchý. Nyní se tedy podívejme na řešení našeho ukázkového příkladu s využitím anonymních tříd: // nejprve si vytvoříme tlačítko Button buttonl = new Button(shell, SWT.NONE); buttonl.settext("tlačítko 1") ; buttonl.setlayoutdata(gd); // přidáme posluchače a provedeme implementaci buttonl.addselectionlistener(new SelectionAdapter() { // implementujeme potřebnou metodu adaptéru public void widgetselected(selectionevent e) { // kód, který nám zobrazí text tlačítka v návěští label.settext("bylo stisknuto: " + ((Button) e.getsource ()).gettext ( ); // obdobné akce provedeme pro druhé tlačítko Button button2 = new Button(shell, SWT.NONE); button2.settext("tlačítko 2"); button2.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { label.settext("bylo stisknuto: " + ( (Button) e.getsource()).gettext( 38

44 5.2. BUTTON A PRÁCE S POSLUCHAČI ); Všimněme si, že jsme s výhodou využili metodu get Source (), jejíž návratovou hodnotou je komponenta, která událost vyvolala. Navíc si ovšem musíme uvědomit, že je tato komponenta typu Object a tudíž ji pro naše účely (zjištění textu, který je na ní umístěn) musíme přetypovat na původní typ Button. Vzhledem k tomu, že uvnitř naší anonymní třídy pracujeme s lokální proměnou label, tak šiji při vytváření instance musíme deklarovat jako final, či případně provést její deklaraci globálně pro celou hlavní třídu. 2. Druhý způsob, který si zde uvedeme je použití tzv. vnitřních tříd. Tento princip budeme využívat v případě delších zdrojových kódů implementovaných metod. Vzhledem k tomu, že opět využijeme adaptér SelectionAdapter, budeme vytvářet třídu, která bude potomkem tohoto adaptéru. Pokud bychom potřebovali využít i ostatní metody posluchače, naše třída by musela implementovat rozhraní SelectionListener. Obě možnosti jsou dobře známé ze standardních javovských prostředí, ale pro jistotu si ukážeme hlavní rozdíl: // implementace rozhraní posluchače class ButtonListener implements SelectionListener {... // využití adaptéru class ButtonListener extends SelectionAdapter {... Samotný postup s využitím adaptéru ukazuje následující zdrojový kód: // vytvoříme první tlačítko a provedeme registraci // posluchače Button buttonl = new Button(shell, SWT.NONE); buttonl.settext("tlačítko 1") ; buttonl.addselectionlistener(new ButtonListener()); // obdobně pro druhé tlačítko Button button2 = new Button(shell, SWT.NONE); button2.settext("tlačítko 2"); button2.addselectionlistener(new ButtonListener()); // dokončení konstruktoru standardním způsobem // vytvoříme vnitřní třídu jako potomka potřebného // adaptéru class ButtonListener extends SelectionAdapter { // podobně jako v~předchozím případě // implementujeme metodu public void widgetselected(selectionevent e) { label.settext("bylo stisknuto: " + 39

45 5.2. BUTTON A PRÁCE S POSLUCHAČI ( (Button) e.getsource()).gettext ()); V našem velmi jednoduchém případě nám dokonce stačilo vytvořit pouze jedi nou třídu, která bude pracovat jako posluchač a díky metodě g e t S o u r c e () ji můžeme jednoduše využít pro obě tlačítka. Pro jistotu si uveďme, že tuto vnitřní třídu nemůžeme definovat v některé z metod naší hlavní třídy (například v konstruktoru), ale jejich definice se provádí podobně jako je tomu u jednotlivých metod třídy. Pro větší projekty se jeví jako velmi zajímavý způsob vytvoření jednotlivých stan dardních tříd posluchačů pro naše komponenty a jejich umístění do příslušného balíku, čímž dosáhneme lepší logické struktury aplikace. V případě potřeby (či zvyku) si také samozřejmě můžeme implementovat rozhraní posluchače přímo naší hlavní třídou, ale tento způsob nebývá nijak zvláště využíván především kvůli nutnosti rozlišení původců událostí v jeho metodách. Jak jsme si již výše uvedli, komponenta B u t t o n je v podstatě několik kompo nent v jedné, podle stylu, který na ni při jejím vytváření aplikujeme. Dosud jsme pracovali pouze se standardním tlačítkem, které je představováno stylem SWT. NONE (respektive SWT.PUSH). Nyní nás tedy čeká prohlídka ostatních stylů této kompo nenty, která nám bude dokonale ilustrovat modifikovatelnost komponent v SWT. Již na první pohled můžeme zaregistrovat první velkou výhodu tohoto způsobu, kterou je použití posluchače S e l e c t i o n L i s t e n e r pro všechny dostupné styly a nemusíme se tedy pro základní práci zabývat použitím většího množství posluchačů (například I t e m S e l e c t i o n L i s t e n e r pro JCheckBox, A c t i o n L i s t e n e r pro J B u t t o n atd.). Prvním stylem, který si zde ukážeme je SWT. CHECK pro tvorbu zaškrtávacích polí ček pro nastavování nejrůznějších parametrů. Podobně jako u komponenty JCheckBox se jedná o dvoustavový přepínač, a není možné využít systém těchto tlačítek pro výběr právě jedné z více možností (narozdíl například od AWT) a jedná se tedy o samostatné přepínače. Velmi častou metodou, kterou budeme při práci s tímto stylem využívat je metoda g e t S e l e c t i o n ( ), díky které můžeme jednoduše zjistit, zda je políčko zaškrt nuto (tato metoda vrátí hodnotu t r u e ), nebo zaškrtnuto není (vrátí hodnotu f a l s e ). I LWUIUJ«, r; popisek v návěští Červené písmo 1^ Zelené pozadí W Tučné písmo W Kurzíva Ukázkový popisek v návěští rv Červené písmo ľ Zelené pozadí W Tučné písmo Kurzíva f I twu!u SWT.CHECK Ukázkový popisek v návěští W Červené písmo ľ W Tučné písmo _ n x Zelené pozadí W Kurzíva _ n x Ukázkový pop/sek v návěští Červené písmo W Zelené pozadí Tučné písmo W Kurzíva Obrázek 5.4: Button - styl SWTCHECK Funkcionalitu zaškrtávacích políček si ukážeme na příkladě. Vytvoříme si okno s návěštím a čtyřmi checkboxy tak, abychom prezentovali jejich nezávislost a ukázali 40

46 5.2. BUTTON A PRÁCE S POSLUCHAČI rozdíl oproti výběru právě jedné z více možností, kterou si ukážeme vzápětí. Tato zaškrtávací políčka budou sloužit ke změně barvy písma, barvy pozadí návěští, nastavení stylu tučného písma a kurzívy. Různé kombinace nastavení v našem příkladě ukazuje obrázek 5.4. Postup je jednoduchý a všimněme si na něm především používání stejného adaptéru Select ionadapter (a také implementace stejné metody), jako tomu bylo u standardních tlačítek v předchozím příkladě: // nejprve si vytvoříme checkbox buttonl = new Button(shell, SWT.CHECK); buttonl.settext("červené písmo"); buttonl.setlayoutdata(gd); // přidáme posluchače pro nastavení červeného písma buttonl.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { // zde si zjistíme, zde je políčko zaškrtnuto if (buttonl.getselection()) { label.setforeground( display.getsystemcolor(swt.color_red)); else { label.setforeground( display.getsystemcolor(swt.color_black) ); // vytvoříme další checkbox button2 = new Button(shell, SWT.CHECK); button2.settext("tučné písmo"); button2.setlayoutdata(gd); // posluchač bude v tomto případě trochu složitější button2.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { // opět rozlišíme stav přepínače if (button2.getselection()) { fontdata = label.getfont().getfontdata(); // navíc musíme zjistit stav přepínače pro // nastavení kurzívy if (button3.getselection()) { fontdata[0].setstyle(swt.italic SWT.BOLD); else { fontdata[0].setstyle(swt.bold); // vytvoříme instanci fontu a nastavíme jej // pro návěští 41

47 5.2. BUTTON A PRÁCE S POSLUCHAČI font = new Font(display, fontdata); label.setfont (font); else { // podobne pokračujeme pro nezaškrtnutý přepínač fontdata = label.getfont().getfontdata(); if (button3.getselection()) { fontdata[0].setstyle(swt.italic); else { fontdata[0].setstyle(swt.none); // nakonec opět provedeme nastavení fontu // pro návěští font = new Font(display, fontdata); label.setfont (font); ); Všimněme si, že díky nezávislosti jednotlivých zaškrtávacích políček musíme v případě nastavování tučného písma a kurzívy zjišťovat stav druhého přepínače. Je zřejmé, že pokud bychom vytvářeli "opravdovou" aplikaci a ne jen ukázkový příklad, bylo by velmi vhodné vytvořit si na nastavování jednotlivých stylů fontu metodu, která by uměla styly přidávat a zároveň také odstraňovat. Ještě jednou si připomeňme, že vzhledem k tomu, že v našem zdrojovém kódu pracujeme s instancemi třídy Font, nesmíme zapomenout explicitně uvolnit její prostředky pomocí volání metody font. dispose (). Druhým stylem (respektive třetím, počítáme-li i standardní tlačítka), na který se společně podíváme je SWT. RADIO, který slouží pro vytváření systému přepínačů pro výběr právě jedné ze dvou či více možností. Vzpomeneme-li si na používání skupiny těchto přepínačů ve standardních javovských prostředích, jistě se nám vybaví, že pro zabezpečení výběru právě jednoho přepínače vždy sloužila nějaká třída (například ButtonGroup v balíku Swing), která zabezpečila potřebné vlastnosti komponenty. SWT se skutečně snaží zjednodušit vše, co je jen trochu možné a proto zde nenalezneme žádnou třídu pro skupinu tlačítek. Samotný princip výběru právě jednoho tlačítka je zde docílen automaticky pro všechny tlačítka se stylem SWT. RAD I O, která jsou umístěna v jednom kontejneru (například instance tříd Shell či Composite). Tento princip se zdá být velmi jednoduchý a užitečný, neboťnám odpadá starost s přidáváním tlačítek do jednotlivých skupin. Jenže již na první pohled je ale jasné, že pokud budeme potřebovat vytvořit dvě na sobě nezávislé skupiny přepínačů, jsme automaticky nuceni vytvořit dva různé panely, na které skupiny samostatně umístíme, což rozhodně nemusí být z hlediska návrhu vítané. Připomeňme si, že i při použití tohoto stylu budeme opět zpracovávat události stejného typu prostřednictvím stejného posluchače, jako tomu bylo dříve. Vytvoříme si jednoduché okno s návěštím a dvěmi skupinami přepínačů, přičemž jedna z nich bude sloužit k přepínání barev písma a druhá k nastavování barvy pozadí tak, abychom prezentovali výběr právě jedné z více možností (například požadujeme, aby bylo písmo buď červené, nebo zelené). Různé kombinace nám ukazuje obrázek

48 5.2. BUTTON A PRÁCE S POSLUCHAČI Obrázek 5.5: Button - styl SWTRADIO Postup je opět velmi jednoduchý, ale musíme si uvědomit nutnost použití panelů pro obě skupiny přepínačů: // vytvoříme si panel pro první skupinu Composite fontcomp = new Composite(shell, SWT.NONE); // ideálním manažerem pro náš panel je FillLayout fontcomp.setlayout(new FillLayout()); // nutné, neboť pro shell máme nastavený GridLayout gd.horizontalspan = 2; fontcomp.setlayoutdata(gd) ; // vytvoříme první přepínač v první skupině buttonl = new Button(fontComp, SWT.RADIO); buttonl.settext("červené písmo"); // nastavíme implicitní zaškrtnutí buttonl.setselection(true); // implementujeme posluchače buttonl.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { label.setforeground(display.getsystemcolor( SWT.COLOR_RED)); ); // podobně pokračujeme pro druhou dvojici přepínačů Composite backcomp = new Composite(shell, SWT.NONE); backcomp.setlayout(new FillLayout()); gd.horizontalspan = 2; backcomp.setlayoutdata(gd); // nutné je přidat tlačítko do správné skupiny button2 = new Button(backComp, SWT.RADIO); button2.settext("šedé pozadí"); button2.setselection(true); button2.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { label.setbackground(display.getsystemcolor( 43

49 5.2. BUTTON A PRÁCE S POSLUCHAČI ); SWT.COLOR_GRAY)); Díky univerzálnímu konstruktoru třídy Button tedy specifikujeme požadovanou skupinu prostřednictvím zadání odpovídajícího kontejneru přímo při vzniku instance. Podobně jako je tomu ve standardních javovských prostředích, je i v SWT vhodné uchovávat si v nějaké proměnné stav přepínače a v posluchači pak provést kontrolu, zda byl stav změněn. Ze struktury posluchače je zřejmé, že provede celý implementovaný kód i při opětovaném kliknutí na již zaškrtnuté tlačítko a právě zamezením tohoto jevu pomocí kontroly stavu přepínače dosáhneme vyššího výkonu aplikace (markantní zvláště při větším počtu operací v posluchači). Dalším stylem, který si zde budeme prezentovat je styl SWT. TOGGLE. Podobně jako u komponenty JToggleButton v balíku Swing (v prostředí AWT podobnou komponentu nenajdeme) se jedná "jen" o vizuální náhradu standardních zaškrtávacích políček, které nám prezentuje styl SWT. CHECK. Opět se tedy jedná o dvoustavový přepínač, a protože je práce sním identická, j ako se standardními zaškrtávacími políčky, nebudeme se tímto stylem nijak podrobně zabývat. Pro ukázku si vytvoříme stejný příklad, jako tomu bylo u stylu SWT. CHECK tak, jak ukazuje obrázek 5.6: SWT.TOGGLE [ 1 SWT.TOGGLE Ukázkový popisek v návěstí Ukázkový popisek v návěští Červené písmo Zelené pozadí Červené písmo Zelené pozadí Tučné písmo Kurzíva Tučné písmo Kurzíva Obrázek 5.6: Button - styl SWT.TOGGLE Jen pro jistotu si ukážeme malý úryvek zdrojového kódu: // v podstatě jediným rozdílem je nastavení jiného // stylu v konstruktoru buttonl = new Button(shell, SWT.TOGGLE); buttonl.settext("červené písmo"); buttonl.setlayoutdata(gd); // použití posluchače je identické buttonl.addselectionlistener(new SelectionAdapter () { public void widgetselected(selectionevent e) { if (buttonl.getselection()) { label.setforeground(display.getsystemcolor( SWT.COLOR_RED)); else { label.setforeground(display.getsystemcolor( SWT.COLOR_BLACK)); 44

50 5.2. BUTTON A PRÁCE S POSLUCHAČI ); Ze zdrojového kódu je patrný smysl komponenty Button, kdy pouhou změnou stylu docílíme vytvoření opticky jiné komponenty, ale nejsme nuceni předělávat posluchače. Tyto vlastnosti si jistě při práci s SWT všichni oblíbí. Posledním stylem, který tato třída nabízí je SWT.ARROW. Jak již název napovídá, slouží k vytvoření tlačítka, jehož smyslem je zvyšování (snižování) nějaké hodnoty a jako popisek má na sobě implicitně šipku pro znázornění modifikace naší hodnoty. Je zřejmé, že v praxi budeme prakticky vždy potřebovat rovnou instance dvou tlačítek s tímto stylem, přičemž jedna bude sloužit pro zvyšování potřebné hodnty a druhá pro její snižování. Ve většině případů se jedná o komponentu, ke které je přidruženo textové pole, které obsahuje modifikovanou hodnotu. Při použití dvou tlačítek s tímto style vedle sebe se nám nabízí uspořádání buď nad sebou, nebo vedle sebe. K této specifikaci budeme využívat těchto stylů: SWT. UP, SWT. DOWN - pro zarovnání dvojice nad sebou. SWT. LEFT, SWT. RIGHT - zarovnání vedle sebe. Při nastavení těchto stylů si ovšem musíme dát pozor a nezaměnit je za například za styl SWT. ARROWJJP, který nepředstavuje kombinaci stylů SWT.ARROW a SWT. UP, jak by se mohlo z jeho názvu na první pohled zdát, ale představuje tlačítko "šipka nahoru" na klávesnici a tudíž s tlačítky této komponenty nemá nic společného. Dále je vhodné si uvědomit, že při použití tohoto stylu již nebudeme schopni specifikovat pro toto tlačítko vlastní popisek či obrázek. Princip práce s tímto stylem si samozřejmě ukážeme na příkladu. Vytvoříme okno s návěštím a dvě instance tlačítek se stylem SWT.ARROW budou modifikovat velikost fontu v návěští tak, jak ukazuje obrázek 5.7: SWT.ARROW Jfllxl»Ukázkový popisek v návěští < I t I SWT.ARROW ^Jnjxj Ukázkový popisek v návěští J J ^ Obrázek 5.7: Button - styl SWT.ARROW Postup je opět jednoduchý a ukážeme si jen malý úryvek: // vytvoříme tlačítko s požadovaným stylem buttonl = new Button(shell, SWT.ARROW SWT.LEFT) // práce s posluchačem je opět stejná buttonl.addselectionlistener(new SelectionAdapter O { public void widgetselected(selectionevent e) { fontdata = label.getfont().getfontdata(); 45

51 5.3. COMBO ); fontdata[0].setheight(fontdata[0].getheight() - 1); font = new Font(display, fontdata); label.setfont (font); Ze zdrojového kódu je zřejmé, že použití tohoto stylu není nikterak specifické a jeho chování je naprosto stejné, jako je tomu u standardních tlačítek. Opět nesmíme zapomenout uvolnit prostředky proměnné font. Tím jsme se dostali na závěr popisu komponenty Button, sniž se i nadále budeme velmi často setkávat. Nyní se postupně podíváme na další komponenty, které nám SWT nabízí. Jejich použití se víceméně odvíjí od komponent Label a Button, takže si je budeme prezentovat v poněkud stručnější formě, než tomu bylo doposud. 5.3 Combo Tato třída nám nabízí možnost pro vytvoření rozbalovacích nabídek, které slouží k výběru právě jedné z více možností, což nám ostatně umožňuje i komponenta Button s použitím stylu SWT. RAD I O. Používat systém přepínačů pro velké množství voleb je však nejen nepřehledné, ale také velmi prostorově náročné a tudíž se při větším množství voleb používají instance komponenty Combo (k rozbalení dochází po kliknutí a po výběru některé z možností se nabídka opět sbalí do původní velikosti). Svým charakterem nám jistě připomene komponenty JComboBox a ComboBox, které známe ze standardních javových prostředí a také TComboBox z jazyka Delphi. Podobně jako u komponenty Button budeme i zde zpracovávat události typu SelectionEvent pomocí posluchače SelectionListener, respektive příslušného adaptéru. Ke vzniku instance nabízí třída konstruktor: Combo (Composite parent, int style) -vytvoří instanci a umístí jiná zadaný panel (což je stejné jako u ostatních komponent). Dostupné styly jsou následující: - DROP_DOWN - standardní combobox, umožňující vložení vlastního textu. - READ_ONLY - zřejmě nejčastěji využívaný combobox, jehož hodnoty jsou jen pro čtení. - SIMPLE - zvláštní styl, při jehož použití dosáhneme neustále rozbalené nabídky bez možnosti jejího sbalení (z tohoto důvodu použití tohoto stylu poněkud postrádá v běžných situacích smysl). Z velkého množství metod si jmenujme alespoň následující: add (String string) - přidá zadanou položku do nabídky (respektive na její konec). add (String string, int index) - přidá položku na specifikovaný index. addselectionlistener (SelectionListener listener) - důležitá metoda pro přidání posluchače SelectionListener. 46

52 5.3. COMBO deselect (int index) - odznačí položku na zadaném indexu (je-li označena). String get Item (int index) - vrací položku na specifikovaném indexu. int get 11 emcount () - vrací celkový počet položek rozbalovací nabídky. String [ ] get Items () - vrací všechny položky dané nabídky (všimněme si typu návratové hodnoty). int getselectionlndex () - vrací index vybrané položky. int indexof (String string) - velmi užitečná metoda, která vrací index specifikované položky. Prohledávání probíhá od první položky (s indexem 0). int indexof (String string, int start) - dovoluje navíc provést optimalizaci pomocí specifikace startovního indexu. remove (int index) - odstraní položku na zadaném indexu. remove (int start, int end) - odstraní všechny položky ve specifikovaném rozmezí (včetně zadaných indexů). select (int index) - označí položku na zadaném indexu. setltems (String [ ] items) - nastaví zadané pole do nabídky. Pro základní práci si však vystačíme jen s několika málo metodami. V podstatě si vytvoříme pole, které obsahuje jednotlivé položky nabídky, dále vytvoříme instanci nabídky a nakonec do ní připravené pole vložíme. V posluchači (respektive v metodě, kterou budeme implementovat) budeme často využívat příkaz switch, který nám dobře poslouží k rozlišení, která položka byla vybrána a následnému provedení požadované akce. K prezentaci práce s touto komponentou si vytvoříme příklad s návěštím a dvěmi rozbalovacími nabídkami, z nichž jedna bude měnit barvu písma v návěští a druhá barvu pozadí tak, jak ukazuje obrázek 5.8:! ComboDemo [ ComboDemo Ukázkový popisek v návěští Ukázkový popisek v návěští [Červené písmo ^J Ižluté pozadí ^J Modré písmo " j U m i m i l * Obrázek 5.8: Combo - změna vlastností návěští Postup ukazuje následující zdrojový kód: // nejprve si vytvoříme potřebná pole final String itemscombol[] = {"Červené písmo", "Zelené písmo", "Žluté písmo", "Modré písmo", "Černé písmo"; final String itemscombo2[] = {"Žluté pozadí", "Zelené pozadí", "Modré pozadí", "Šedé pozadí"; 47

53 5.4. LIST // vytvoříme si první instanci comboboxu combol = new Combo(shell, SWT.READ_ONLY); // a přidáme do ní připravené pole combol.setitems(itemscombol); combol.select(4) ; combol.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { switch (combol.getselectionlndex()) { case 0: label.setforeground( display.getsystemcolor( SWT.COLOR_RED)); break; case 1: label.setforeground( display.getsystemcolor( SWT.COLOR_GREEN)); break; ); // podobně pokračujeme u druhé instance combo2 = new Combo(shell, SWT.READ_ONLY); combo2.setitems(itemscombo2); combo2.select(3) ; combo2.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { switch (combo2.getselectionlndex()) { ); Když se podíváme na zdrojový kód, můžeme si všimnout jisté podobnosti s komponentou But t on, především díky použití stejného posluchače. Vskutku se dá považovat za velký klad SWT, který ocení hlavně začátečníci, že práce s jednotlivými základními komponentami je navzájem podobná. Výběry z nabídek možností zakončíme v následující sekci, kde se podíváme na práci se seznamy. 5.4 List Tato třída nám představuje komponentu pro tvorbu seznamů. Svým vzhledem nám může připomenout komponentu Combo s použitím stylu SWT. SIMPLE, kterou jsme si popsali v minulé sekci a jedná se v podstatě o ekvivalentní komponentu s třídami List (AWT), JList (Swing) a TListBox (Delphi). Možná je až s podivem, že se přímo 48

54 5.4. LIST nejedná o styl třídy Combo, neboť jak jsme mohli vidět u třídy Button, komponenty SWT jsou pomocí stylů velmi jednoduše modifikovatelné. Díky své prostorové náročnosti (kterou je ovšem možno alespoň částečně zredukovat přidáním posouvací lišty) je v praxi poměrně málo využívána a proto je velmi často nahrazována klasickými rozbalovacími nabídkami, jejichž vytváření nám umožňuje třída Combo. K využití se nám tato komponenta bude hodit jen v případě, kdy po nabídce požadujeme, abychom mohli zvolit rovnou několik možností, které obsahuje. Jako tomu bylo u předchozích komponent, také instance této třídy generují události typu Select i onevent a pro jejich zpracování budeme nejčastěji využívat adaptéru Select ionadapter. Pro vznik instance budeme používat konstruktor: List (Composite parent, int style) - vytvoří instanci a smysl parametru parent je opět stejný. Možné styly tentokrát neslouží jako nějaké vizuální modifikace, ale jedná se o modifikace chování komponenty: - S INGLE - seznam, umožňující vybrání pouze jedné položky. - MULTI - umožňuje vybrat několik položek z dostupné nabídky. Standardně se výběr více položek provádí prostřednictvím tlačítka Ctrl. Z obecných stylů budeme ještě velmi často využívat SWT. BORDER pro ohraničení (nebo chcete-li rámeček) seznamu a také se nám bude často hodit styl pro přidání posouvací lišty SWT. V_SCROLL, který nám pomůže ušetřit v případě potřeby místo v zobrazeném okně. Metody, které nám třída nabízí jsou v podstatě stejné, jako u třídy Combo. Zmíníme si alespoň následující: add (String string, int index) - přidá položku pod specifikovaným názvem na zadaný index v seznamu. String [] getselection () -vrací seznam vybraných položek seznamu, který je obsažen v poli. setselection (int [ ] indices) - provede vybrání zadaných položek (prostřednictvím pole indexů) v seznamu. Spousta ostatních metod má identické názvy i použití jako je tomu u třídy Combo (například metody na zjištění vybrané položky, (od)označení položky atd.), takže zde pro ně nebudeme plýtvat místem. Jako ukázkový příklad si tentokrát vytvoříme okno se seznamem a návěštím. Volby seznamu budou modifikovat barvu písma. Výsledek ukazuje obrázek 5.9: Postup je opět velmi podobný: Obrázek 5.9: List - výběr z možností 49

55 5.4. LIST // nejprve si opět vytvoříme pole možností final String itemslistl[] = {"Černé písmo", "Zelené písmo", "Modré písmo", "Červené písmo"; // při vytváření instance použijeme i styl pro rámeček listi = new List(shell, SWT.SINGLE SWT.BORDER); // přidáme položky do seznamu listi.setitems(itemslistl); // nastavíme implicitní volbu listi.select(0); // a nakonec standardně přidáme posluchače listi.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { switch (listi.getselectionlndex()) { case 0: label.setforeground( display.getsystemcolor( SWT.COLOR_BLACK)); break; ); Vzhledem k tomu, že práce s jednotlivými komponentami pro výběr právě jedné či několika z dostupných možností je v podstatě stejná, záleží tedy na konkrétní situaci, kterou z nich použijeme. Nyní ukončíme prohlídku nejzákladnějších komponent SWT a přejdeme ke dvojici tříd, která nám umožní pracovat s textem. Spoustu dalších příkladů použití základních komponent SWT lze nalézt na webových stránkách, které se SWT zabývají. Jedná se především o ukázkové příklady na serveru Java2s [Examples] a také na domovských stránkách SWT [Snippets]. 50

56 Kapitola 6 Textové komponenty V této kapitole se postupně podíváme na skupinu tříd balíku SWT, které nám poskytují komplexní nástroje pro tvorbu textových polí a textových oblastí. Seznámíme se s některými dalšími důležitými posluchači a ukážeme si základní práci se stylizovaným textem. Obě komponenty, které si postupně předvedeme jen reflektují velkou modifikovatelnost tříd SWT, neboť pomocí nastavení stylů opět dosáhneme zcela rozdílného chování a tudíž budou představovat ekvivalenty hned několika tříd ze standardních javovských prostředí. 6.1 Text Pod tímto název se skrývá třída, umožňující všechny základní operace s neštylizovaným textem. Slovo "všechny" jsme si uvedli zcela záměrně, neboť stejně jako tomu bylo u komponenty Button, i zde se v podstatě jedná (z pohledu dřívějšího uživatele standardních javovských prostředí) o několik komponent v jedné. Přesněji, nastavením dostupných stylů dosáhneme chování textového pole (jtextfield v balíku Swing či TEdit v Delphi), pole pro zadávání hesla (jpasswordfield) a v případě potřeby také textové oblasti (JTextArea, případně TMemo v Delphi). Nejjednodušší styl je zmiňované textové pole, které většinou slouží k zadávání hodnot uživatelem. Toto pole můžeme jednoduše změnit na pole pro zadávání hesla, které se liší tím, že namísto vstupního textu zobrazuje předem definované znaky. Textovou oblast použijeme v různých situacích, kdy například potřebujeme zobrazovat soubory uložené na disku, či případně potřebujeme uživateli umožnit víceřádkový vstup z klávesnice. Jak si postupně ukážeme, práce s touto komponento je jednoduchá a velmi intuitivní. Pro práci s touto komponentu budeme již používat také jiné posluchače, než tomu bylo doposud. Nejčastěji se pro základní účely budeme setkávat s posluchači KeyListener (vhodný zvláště pro zjištění a následnou reakci na stisk tlačítka) a Modif ylistener (zpracování událostí, které se generují při modifikaci komponenty). Ke vzniku instance třída nabízí opět jediný konstruktor: Text (Composite parent, int style) - vytvoří instanci třídy Text amožné užitečné styly jsou následující (opět je možné kombinovat jen některé, navzájem nevýlučné styly): - CENTER - zarovnání textu, obsaženého v komponentě na střed. - LEFT - zarovnání vlevo. - RIGHT - zarovnání vpravo. - S INGLE - standardní jednořádkové textové pole pro jednoduchý vstup hodnot. 51

57 MUL T i - víceřádková textová oblast. - PAS SWORD - vstupní textové pole pro zadávání hesla TEXT - READ_ONLY - nastaví pole pouze pro čtení (čímž dosáhneme zvláště v kombinaci se stylem SINGLE v podstatě obdobného chování, jako při použití třídy Label). - WRAP - umožňuje nastavit zalamovaní řádků textu, který je v komponentě obsažen. Zvláště v případě jednořádkových polí budeme dále využívat styl SWT. BORDER. Dostupných metod je celá řada, ale my si ukážeme alespoň následující: addkeylistener (KeyListener listener) - provede registraci specifikovaného posluchače KeyListener (opět budeme s výhodou využívat také adaptéru KeyAdapter). addmodifylistener (ModifyListener listener) - slouží k přidání posluchače Modif ylistener. append (String string) - připojí zadaný text k textu, který je již v komponentě obsažen. Pro jistotu si připomeňme, že pro odskok na nový řádek v textové oblasti budeme využívat znak "\n". copy () - zkopíruje vybraný text do schránky. Velmi užitečná metoda, která představuje úplný základ každého textového editoru. cut () - vyřízne text do schránky a umožňuje následné vložení na jiné místo. int getcaretposition () - vrací pozici kurzoru relativně vůči počátku. Přesněji řečeno, vrací počet znaků od počátku dokumentu k pozici kurzoru. int getcharcount () - vrací celkový počet znaků v komponentě. Užitečné zvláště v případě, kdy potřebujeme procházet jednotlivé znaky (slova) v celém dokumentu pomocí cyklu. char getechochar () - metoda, která se používá jen u stylu SWT. PASSWORD, a vrací znak, který zobrazuje v komponentě místo uživatelem zadávaného hesla. int getlinecount () - užitečná metoda, která vrací počet řádek textu. Smysl má ovšem především v případě, že máme nastaveno zalamování řádků v komponentě (styl SWT. WRAP). String getselectiontext () - metoda, která vrací vybranou část textu (například část označenou uživatelem pomocí myši). String gettext () - vrací celý text, obsažený v komponentě. String gettext (int start, int end) - navíc umožňuje specifikovat požadované rozmezí a jedná se o velmi užitečnou metodu. paste () - metoda, sloužící ke vložení obsahu schránky (který je zde uložen pomocí metod copy () nebo cut ()) do textu. 52

58 6.1. TEXT selectall () - označí celý text, obsažený v komponentě. Přestože se nastavováním zkratek budeme zabývat až v následujících kapitolách, tak si uveďme, že se v tomto případě jedná o zkratku Ctrl+A. setechochar (char echo) -slouží k nastavení znaku pro styl SWT.PASSWORD. seteditable (boolean editable) - umožňuje znemožnit uživatelský zásah do komponenty pomocí zadání hodnoty false. Užitečné v případě, kdy například po textové oblasti chceme, aby sloužila jen jako výstup informací a uživatel do ní nemohl sám zapisovat. setfont (Font font) - nastaví zadaný font pro celou komponentu (respektive pro text, který je v ní obsažen). setselection (int start, int end) - programově označí text ve specifikovaném rozmezí. settext (String string) -vloží text do komponenty. Pokud je v ní již nějaký text obsažen, je smazán a nahrazen novým. Tato metoda je užitečná i v případě, kdy chceme text v komponentě obsažený vymazat, čehož docílíme jednoduchým zadání prázdného řetězce jako parametru. K prezentaci si vytvoříme ukázkový příklad tak, že si na něm ukážeme všechny dostupné základní styly zároveň. Nejprve se podívejme na obrázek 6.1: Obrázek 6.1: Text - použití různých stylů Jak nám ukazuje obrázek, v okně bude jedno textové pole a k němu příslušné tlačítko a podobná dvojice pro zadávání hesla. Textová oblast bude sloužit pro zobrazování zadaných hodnot a při stisku příslušného tlačítka se do ní vloží obsah daného pole. Navíc budeme požadovat, aby obě pole reagovaly na tlačítko Enter a po jeho stisku provedly stejnou akci, jaká se provede po stisku tlačítka (čímž budeme prezentovat použití pro nás nového posluchače KeyListener). Jen pro ilustraci si navíc změníme znak, který se bude zobrazovat místo hesla. Postup není nijak složitý a ukazuje jej zdrojový kód (ve kterém je opět z prostorových důvodů vynechána především práce s manažery rozmístění komponent): Label labell = new Label(controlPane, SWT.CENTER); labell.settext("textové pole: "); labell.setforeground(display.getsystemcolor(swt.color_red)) ; 53

59 // vytvoříme si textové pole tf = new Text(controlPane, SWT.SINGLE SWT.BORDER SWT.CENTER); // posluchač pro rozlišení tlačítka Enter tf.addkeylistener(new KeyAdapter() { public void keypressed(keyevent e) { if ((e.keycode == SWT.CR) (e.keycode == SWT.KEYPAD_CR)) { // text připojíme do textové oblasti ta.append("byla zadána hodnota: " + ); // a pole vymažeme tf.settext(""); tf.gettext() + "\n"); // tlačítko pro odeslání hodnoty buttonl = new Button (controlpane, SWT.PUSH); buttonl.settext("odeslat hodnotu"); buttonl.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { // podobně jako v předchozím případě ta.append("byla zadána hodnota: " + tf.gettext() + "\n"); ); tf.settext(""); 6.1. TEXT Label label2 = new Label(controlPane, SWT.CENTER); label2.settext("zadávání hesla: "); label2.setforeground(display.getsystemcolor(swt.color_red)) ; // vytvoříme si pole pro zadávání hesla pw = new Text (controlpane, SWT.PASSWORD SWT.BORDER SWT.CENTER); pw.addkeylistener(new KeyAdapter() { public void keypressed(keyevent e) { if ((e.keycode == SWT.CR) (e.keycode == SWT.KEYPAD_CR)) { ta.append("byla zadáno heslo: " + pw.gettext() + "\n"); pw.settext(""); ); // tady si nastavíme znak v poli pro zadávání hesla pw.setechochar('+'); 54

60 6.1. TEXT // podobně si vytvoříme příslušné tlačítko button2 = new Button (controlpane, SWT.PUSH); button2.settext("odeslat heslo"); button2.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { ta.append("bylo zadáno heslo: " + pw.gettexto + "\n") ; pw.settext(""); ); // a nakonec vytvoříme textovou oblast pro // zobrazování výsledků ta = new Text (shell, SWT.MULTI SWT.BORDER SWT.V_SCROLL) ; Ve výše zmíněném kódu si všimněme hned několika zajímavých a důležitých věcí: V podstatě vždy budeme v konstruktorech textových polí používat spolu s ostatními i styl SWT. BORDER pro zobrazení rámečku kolem komponenty. Posluchač KeyListener je v podstatě obdobou stejnojmenné třídy v balíku Swing. Navíc s výhodou opět využíváme adaptéru, neboťpotřebujeme pro naše účely implementovat pouze metodu keypressed (KeyEvent e). Aby bylo zamezeno problémům, existují v SWT dvě konstanty pro tlačítka Enter, SWT. CR pro standardní Enter a SWT. KEYPAD_CR pro Enter na numerické části klávesnice. V případě potřeby můžeme jednoduše přidat posouvací lištu pomocí zadání stylu SWT. V_SCROLL přímo v konstruktoru a samozřejmě také odpovídající styl pro horizontální posuvník. Styl SWT. WRAP je velmi důležitý, neboť implicitně je zalamování řádků vypnuto. Přestože jsme si na to zatím neupozornili, naším příkladem jsme zároveň vytvořili také popup menu (zobrazující se stisku pravého tlačítka myši) pro všechny tři instance třídy Text. Tuto vlastnost můžeme považovat za velmi užitečnou, protože tato implicitně vytvořená nabídka obsahuje v podstatě všechny základní nástroje pro práci s textem. Implicitní nabídku z našeho příkladu ukazuje obrázek 6.2. Pokud bychom chtěli změnit font (případně jeho styl či velikost) v této komponentě, zjistíme, že toto nastavení můžeme provést pouze globálně pro celý text, který je v ní obsažen (podobně jako třeba u komponenty Label). Důvodem je skutečnost, že tato komponenta nedovoluje kombinaci různých stylů a tím tvorbu stylizovaného textu. Nicméně, podobně jako ostatní komponenty SWT nám pomocí stylů jednoduše nahrazuje rovnou tři třídy z balíku Swing a navíc nám automaticky vytváří jednoduché popup menu. Komponentou pro práci se stylizovaným textem se budeme zabývat hned vzápětí, v následující sekci a vytvoříme si jejím prostřednictvím jednoduchý textový editor jako ukázkový příklad. 55

61 6.2. STYLEDTEXT Vybrat vše Obrázek 6.2: Text - implicitní popup menu 6.2 StyledText Nyní jsme se dostali ke komponentě, která nám (jak ostatně její název napovídá) umožňuje pracovat se stylizovaným textem a provádět s ním nejrůznější operace. Například nám tedy umožňuje jednoduše nastavovat styly a velikosti fontů označeného textu, používat různé barvy písma pro části textu, který je v ní obsažen atd. Svým chováním tedy připomíná třídy JTextPane z balíku Swing a také TRichEdit z Delphi. V balíku AWT se žádná podobná komponenta nenachází. Svými dovednostmi tedy představuje základní stavební kámen textového editoru a jak si ukážeme, práce s ní je mnohem jednodušší a více intuitivní než tomu je u jejího ekvivalentu v balíku Swing. Vzhledem k tomu, že se svým způsobem jedná o speciální komponentu, nachází se v balíku org.eclipse.swt.custom. Instanci budeme vytvářet konstruktorem: StyledText (Composite parent, int style) -dostupné styly j sou následující: - FULL_SELECT I ON- tento styl se projeví pouze při označení textu, obsaženého v komponentě a způsobí označení celých řádků i v případě, kdy je text v tomto řádku kratší a nedosahuje až do pravého okraje komponenty. MUL TI - podobně, jako tomu bylo u komponenty Text, slouží tento styl k vytvoření víceřádkové textové oblasti a v praxi jej budeme používat v podstatě vždy. - READ_ONL Y - znemožní uživatelskou editaci textu, který bude v komponentě obsažen. - S INGLE - slouží k vytvoření jednořádkového textového pole. - WRAP - zalamování řádků textu. Metod nabízí třída velkou spoustu, z nichž je většina jak názvem, tak funkcionalitou stejná jako tomu je u komponenty Text, takže si zmíníme alespoň následující metody, které budeme potřebovat využívat pro práci se stylizovaným textem: int getlineatof f set (int offset) - vrací číslo řádku, který obsahuje zadaný n-tý znak od počátku dokumentu. Color getlinebackground (int index) - vrací barvu pozadí celého specifikovaného řádku. 56

62 6.2. STYLEDTEXT int getof f setatline (int line Index) -vrací index prvního znaku na zadaném řádku. Point get Select ion () - vrací indexy rozsahu vybraného textu. Všimněme si, že přestože se jedná o metodu se stejným názvem, jako u komponenty Text, nevrací tato metoda řetězec výběru typu String, nýbrž jeho index typu Point. Například tedy vyber. x nám ukazuje index začátku výběru a vyber. y index jeho konce. Color get Select ionbackground () - vrací barvu pozadí výběru. Color getselectionforeground () - slouží ke zjištění barvy popředí (respektive písma) výběru. String getselectiontext () - obdoba metody getselection () u komponenty Text, sloužící k vrácení textu, obsaženého ve výběru. StyleRange getstylerangeatof f set (int offset) - velmi důležitá metoda, která nám vrací styl (typu StyleRange), aplikovaný v místě zadaného parametru offset. Například je tato metoda zcela nezbytná, budeme-li vytvářet tlačítka pro nastavování a také vypínání jednotlivých stylů písma (tučné písmo, kurzíva,...), jak si ukážeme na příkladě v závěru této sekce. StyleRange [ ] getstyleranges (int start, int len) - vrací všechny styly, aplikované v komponentě v zadaném rozsahu. Tuto metodu je možné použít i bez zadání indexu rozsahu a obdržíme tím všechny styly, které jsou aplikovány na celý dokument. replacestyleranges(int st, int length, StyleRange[] ranges)- zcela nezbytná metoda pro změnu stylů ve specifikovaném rozsahu. Jednotlivé styly totiž není možné aplikovat "přes sebe", čímž bychom docílili nefunkčnosti aplikace. Tato metoda tedy provede potřebnou náhradu a všimněme si, že není možné zadat jediný styl, ale pro naše účely musíme vždy vytvořit pole. setselectionbackground (Color color) -jednoduché nastavení barvy pozadí výběru. setselectionforeground (Color color) - nastavení barvy písma označeného textu. setstylerange (StyleRange range) - nastaví specifikovaný styl pro naši komponentu. setstyleranges (StyleRange [ ] ranges) - umožňuje zadat více stylů prostřednictvím pole. Přestože jsme si vybrali jen několik zcela základních metod, je zřejmé, že chybí metody na nastavování nejrůznějších parametrů výběru. Tato komponenta však takové metody neobsahuje a budeme muset použít její "pomocnou" třídu StyleRange, jejímž prostřednictvím budeme nastavovat jednotlivé styly (tento postup v podstatě reflektuje práci s komponentou JTextPane v balíku Swing). Vytvořený styl (instanci třídy StyleRange) pak jednoduše aplikujeme (případně nahradíme dříve aplikovaný styl) na náš vybraný text. Třída nabízí pro vznik instance (pro balík SWT možná trochu atypicky) rovnou tři konstruktory: 57

63 6.2. STYLEDTEXT StyleRange O - vytvoří novou instanci stylů. Nastavování všech parametrů budeme v tomto případě provádět postupně, specifikací jednotlivých vlastností této třídy. StyleRange(int st, int length, Color fore, Color back) - rovnou nám umožňuje specifikovat rozmezí textu, na které bude styl aplikován a také barvu textu a pozadí (v případě, kdy nechceme žádnou barvu specifikovat, zadáme hodnotu null). StyleRange (int s, int 1, Color f, Color b, int style) -oproti předchozímu konstruktoru můžeme navíc zadat požadovaný styl (podobně jako u konstruktorů jednotlivých komponent můžeme i zde zadávat více stylů najednou, oddělených standardním oddělovačem). Pro specifikace požadovaných stylů budeme přistupovat k následujícím vlastnostem této třídy: background - barva pozadí textu. font Style - styl fontu textu. Možné hodnoty jsou SWT. NORMAL (bez stylu), SWT. BOLD (tučné písmo) a SWT. ITALIC (kurzíva). foreground - barva písma textu. length - délka rozsahu textu, na který bude styl aplikován (například hodnota 10 znamená aplikaci na deset následujících znaků od startovní pozice, která je zadána v hodnotě start). start - startovní pozice, od které bude styl aplikován. Její hodnota se zadává stejným způsobem jako specifikace offsetu (tj. relativní pozice znaku od počátku dokumentu). strikeout - nastavení přeškrtnutí textu (zadáním hodnoty true). underline - podtržení textu (opět zadáním hodnoty true). Abychom si ukázali, jak nastavování různých stylů pracuje v praxi, vytvoříme si velmi jednoduchý editor, který sice bude zvládat jen nejzákladnější funkce, ale k prezentaci práce s výše uvedenými třídami bude ideální. Pro jednoduchost si tedy vytvoříme editor, umožňující jen nastavování tučného písma, kurzívy a podtržení textu tak, jak ukazují obrázky 6.3 a 6.4. Postup nám ukazuje vskutku intuitivní práci s touto komponentou: // nejprve si vytvoříme instanci a všimněme si // použitých stylů styledtext = new StyledText(shell, SWT.MULTI SWT.WRAP SWT.BORDER SWT.V_SCROLL); // zde si nastavíme iniciální text styledtext.settext("tučné písmo\nkurzíva\npodtržené písmo XnČervené tučné písmo"); 58

64 6.2. STYLEDTEXT // nyní si vytvoříme styl pro první řádek StyleRange stylerange = new StyleRange(); // začátek rozsahu stylerange.start = 0; // délka rozsahu stylerange.length = 11; // nastavení tučného písma v rozsahu stylerange.fontstyle = SWT.BOLD; // a nakonec aplikujeme styl styledtext.setstylerange(stylerange); // podobně pro druhý řádek stylerange = new StyleRange(); // zde si zjistíme offset prvního znaku druhého řádku stylerange.start = styledtext.getoffsetatline(1); stylerange.length = 7; stylerange.fontstyle = SWT.ITALIC; styledtext.setstylerange(stylerange); // podobně dokončíme zbývající dva řádky // nyní si vytvoříme tlačítko pro nastavování tučného stylu bold = new Button(buttonPane, SWT.NONE); bold.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { // nejprve si zjistíme styl, použitý v~našem výběru StyleRange oldsr = styledtext.getstylerangeatoffset( styledtext.getselection().x + 1); StyleRange sr = new StyleRange(); // jako počátek si nastavíme počátek výběru sr.start = styledtext.getselection().x; // a jako délku rozdíl konce výběru a počátku sr.length = styledtext.getselection().y - sr.start; // do nového stylu převezmeme vlastnosti původního stylu sr.foreground = oldsr.foreground; sr.underline = oldsr.underline; // a nyní jednoduše provedeme nastavení tučného stylu, // případně jeho zrušení if (oldsr.fontstyle == (SWT.BOLD SWT.ITALIC)) { sr.fontstyle = SWT.ITALIC; else { if (oldsr.fontstyle == SWT.BOLD) { sr.fontstyle = SWT.NORMAL; else { 59

65 if (oldsr.fontstyle == SWT.ITALIC) { sr.fontstyle = SWT.ITALIC SWT.BOLD; else { sr.fontstyle = SWT.BOLD; 6.2. STYLEDTEXT // nyní nahradíme původní styl novým StyleRange[] newsr = new StyleRange[1]; newsr[0] = sr; styledtext.replacestyleranges( sr.start, sr.length, newsr); ); bold. settext ("Bolď StyledTeHtDemo ^JnJiiJ Bold 1 Italic! Underline fučné písmo uľzíva Zervené tučné písmo odtržené písmo ; Obrázek 6.3: StyledText - původní nastavení StyledTeHtDemo LOl_x Bold Italic Underline Tuč/ie ptsmo Kurzíva j^od tržené písmo Červené tučné písmo Obrázek 6.4: StyledText - nastavení různých stylů Použití metody pro nahrazování styluje ve výše uvedeném příkladě zcela nezbytné, neboť styly není možné aplikovat "přes sebe". Z výše uvedeného kódu je patrné, že práce s touto komponentou je jednoduchá, stejně jako používání třídy StyleRange, jejímž prostřednictvím si vymezíme požadovaný rozsah a nastavíme styly. Právě díky těmto vlastnostem je práce s touto komponentou jednodušší a svým způsobem také 60

66 6.2. STYLEDTEXT přehlednější, než je tomu u třídy JText P ane v balíku Swing. Na rozdíl od komponenty Text zde však nenajdeme žádné implicitní pop-up menu a tudíž si jej v případě potřeby budeme muset vytvořit. Tím se dostáváme k závěru této kapitoly a v následující kapitole se podíváme na třídy, které nám umožní vytvářet programová menu, tlačítkové lišty a menu, zobrazující se po stisku pravého tlačítka myši (pop-up menu) na komponentě (s tímto menu jsme se setkali u komponenty Text, kde bylo ovšem vytvořeno implicitně bez našeho zásahu). 61

67 Kapitola 7 Tvorba menu a tlačítkových lišt Programové menu a tlačítkové lišty, které jsou pod ním umístěné, tvoří nedílnou součást každé dnešní aplikace a tudíž nalezneme všechny potřebné třídy pro jeho tvorbu i v balíku SWT. V této kapitole si tyto třídy postupně ukážeme a především si ukážeme princip tvorby menu, který je poněkud odlišný od standardních javových prostředí a proto si na jednotlivé rozdíly upozorníme. Prakticky si princip vytváření menu můžeme rozdělit do následujících dílčích kroků: vytvoření lišty pro menu (třída Menu) - základní stavební prvek, stejně jako v balících Swing a AWT. vytvoření menu nejvyšší úrovně (třída Menu I tem) - například položky File, Edit atd. inicializace "rozbalovacího" menu (třída Menu) a jeho připojení k menu nejvyšší úrovně. tvorba jednotlivých položek menu (třída Menu I tem) a jejich přiřazování do rozbalovacího menu. V jednotlivých krocích musíme používat předem určené styly jednotlivých tříd (nastavení se opět provádí v konstruktoru) a proto se v následujících sekcích této kapitoly na jednotlivé možnosti blíže podíváme. Dále se v této kapitole podíváme na nastavování klávesových zkratek pro jednotlivé položky menu. 7.1 Menu - lišta a rozbalovací nabídky Instance této třídy nám budou sloužit jednak pro vytvoření lišty, na které bude menu v okně umístěno a také pro vytvoření jednotlivých rozbalovacích nabídek, které se zobrazí při stisku menu nejvyšší úrovně. Tyto nabídky jsou pochopitelně implicitně prázdné a budeme je plnit jednotlivými instancemi třídy Menu I tem, které budou představovat položky menu. Pro vznik instance budeme využívat konstruktor: Menu (Decorations parent, int style) - prvním parametrem bude ve většině případů instance třídy Shell (a to i v případě, kdy budeme vytvářet submenu některé z položek) a důležité styly jsou následující: - BAR - styl pro vytvoření lišty pro menu. - DROP_DOWN - nezbytný styl pro vytvoření rozbalovací nabídky, která bude připojena k vytvořené instanci třídy Menultem se stylem CASCADE, představující menu nejvyšší úrovně. 62

68 72. MENUITEM - POLOŽKY MENU A NASTAVOVÁNÍ ZKRATEK - POPJJP - styl pro vytvoření pop-up menu. Z dostupných metod této třídy si zmíníme následující: Menultem getltem (int index) - vrací položku menu na specifikovaném indexu. int get 11 emcount () - užitečná metoda ke zjištění počtu položek menu. Menultem [] get Items () - vrací všechny položky menu prostřednictvím pole. Menu getparentmenu () - slouží k vrácení rodičovského menu. She 11 get She 11 () - užitečná metoda ke zjištění instance třídy She 11, ke které dané menu přísluší a její využití oceníme v případě víceokenních aplikací. Po vytvoření lišty ji samozřejmě nesmíme zapomenout do našeho okna přidat, protože nastavení instance třídy Shell v konstruktoru v tomto případě neslouží k automatickému přidání na tuto komponentu, jak je tomu u většiny ostatních tříd v SWT. Takže například podobně jako v balíku Swing musíme využít metodu pro přidání lišty, tj.: shell.setmenubar(bar) ; Smyslem této třídy je tedy připravit pomyslnou "konstrukci" (všimněme si, že tato třída nemá metodu set Text ()) do které budeme následně umísťovat položky, na které se podíváme v následující sekci. Narozdíl od balíku Swing tedy například položka "File" není instancí třídy Menu, ale jedná se o komponentu Menultem s nastavením speciálního stylu pro menu nejvyšší úrovně. Ukázkový příklad si budeme prezentovat až v následující sekci, neboť vytvoření prázdných nabídek by nebylo v této fázi nijak ilustrativní. 7.2 Menultem - položky menu a nastavování zkratek Tato třída představuje jednotlivé položky menu a jak si ukážeme, můžeme na ni nahlížet v podstatě stejně, jako na třídu Button. Podobně jako standardní tlačítka, i tato třída generuje při stisku události typu SelectionEvent (při použití libovolného stylu třídy) a pro jejich obsluhu budeme využívat posluchače SelectionListener (případně pro zjednodušení odpovídající adaptér). Tím však podobnost nekončí, neboť podobně jako u komponenty Button budeme i zde jednoduše vytvářet zaškrtávací položky menu pro nastavování nejrůznějších vlastností a také skupiny položek pro výběr právě jedné z více možností. Tato nastavení chování komponenty budeme opět provádět prostřednictvím dostupných stylů, které mají navíc identická jména jako styly, které jsme používali u třídy Button. Instanci budeme vytvářet následujícími konstruktory: Menultem (Menu parent, int style) - prvním parametrem je rodičovské menu, tj. pro menu nejvyšší úrovně se jedná o instance třídy Menu se stylem SWT. BAR. Dostupné styly umožňují nastavit položku přesně podle našich představ: 63

69 72. MENUITEM - POLOŽKY MENU A NASTAVOVÁNÍ ZKRATEK - CHECK - styl pro vytvoření zaškrtávacího políčka v menu, které pracuje jako dvoustavový přepínač a jeho využití je stejné jako u třídy Button. Například si tedy můžeme představit položku pro nastavení tučného písma textu. - CASCADE - důležitý styl pro vytvoření položky menu nejvyšší úrovně a také rodičovského menu, které obsahuje jakou svou položku nějaké další menu. Pro dosažení funkčnosti je nutné vytvořit a připojit (pomocí metody setmenu ()) instanci třídy Menu se stylem DROP_DOWN, do které je následně možné umístit potřebné položky. Typicky se tedy bude jednat o položky Soubor, Zobrazit atd. a také například položku Písmo, která v sobě obsahuje menu pro nastavování parametrů písma. - PUSH - standardní položka menu, která po svém stisku provede akci definovanou v posluchači. Takovou položkou je například Konec, po jejímž stisku dojde k ukončení programu. - RAD 10 - položky pro výběr právě jedné z více možností. Podobně jako u třídy Button se nepoužívá žádná sdružující třída, jako tomu je v balíku Swing, ale sdružení je provedeno automaticky pro celé menu a tím samozřejmě také mechanismus, kdy je vybrána právě jedna instance. SEPARATOR - podobně, jako tomu bylo u komponenty Label (u které ovšem tento styl využijeme jen velmi zřídka) dovoluje vytvoření oddělovací čáry. Tato čára se v menu používá pro oddělení logicky souvisejících položek pro dosažení větší přehlednosti. Menultem (Menu parent, int style, int index) - oproti předchozímu konstruktoru dovoluje navíc nastavit pozici položky v menu, neboť implicitně je prováděno řazení tak, že nově přidaná položka se objeví v dolní části menu (s nejvyšším indexem). Podobně jako je tomu například u typu pole (Array), i zde probíhá indexace od nuly. Následující metody nám umožní základní práci s touto komponentou: addselectionlistener (SelectionListener listener) -nezbytnámetoda pro přidání posluchače. int getaccelerator () - vrací klávesovou zkratku pro danou položku. Menu getmenu () - vrací instanci třídy Menu, která naši položku obsahuje. V případě, kdy žádná taková instance neexistuje, vrací tato metoda null. boolean getselection () - podobně jako u třídy Button má smysl pouze při použití stylů CHECK a RAD 10 a vrací je-li přepínač zaškrtnut (t rue), nebo není (false). void setaccelerator (int accelerator) - slouží k nastavení klávesové zkratky. Na samotný princip a možné parametry se podíváme dále v této sekci. set Image (Image image) - umožňuje nastavení obrázku pro danou položku menu. setmenu (Menu menu) - důležitá metoda k nastavení instance třídy Menu pro položku se stylem CASCADE. 64

70 72. MENUITEM - POLOŽKY MENU A NASTAVOVÁNÍ ZKRATEK setselection (boolean selected) - provede programový výběr daného přepínače. settext (String string) - nastavení popisku položky. Velmi důležitou součástí menu jsou klávesové zkratky, které si můžeme rozdělit do následujících dvou skupin: Zkratky, jejichž pomocí procházíme menu bez použití myši po stisku klávesy Alt. K nastavení těchto zkratek není v SWT (narozdíl například od balíku Swing, kde bylo nutné použít metodu setmnemonic ()) zapotřebí žádná metoda a toto nastavení provedeme jednoduše umístěním znaku "&" před požadované písmeno v metodě settext () při zadávání názvu položky menu, tj. například: // nastavení zkratky na Alt + f file.settext("sfile"); Vizuální znázornění tohoto typu zkratek se výrazně liší podle platformy, na které naši aplikaci spouštíme. Podle operačního systému tedy můžeme očekávat zvýraznění daného písmene v položce kurzívou, podtržením a také jeho zvýraznění až po stisku klávesy Alt (stejné chování má i vývojové prostředí Eclipse, které je v SWT naprogramováno). Používání těchto zkratek sice není nikterak využíváno, ale z hlediska vývojářů se svým způsobem jedná o standard a proto musíme do našich aplikací tyto zkratky implementovat. Druhou skupinu tvoří velmi často využívané zkratky, které po stisku kombinace kláves vyvolají akci přidruženou k určité položce menu. Při nastavování těchto zkratek musíme brát v úvahu jisté obecné zvyklosti uživatelů a alespoň pro standardní akce definovat stejné zkratky, jako je tomu u jiných aplikací. Například tedy: - Ctrl + n - vytvoření nového dokumentu. - Ctrl + o - otevření existujícího dokumentu. - Ctrl + q - ukončení aplikace. Samotné nastavení zkratky pro položku menu provádíme prostřednictvím metody setaccelerator (int accelerator), přičemž možné parametry jsou tvořeny konstantami SWT.CTRL a SWT. SHIFT a nastavením zkratkového písmene. Například tedy: // nastavení zkratky na kombinaci kláves Ctrl + n newltem.setaccelerator(swt.ctrl + 'N'); // kombinace Shift + a item.setaccelerator(swt.shift + 'A'); Při zadávání zkratkového písmene si všimněme použitých uvozovek, protože se jedná o typ char. Použití operátoru sčítání je zcela v pořádku, neboť se jedná o ordinální typ a očekávaným vstupním parametrem je celé číslo typu int. Vzhledem k tomu, že třída Menu I tem neumožňuje zobrazení klávesové zkratky pro její aktivaci, jsme nuceni ji v případě potřeby zadat přímo do jejího názvu. Od názvu ji nejjednodušeji oddělíme tabelátorem, například tedy: 65

71 72. MENUITEM - POLOŽKY MENU A NASTAVOVÁNÍ ZKRATEK // zobrazení klávesové zkratky v názvu položky openfile.settext("sopen" + "\tctrl + 0"); Využívání těchto zkratek je natolik běžné (především z důvodu větší efektivity práce uživatele s aplikací), že je jejich zahrnutí do naší aplikace v podstatě stejně důležité, jako tvorba samotného menu. Nyní si tedy vytvoříme příklad, na kterém si postupně ukážeme tvorbu menu s položkami, o kterých jsme se zatím dozvěděli teoreticky. Vytvoříme si jednoduché okno aplikace s menu tak, jak ukazuje obrázek 7.1: Obrázek 7.1: Menu - tvorba položek V našem příkladě nebudeme vytvářet pro jednotlivé položky žádné akce, čehož bychom docílili jednoduchou implementací posluchačů SelectionListener. Postup nám ukazuje okomentovaný zdrojový kód: // nejprve si vytvoříme lištu Menu bar = new Menu(shell, SWT.BAR); // a nastavíme ji k použití v okně aplikace shell.setmenubar(bar); // vytvoříme si položku File a umístíme ji na lištu, // její použitý styl musí být CASCADE Menultem file = new Menultem(bar, SWT.CASCADE); // zde si nastavíme popisek a zkratku pro stisk klávesy Alt file.settext("&file"); // vytvoříme rozbalovací menu pro položku File, // použitý styl musí být DR0P_D0WN Menu filemenu = new Menu(shell, SWT.DR0P_D0WN); // připojíme menu k položce File file.setmenu(filemenu); // nyní můžeme naplnit menu položkami Menultem newltem = new Menultem(filemenu, SWT.PUSH); newltem.settext("new") ; // nastavení zkratky newltem.setaccelerator(swt.ctrl + 'N'); 66

72 7.2. MENUITEM - POLOŽKY MENU A NASTAVOVÁNÍ ZKRATEK Menultem openltem = new Menultem(filemenu, SWT.PUSH); openltem.settext("open") ; // přidání oddělovací čáry new Menultem(filemenu, SWT.SEPARATOR); Menultem exitltem = new Menultem(filemenu, SWT.PUSH); exitltem.settext("exit") ; // podobně postupujeme pro menu Text Menultem text = new Menultem(bar, SWT.CASCADE); text.settext("text"); Menu textmenu = new Menu(shell, SWT.DROP_DOWN); text.setmenu(textmenu); // pro vytvoření submenu je opět nutný styl CASCADE Menultem sizeltem = new Menultem(textmenu, SWT.CASCADE); sizeltem.settext("font Size"); // a podobně vytvoříme rozbalovací nabídku // a provedeme připojení Menu sizemenu = new Menu(shell, SWT.DROP_DOWN); sizeltem.setmenu(sizemenu); // pro výběr právě jedné z více možností použijeme // styl RADIO Menultem sizellltem = new Menultem(sizemenu, SWT.RADIO); sizellltem.setselection(true); sizellltem.settext("size 11"); Menultem sizel2ltem = new Menultem(sizemenu, SWT.RADIO); sizel2ltem.settext("size 12"); Menultem sizel3ltem = new Menultem(sizemenu, SWT.RADIO); sizel3ltem.settext("size 13"); new Menultem(textmenu, SWT.SEPARATOR); // a pro zaškrtávací políčka slouží styl CHECK Menultem boldltem = new Menultem(textmenu, SWT.CHECK); boldltem.setselection(true) ; boldltem.settext("bold") ; Menultem italicltem = new Menultem(textmenu, SWT.CHECK); italicltem.setselection(true); italicltem.settext("italic") ; Menultem underlineltem = new Menultem(textmenu, SWT.CHECK); 67

73 7.2. MENUITEM - POLOŽKY MENU A NASTAVOVÁNÍ ZKRATEK underlineltem.settext("underline") ; Všimněme si, že i v případě, kdy tvoříme submenu, zadáváme jako rodičovskou komponentu instanci třídy Shell. Dále se podívejme, jak jednoduše vytvoříme pop-up menu (zobrazující se ve většině operačních systémů po stisku pravého tlačítka myši). Naše ilustrační menu nám ukazuje obrázek 7.2: Obrázek 7.2: Menu - tvorba pop-up nabídky Postup je velmi jednoduchý (SWT narozdíl od balíku Swing provádí otevření a umístění menu automaticky): // vytvoříme si instanci s použitím stylu POP_UP Menu popup = new Menu(shell, SWT.POP_UP); // opět musíme nastavit menu pro naše okno shell.setmenu(popup); // a jednoduše do menu přidáme položky Menultem cutltem = new Menultem(popUp, SWT.PUSH); cutltem.settext("cut"); Menultem copyltem = new Menultem(popUp, SWT.PUSH); copyltem.settext("copy"); Menultem pasteltem = new Menultem(popUp, SWT.PUSH); pasteltem.settext("paste"); new Menultem(popUp, SWT.SEPARATOR); Menultem searchltem = new Menultem(popUp, SWT.PUSH); searchltem.settext("search"); Je vhodné si uvědomit, že použití stylu POP_UP nám vytvoří požadovanou konstrukci a pokud nepotřebujeme vytvářet submenu, jednoduše umísťujeme položky přímo do vytvořené instance. Pro určení, na kterých komponentách se má vytvořené menu zobrazovat slouží metoda setmenu () a v našem případě jsme toto menu nastavili pro celou instanci třídy Shell. Dále si ještě jednou připomeňme, že zajištění funkčnosti menu bychom provedli implementací metod posluchače Select ionlistener, případě odpovídajícího adaptéru. 68

74 7.3. TOOLBAR A TOOLITEM Používání pop-up menu je v dnešní době považováno za standardní součást každé aplikace, která opět jako klávesové zkratky zvyšuje efektivitu uživatelské práce s aplikací. 7.3 ToolBar a Toolltem Tato dvojice tříd představuje nástroj pro tvorbu tlačítkových lišt, které bývají umístěny přímo pod menu a obsahují na sobě tlačítka pro rychlý přístup k často využívaným položkám menu. Jak již jejich názvy napovídají, třída ToolBar představuje lištu a instance třídy Toolltem představují jednotlivé tlačítka, které na ni budeme umísťovat. Na rozdíl od balíku Swing a třídy JToolBar však lze tyto třídy použít "jen" pro lištu, obsahující tlačítka. Není tedy například možné přidat na tuto lištu instanci třídy Combo (což je velmi užitečné například pro výběr fontů písma při tvorbě textového editoru). Právě k těmto účelům slouží třída CoolBar, kterou si ukážeme v následující sekci. Za užitečnou vlastnost třídy Tool Item můžeme považovat skutečnost, že přestože se v podstatě jedná o podobnou komponentu, jakou je instance třídy Button, můžeme na ni umístit text i obrázek zároveň. Podobně jako spousta ostatních komponent v balíku SWT, generuje i tato třída události typu Select i onevent a tudíž budeme pro jejich zpracování nejčastěji využívat adaptér SelectionAdapter. Na rozdíl od standardních javových prostředí zde však nemáme k dispozici metodu, která by nastavila lištu pro naše okno a tudíž musíme nastavit její velikost a navíc, když je tato lišta v okně obsažena, chová se stejně jako ostatní komponenty a musíme s tím při návrhu počítat. Za ekvivalentní komponentu v jazyce Delphi můžeme považovat TToolBar (ovšem s tím, že tato komponenta nám navíc kromě tlačítek umožňuje například i vložení textového pole, tj. instance třídy TEdit). Pro vznik instance třídy ToolBar budeme využívat konstruktor: ToolBar (Composite parent, int style) - za rodičovskou komponentu budeme zadávat instanci třídy Shell a dostupné užitečné styly jsou následující: - FLAT - způsobí vizuální změnu odstraněním implicitně nastaveného 3-D efektu lišty. WRAP - nastaví (podobně jako u zalamování řádku textu) odskočení tlačítka na další řádek lišty, pokud není dostupné místo dostatečně velké. - RIGHT - užitečné jen ve speciálních případech a způsobí, že u instancí třídy Toolltem, umístěných na liště bude text zarovnán k pravému okraji obrázku. - HORIZONTAL - vytvoření klasické lišty a tento styl budeme zadávat v podstatě při každém vytváření instance. - VERT ICAL - umožňuje v případě potřeby vytvořit vertikální lištu. Tato možnost však není příliš využívána. Metody této třídy sice nebudeme pro naši základní práci nijak zvlášť potřebovat, ale zmíníme si alespoň následující: Toolltem getltem (int index)-vrací tlačítko na specifikovaném indexu. int get 11 emcount () - vrací počet tlačítek, které jsou na liště umístěny. 69

75 7.3. TOOLBAR A TOOLITEM setfont (Font font) - nastaví font pro všechny popisky tlačítek, které jsou na liště umístěny. Nyní se podívejme na konstruktory třídy Tool Item: Toolltem (ToolBar parent, int style) - rodičovskou komponentou je instance třídy ToolBar a často používané dostupné styly jsou: PUSH - klasické tlačítko, jedná se o nejpoužívanější styl. CHECK - dvoustavový přepínač, projevující se vizuálně jako styl TOGGLE u třídy Button. - RADIO - výběr právě jedné z více možností (tento styl použijeme na lištách opravdu jen výjimečně). SEPARATOR - oddělovač pro separaci logicky souvisejících skupin (podobně, jako tomu je u třídy Menu). Toolltem (ToolBar parent, int style, int index) - dovoluje navíc specifikovat index, na kterém se vytvořené tlačítko na liště objeví. Indexace probíhá opět od nuly. Užitečné metody jsou následující: addselectionlistener (SelectionListener listener) - přidá posluchač nezbytný pro zpracování událostí generovaných komponentou. String gettooltiptext () -vrací rozbalovací nápovědu tlačítka. set Image (Image image) - nastaví specifikovaný obrázek. setselection (boolean selected) - provede programovou změnu výběru komponenty (u stylů CHECK a RADIO). set Text (String string) - nastaví popisek tlačítka. Pokud je na tlačítku umístěn i obrázek, popisek se objeví pod ním. Pro změnu fontu popisku je nutné použít metodu z třídy ToolBar. settooltiptext (String string) - nastaví rozbalovací nápovědu. Tyto popisky jsou zvláště u tlačítek na lištách velmi často využívány. V ukázkovém příkladě si vytvoříme jednoduchou tlačítkovou lištu s obrázky a návěštím pro detekci stisku jednotlivých tlačítek, jak nám ukazuje obrázek 7.3: Obrázek 7.3: ToolBar - tlačítková lišta Postup je velmi jednoduchý a ukazuje jej zdrojový kód: 70

76 7.3. TOOLBAR A TOOLITEM // nejprve si vytvoříme instanci lišty ToolBar tbar = new ToolBar(shell, SWT.HORIZONTAL); // dále musíme nastavit její implicitní rozměry tbar.setsize(tbar.getshell().getsize().x, 40); // provedeme inicializace obrázků Image newlmage = new Image(display, "./img/toolbar/filenew.png") ; Image openlmage = new Image(display, "./img/toolbar/fileopen.png"); // vytvoříme instanci prvního tlačítka Toolltem newltem = new Toolltem(tBar, SWT.PUSH); // nastavení obrázku newltem.setlmage(newlmage); // nastavení rozbalovací nápovědy newltem.settooltiptext("new"); // přidání posluchače newltem.addselectionlistener(new ToolListener()); // podobně pro další tlačítko Toolltem openltem = new Toolltem(tBar, SWT.PUSH); openltem.setlmage(openlmage) ; openltem.settooltiptext("open"); openltem.addselectionlistener(new ToolListener ()); // jednoduchá implementace posluchače class ToolListener extends SelectionAdapter { public void widgetselected(selectionevent e) { lab.settext("bylo stisknuto: " + ((Toolltem)e.getSource()).getToolTipText());! ToolBarDemo 3 fir New Save Find Fonts Open Testovací text v návěští Obrázek 7.4: ToolBar - použití tlačítek s popisky Při práci s obrázky opět nesmíme zapomenout na explicitní uvolňování prostředků 71

77 7.4. COOLBAR A COOLITEM pomocí metody dispose (). Používání tlačítek s obrázky včetně popisného textu není často využíváno a pro lepší představu nám jej ukazuje obrázek 7.4. S touto komponentou si tedy vystačíme pouze v případě, kdy potřebujeme na lištu umístit jen tlačítka. Pokud potřebujeme mít na liště i jiné komponenty, musíme použít instance tříd, které si ukážeme v následující sekci. 7.4 CoolBar a Coolltem Tuto dvojici tříd můžeme považovat za ekvivalentní komponentu s třídou JToolBar v balíku Swing atcoolbarv Delphi. Umožňuje nám vytvořit lištu, na kterou je možné umísťovat jednak tlačítka, ale také instance třídy Combo a Text (užitečné zvláště při zadávání jednoduchých parametrů uživatelem) a dalších užitečných komponent. Podstatný rozdíl oproti třídě Tool Item je skutečnost, že instance třídy Coolltem nepředstavují jednotlivé komponenty (nastavováním potřebných stylů), ale představují pouze kontejner, do kterého je možné umístit instance tříd Button, Text (typicky pouze s použitím stylu SINGLE), Combo atd. V případě, kdy potřebujeme do jedné instance třídy Coolltem umístit více komponent (tlačítek, nebo návěští jako popisek s rozbalovací nabídkou apod.), musíme použít (stejně jako při návrhu samotného GUI) panely, představované instancemi třídy Composite. Jako ideální manažer pro rozmísťování komponent se pro tyto účely nabízí GridLayout, jehož vlastnosti zabezpečí přesně to, co po jednotlivých panelech budeme požadovat. Pro úplnost si ještě dodejme, že na instanci třídy CoolBar je možné umístit i instance třídy ToolBar, což ovšem využijeme pouze v případě, kdy budeme požadovat zobrazení tlačítek s obrázkem i popiskem zároveň (což jednoduše umožňuje třída Tool Item). K vytvoření lišty budeme používat konstruktor: CoolBar (Composite parent, int style) - za rodiče budeme nejčastěji považovat instanci třídy Shell a dostupné styly jsou pouze dva: NONE - tento styl budeme používat nejčastěji. - FLAT - odstranění 3-D efektu komponent na liště. Z dostupných metod si zmíníme následující (ostatní metody jsou v podstatě podobné komponentě ToolBar): boolean getlocked () - vrací true, je-li lišta zamknuta. V opačném případě vrací false. setlocked (boolean locked) - nastavuje uzamknutí (odemknutí) lišty, které znemožní (povolí) přesouvání komponent (respektive celých panelů komponent, které jsou obsaženy v dané instanci třídy Cool Item), které jsou na ní obsaženy. Pro vznik instance třídy Coolltem jsou dostupné následující konstruktory: Coolltem (CoolBar parent, int style) -vystačíme si s následujícím stylem: - NONE - pro vytvoření kontejneru k umísťování komponent. Coolltem (CoolBar parent, int style, int index) -navíc dovoluje zadat index na liště. 72

78 Pro základní práci si vystačíme s následujícími metodami: 7.4. COOLBAR A COOLITEM addselectionlistener (SelectionListener listener) -přidáníposluchače SelectionListener. Point computesize (int whint, int hhint) -důležitá metoda pro výpočet velikosti dané instance. setcontrol (Control control)- nezbytná metoda, jejímž prostřednictvím se přidávají komponenty (případně celé panely) do kontejneru. setsize (Point size) - slouží k nastavení velikosti. Použití této metody je zcela nezbytné a jako parametr nám bude většinou sloužit návratová hodnota metody computesize (). Postup práce s touto komponentou si ukážeme na příkladě a vytvoříme lištu s třemi tlačítky, vstupním polem pro zadávání hodnot a rozbalovací nabídkou tak, jak nám ukazují obrázky 7.5 a 7.6: Testovací text v návěští Obrázek 7.5: CoolBar - komplexní lišta pro komponenty Obrázek 7.6: CoolBar - zadávání hodnot Okomentovaný zdrojový kód nám ukazuje samotný postup: // nejprve si vytvoříme lištu CoolBar cbar = new CoolBar(shell, SWT.NONE); // vytvoření obrázku pro tlačítko Image newlmage = new Image(display, "./img/toolbar/filenew.png"); // zde si vytvoříme kontejner pro trojici tlačítek Coolltem buttonltem = new Coolltem(cBar, SWT.NONE); // pro tři tlačítka musíme vytvořit panel Composite buttonpane = new Composite(cBar, SWT.NONE); 73

79 buttonpane.setlayout(new GridLayout(3, true)); 7.4. COOLBAR A COOLITEM // standardně vytvoříme tlačítko Button newbutton = new Button(buttonPane, SWT.PUSH); newbutton.setimage(newlmage); newbutton.settooltiptext("nový"); newbutton.addselectionlistener(new ButtonsListener() // po vytvoření všech tlačítek použijeme metodu pack() // pro panel buttonpane.pack(); // nyní provedeme nastavení velikosti kontejneru podle // velikosti panelu buttonltem.setsize(buttonltem.computesize( buttonpane.getsize().x, buttonpane.getsize().y)); // a nakonec přidáme panel do kontejneru buttonltem.setcontrol(buttonpane) ; // podobně postupujeme pro návěští a textové pole Coolltem textltem = new Coolltem(cBar, SWT.NONE); Composite textpane = new Composite(cBar, SWT.NONE); textpane.setlayout(new GridLayout(2, true)); // vytvoříme návěští new Label(textPane, SWT.CENTER).setText ( "Zadávejte hodnoty: "), // a také inicializujeme textové pole final Text text = new Text(textPane, SWT.SINGLE SWT.BORDER); text.addkeylistener(new KeyAdapter() { public void keypressed(keyevent e) { if ((e.keycode == SWT.CR) (e.keycode == SWT.KEYPAD_CR)) { lab.settext("byla zadána hodnota: " + text.gettext text.settext(""); ); // opět je nezbytné nastavit velikost kontejneru textpane.pack(); textltem.setsize(textltem.computesize( textpane.getsize().x, textpane.getsize().y)); textltem.setcontrol(textpane) ; 74

80 7.4. COOLBAR A COOLITEM Vzhledem k tomu, že jsme lištu nezamknuli, je možné přesouvat jednotlivé panely pomocí tažení myši a měnit jejich velikost. V praxi se většinou volba na zamknutí (odemknutí) lišty nachází v menu. Přestože je komponenta CoolBar vskutku komplexní, práce s ní je bohužel poněkud komplikovanější, než je tomu u jejího ekvivalentu v balíku Swing. Touto sekcí jsme zakončili naši prohlídku tvorby menu a tlačítkových lišt a v následující kapitole (respektive v první kapitole přílohy) se podíváme na práci ze standardními dialogy v modulu SWT. 75

81 Kapitola 8 Zaver Prostředí SWT poskytuje všechny potřebné nástroje pro tvorbu vizuálně dokonalých GUI v jazyce Java. Bohužel, diplomová práce neposkytuje dostatečných prostor k popisu všech možností tohoto prostředí a proto jsem se zaměřil především na popis tohoto komponentního systému. Při provádění srovnání SWT s balíkem Swing, by bylo opravdu moc těžké vynést "rozsudek" a prohlásit, že některé z těchto prostředí je "lepší". Porovnáme-li optimalizaci, tak na dnešních průměrných počítačích nezaznamenáme v podstatě žádné rozdíly ve výkonu. Přestože práce s některými komponentami je v SWT výrazně jednodušší (například s třídou StyledText), tak některé postupy jsou lépe zvládnuty v balíku Swing. Z pohledu SWT se jedná především o chybějící metody pro umístění zobrazeného okna do středu obrazovky nebo pro zavření okna a uvolnění všech systémových prostředků držených aplikací. Dále v SWT citelně chybí manažer pro rozmístění komponent, který by v podstatě simuloval práci manažeru BorderLayout z balíku Swing. Tento manažer je ve Swingu velmi často využíván pro hlavní organizaci panelů v aplikačním okně a tudíž je jeho nepřítomnost v SWT poměrně nepříjemná. Podobná situace je s tvorbou tlačítkových lišt, které zde nemáme možnost umístit přímo do aplikačního okna, ale chovají se stejně, jako všechny ostatní komponenty v hlavní části (což nám opět připomene nepřítomný manažer BorderLayout, který bychom jednoduše využili pro umístění této lišty do horní části okna). Také tvorba menu je v SWT řešena méně intuitivním způsobem, než je tomu v balíku Swing. Naopak, téměř jednotný systém konstruktorů jednotlivých komponent, práce se styly a hlavně používání výrazně menšího počtu posluchačů jsou výraznými klady SWT. Tato práce však rozhodně není zaměřena na to, aby některé z těchto prostředí doporučila a záleží spíše na každém programátorovi, které mu bude lépe vyhovovat. Nicméně, díky své relativní jednoduchosti (menší počet komponent a nastavení pomocí stylů, univerzální posluchače atd.) se mi právě SWT zdá přístupnější začínajícím programátorům. A navíc vzhledem k tomu, že se toto prostředí neustále vyvíjí, můžeme v budoucnu jistě očekávat mnohá vylepšení a snad se dočkáme i implementace některých metod, které zatím citelně chybí. Byl bych velmi rád, kdyby informace uvedené v této práci pomohly všem, kteří se chtějí toto prostředí naučit a vyvíjet v něm své aplikace. 76

82 Literatura [Examples] Java examples,, Copyright , CatalogSWT-JFace-Eclipse.htm. [Snippets] SWT Snippets,, Copyright , http: // org/swt/snippets/. 77

83 Příloha A Práce s dialogy v SWT V této kapitole nás čeká prohlídka komponent SWT, které slouží k zobrazení a práci se standardními dialogy. Tyto komponenty jsou podobně jako jejich ekvivalenty ve standardních ja vovských prostředích navržené pro jednoduchou obsluhu a díky svému implicitnímu designu slouží k podstatnému ulehčení práce. Nejprve se podíváme na třídu, která slouží k zobrazování nejrůznějších programových hlášení a dále budou následovat komponenty pro vyvolávání specifických dialogů. Jak si postupně ukážeme, základem pro práci s jednotlivými dialogy je metoda open (), která slouží k zobrazení vytvořeného okna a hlavně také k vrácení hodnoty (tato hodnota závisí na typu dialogu). Přestože si samozřejmě v SWT můžeme v případě potřeby vytvořit vlastní dialogy (například pro zadávání specifických hodnot), v této kapitole se zaměříme pouze na předem vytvořené standardní třídy. Vytvoření vlastního dialogu je jednoduché a stačí si definovat třídu, rozšiřující komponentu D i al o g a dále je již postup v podstatě stejný, jako při návrhu klasického aplikačního okna. A.l MessageBox - programová hlášení Prostřednictvím této třídy můžeme, podobně jako pomocí třídy JOpt i onp ane v balíku Swing, zobrazovat všechna potřebná programová hlášení (informace, varování, chyba atd.). Práce s ní je velmi podobná jako je tomu u jejího ekvivalentu, neboťnastavování druhů jednotlivých hlášení se provádí prostřednictvím stylů této třídy. Díky SWT se vzhled zobrazeného hlášení plně přizpůsobí dané platformě, pod kterou je naše aplikace spuštěna. Instanci této třídy budeme vytvářet konstruktorem: MessageBox (Shell parent, int style) - rodičovskou komponentou je opět aplikační okno a styly nám umožňují specifikovat, o jaké hlášení se bude jednat: - IC0N_ERR0R - zobrazení chybového hlášení (například chyba programu, způsobená špatným zadáním hodnot uživatelem). - IC0N_INF0RMATI0N - informační hlášení (například informace o autorovi programu). - I CON_QUE S TI ON - otázka na uživatele (potvrzení ukončení programu). - IC0N_WARNING - zobrazení varovného hlášení. - IC0N_W0RKING - umožňuje zobrazení akcí při chybě probíhajícího procesu. - OK - zobrazení potvrzovacího tlačítka (v informačním hlášení apod.). 78

84 A.l. MESSAGEBOX - PROGRAMOVÁ HLÁŠENÍ - OK CANCEL-dvojice tlačítek pro potvrzení či zrušení (při dotazu na ukončení aplikace). YES NO - opět dvojice tlačítek pro kladnou či zápornou odpověď. - YES NO CANCEL - oproti předchozímu stylu přidá další tlačítko pro zrušení dotazu. - RETRY I CANCEL - dvojice tlačítek pro opakování akce a zrušení dialogu. - ABORT RETRY IGNORE - trojice pro reakci na chybu v běžícím procesu, umožňující přerušení, opakování či ignorování chyby v procesu. Při práci s touto komponentou budeme nejčastěji využívat následující metody (z nichž některé jsou zděděné z rodičovské třídy Dialog): String getmessageo - vrací text ze zobrazeného hlášení. int get Style () - slouží ke zjištění stylu zobrazeného dialogu. int open () - nezbytná metoda, která slouží k zobrazení dialogu. Všimněme si návratové hodnoty typu int, jejích prostřednictvím budeme rozlišovat, které z tlačítek na dialogu bylo stisknuto (návratovou hodnotou je tedy právě hodnota stisknutého tlačítka, například tedy SWT. OK). setmessage (String string) - nastavení hlášení, které se zobrazí na dialogu. settext (String text) - nastavení popisku okna dialogu. Musíme si uvědomit, že tato metoda neslouží ke specifikaci vlastního textu hlášení. Přestože jsou tyto dialogy v praxi většinou zobrazovány jako reakce na nějakou událost (například chybové hlášení o dělení nulou) v našem prezentačním příkladě si vytvoříme pouze okno se systémem tlačítek pro vyvolání odpovídajících hlášení, jak ukazuje obrázek A.l: Obrázek A.l: MessageBox - zobrazení hlášení Postup je velmi jednoduchý a jednotlivé dialogy se liší v podstatě jen nastavením různých stylů: // standardně vytvoříme tlačítko final Button infbutton = new Button(shell, SWT.NONE); infbutton.settext("informace"); infbutton.addselectionlistener(new SelectionAdapter() { 79

85 A.l. MESSAGEBOX - PROGRAMOVÁ HLÁŠENÍ public void widgetselected(selectionevent e) { // nejprve vytvoříme instanci a nastavíme potřebný styl MessageBox box = new MessageBox(shell, SWT.ICON_INFORMATION SWT.OK); // nastavíme popisek okna dialogu box.settext("informace"); // zde si nastavíme zobrazované hlášení box.setmessage("ukázkové informační hlášení."); // a nakonec hotový dialog zobrazíme box.open(); ); Nyní se ještě pro jistou podívejme, jak zpracovat odpověď na dotaz. Po výběru odpovědi se nám zobrazí informační okno o zadané odpovědi tak, jak ukazuje obrázek A.2: Obrázek A.2: MessageBox - zpracování odpovědi Samotné zjištění odpovědi provedeme prostřednictvím návratové hodnoty metody open (): // nejprve si vytvoříme dialogové okno pro otázku MessageBox box = new MessageBox(shell, SWT.ICON_QUESTION SWT.YES SWT.NO); box.settext("otázka"); box.setmessage("líbí se Vám SWT?"); // inicializujeme dialog pro odpověd MessageBox boxanswer = new MessageBox(shell, SWT.ICON_INFORMATION SWT.OK); boxanswer.settext("informace"); // zde provedeme rozlišení, které tlačítko bylo stisknuto if (box.open() == SWT.YES) { boxanswer.setmessage("zadali jste: ano."); 80

86 else { boxanswer.setmessage("zadali jste: ne."); // nakonec dialog otevřeme boxanswer.open(); A.2. FILEDIALOG A NAČÍTÁNÍ SOUBORŮ Jak jsme viděli, práce s touto komponentou je velmi jednoduchá a v dalších sekcích této kapitoly se postupně podíváme na další specifické dialogy, které se nám budou prakticky v každé aplikaci hodit. A.2 FileDialog a načítání souborů Tato komponenta představuje dialog pro otevření a uložení souboru (podle použitého stylu) tak, jak jej známe ze svého operačního systému. Její účel je tedy stejný, jako u ekvivalentních komponent ze standardních javovských prostředí a také z jazyka Delphi (TOpenDialog a TSaveDialog). Samozřejmě máme také možnost nastavování filtrů pro zobrazování specifických typů souborů. Následujícím konstruktorem budeme vytvářet instanci: FileDialog (Shell parent, int style) - dostupné styly slouží k nastavení typu zobrazeného dialogu: - SAVE - slouží pro vytvoření dialogu pro uložení souboru na disk. - OPEN - načtení existujícího souboru z disku. Tento styl je nastaven implicitně. - MULTI - umožňuje zobrazit dialog, který umožní výběr více souborů pro načtení z pevného disku. Metody, které si zde zmíníme nám umožňují základní práci s komponentou: String getfilename () - vrací název vybraného souboru. String [] getfilenames () -v případě použití stylu MULTI vrací názvy všech vybraných souborů v poli. String [] getfilterextensions () - vrací filtry přípon souborů, které jsou přiřazeny pro daný dialog. String getfilterpath () - vrací implicitně nastavenou cestu do některé ze složek v souborovém systému. String open () - nezbytná metoda pro otevření dialogu. Návratovou hodnotou je název vybraného souboru a musíme si uvědomit, že se jedná o typ S t ring a nikoliv typ int, jako tomu bylo u stejnojmenné metody u komponenty Me s s agebox. setfilename (String string) - programově nastaví název vybraného souboru. Jedná se o užitečnou metodu, chceme-li mít vybrán nějaký soubor implicitně. 81

87 A.2. FILEDIALOG A NAČÍTANÍ SOUBORU setfilterextensions (String [ ] extensions) - metoda k nastavení filtru přípon souborů, které uživatel v dialogu uvidí. Implicitně jsou viditelné všechny soubory (tj. je použit filtr "*.*"). Například tedy pro viditelnost zdrojových kódů jazyka java použijeme filtr "*.java" a uživatel tedy v jednotlivých složkách uvidí pouze soubory tohoto typu (respektive s touto příponou). Zvláště u dialogů, sloužících k otevírání souborů je nastavování filtrů velmi důležité, protože tím zamezíme otevření neznámého typu soboru a nemusíme tato neočekávaná otevření nijak ošetřovat. setfilterpath (String string) - nastaví implicitní cestu, která bude otevřena po zobrazení dialogu. Pokud tuto cestu nenastavíme, bude otevřen aktuální pracovní adresář. Je možné zadávat cesty absolutní (například "c:/java/") a také cesty relativní vzhledem k aktuálnímu adresáři (například "./src/"), což je pro naše aplikace velmi užitečné. Jako ukázkový příklad si vytvoříme základ jednoduchého prohlížeče zdrojových kódů jazyka Java. Aplikační okno bude obsahovat menu s položkou pro otevření souboru a textovou oblastí pro jeho zobrazení. Pro samotný dialog si nastavíme filtr a implicitní cestu k našim ukázkovým příkladům, abychom prezentovali jeho vlastnosti. Obrázek A.3 nám ukazuje náš zobrazený dialog: Oblast hledání: Ö basicconnponents 3 Button_AnClassDemo ] Button_ARROWDemo íjo ButtonjIHECKDemo y ButtonJnnerClassDemo IjÖ Button_RADIODemo IjO Button_TOGGLEDemo y ComboDerino F I LabelDemo jo LabelFontDenno 5 Typ: 5oubor JAVA Změněno: 10,7, :10 Velikost: 1,83 kb ~3 E Ü _U_xj Název souboru: Soubory typu: ListDemo. ava "3 "3 Otevřít Storno % Obrázek A.3: FileDialog - otevření souboru Ve zdrojovém kódu se podíváme na práci s komponentou FileDialog a také na princip načítání souboru z pevného disku, čímž si zároveň připomeneme práci se třídou File, obsaženou ve standardní Jávě: 82

88 A.2. FILEDIALOG A NAČÍTANÍ SOUBORU // nejprve si klasicky vytvoříme položku menu Menultem openltem = new Menultem(filemenu, SWT.PUSH); openltem.settext("&otevřít\t CTRL+O"); openltem.setaccelerator(swt.ctrl + '0'); // zobrazení dialogu provedeme v posluchači openltem.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { // vytvoříme si instanci dialogu FileDialog fd = new FileDialog(shell, SWT.OPEN); // nastavíme si relativní implicitní cestu fd.setfilterpath("./src/basiccomponents/"); // filtr nastavíme pouze na soubory jazyka Java String[] filter = {"*.java"; fd.setfilterextensions(filter) ; // pomocí návratové hodnoty metody open() zjistíme // vybraný soubor a provedeme jeho načtení text.settext(loadfile(new File(fd.open()))); ); // metoda pro načtení souboru z disku public String loadfile(file f){ String kod = ""; try { BufferedReader br = new BufferedReader(new FileReader(f) String radek = br.readline() + "\n"; // v~cyklu načítáme jednotlivé řádky while (radek!= null) { kod += radek; radek = br.readline(); if (radek!= null) radek += "\n"; br.close(); // ošetření možné chyby je nezbytné catch (IOException ioe) { System.err.printin("Chyba při načítání."); kod = ""; return kod;

89 A.3. COLORDIALOG V případě použití stylu SAVE bychom při ukládání postupovali velmi podobně, jaké ve výše zmíněném případě. V případě, kdy potřebujeme vybrat složku a nikoliv soubor, musíme k tomuto účelu použít komponentu DirectoryDialog. Práce s ní je však natolik podobná, jako je tomu u třídy FileDialog, že se jí v našem přehledu nebudeme z rozsahových důvodů zabývat (opět nám metoda open () vrátí název vybrané složky). FileDialog je zcela základní komponentou (přístupnou většinou z menu a tlačítkové lišty), kterou budeme v praxi velmi často využívat a bude součástí prakticky každé naší aplikace. A.3 ColorDialog Jak již název této třídy napovídá, jedná se o dialog pro výběr barvy, který implicitně zobrazí k výběru základní barevné spektrum. Jednotlivé barvy jsou specifikovány v modelu RGB (red, green, blue) a každá složka představuje celé číslo v rozsahu 0-255, definující zastoupení složky ve výsledné barvě. Například tedy specifikace (255,0, 0) odpovídá červené barvě bez příměsi jiných odstínů. Ekvivalentními komponentami jsou například JColorChooser (Swing) a TColorDialog (Delphi). K vytvoření instance slouží konstruktor: ColorDialog (Shell parent) - stačí nám pouze specifikace instance třídy Shell, žádné styly nejsou pro tuto komponentu dostupné. Metody nám opět umožňují práci s komponentou: RGB getrgbo - vrací specifikovanou barvu. RGB open () - podobně jako stejnojmenné metody u ostatních dialogů způsobí zobrazení dialogu. Návratovou hodnotou je tentokrát zvolená barva v modelu RGB. setrgb (RGB rgb) -provede programový výběr zadané barvy. K prezentaci práce s touto komponentou si vytvoříme jednoduchý příklad, kdy pomocí dialogu budeme nastavovat barvu písma v návěští. Vytvořený dialog nám ukazuje obrázek A.4. Postup je vskutku krátký a jednoduchý: // standardně si vytvoříme tlačítko pro vyvolání dialogu final Button colorbutton = new Button(shell, SWT.NONE); colorbutton.settext("změnit barvu"); colorbutton.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { // nejprve si vytvoříme instanci dialogu ColorDialog cd = new ColorDialog(shell); // do proměnné color si načteme vybraný RGB profil RGB color = cd.open(); // provedeme kontrolu, zda byla vybrána nějaká barva 84

90 if (color!= null) { // a nastavíme barvu písma v návěští label.setforeground(new Color(shell.getDisplay color)); A.4. FONTDIALOG ); Obrázek A.4: ColorDialog - změna barvy písma textu Podobně jednoduchým způsobem můžeme tuto komponentu využít i pro nastavování barvy označeného textu, který je obsažen v instanci třídy StyledText. Poslední třídou, na kterou se v této kapitole podíváme bude další užitečná komponenta s názvem FontDialog. A.4 FontDialog Tato komponenta (podobně jako například TFontDialog v Delphi) nám umožňuje zobrazení komplexního dialogu k nastavení vlastností fontů a je součástí v podstatě každého textového editoru. Přestože si můžeme některé pomocné funkce v editoru umístit přímo na tlačítkovou lištu (například nastavení typu fontu či velikosti písma), je tento dialog velmi užitečný a pro komplexní nastavení vlastností písma v podstatě nezbytný (a také můžeme vzít v úvahu skutečnost, že nastavování fontů prostřednictvím tohoto dialogu je výrazně jednodušší a přehlednější). Podobně jako komponenta ColorDialog dovoluje i instance této třídy nastavit několik základních barev písma a přestože neposkytuje tolik možností, pro základní práci si s tímto nastavením bohatě vystačíme. Tvorbu instance provedeme konstruktorem: 85

91 A.4. FONTDIALOG FontDialog (Shell parent) - opět není zapotřebí žádný styl a rodičovskou komponentou je opět aplikační okno. Metod, které budeme využívat je opět jen malé množství: RGB getrgbo - slouží ke zjištění vybraného barevného profilu. FontData open () - opět nezbytná metoda k zobrazení dialogu a vrácení všech nastavení, které uživatel v dialogu provedl. Všimněme si, že je návratovým typem třída FontData a nikoliv samotný font. Ten si pak ovšem velmi jednoduše vytvoříme. void setfontlist (FontData [ ] f ontdata) - slouží k inicializace dialogu, respektive k jeho synchronizaci s nastavením fontu v určité komponentě či v označeném textu. Provede tedy nastavení aktuálně použitého fontu, řezu písma, velikosti atd. void setrgb (RGB rgb) -opět metoda, používaná při inicializaci dialogu k nastavení aktuálního barevného profilu. K prezentaci nám opět poslouží jednoduchý ukázkový příklad a vytvoříme si textovou oblast s tlačítkovou lištou, na které bude tlačítko pro vyvolání dialogu, který nastaví (globálně) font se zvolenými parametry pro textovou oblast. Samotný dialog nám ukazuje obrázek A.5: Obrázek A.5: FontDialog - nastavování fontů v textové oblasti Postup je opět velmi jednoduchý: // standardně si vytvoříme lištu s tlačítkem 86

92 A.4. FONTDIALOG Toolltem fontsltem = new Toolltem(tBar, SWT.PUSH); fontsitem.setlmage(fontslmage); fontsltem.settext("fonty"); fontsltem.settooltiptext("fonty") ; fontsitem.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { // začneme vytvořením instance FontDialog fd = new FontDialog(shell); // provedeme inicializace aktuální barvy fd.setrgb(text.getforeground().getrgb()); // dále inicializujeme nastavení fontu fd.setfontlist(text.getfont().getfontdata()); ); // metoda open nám vrátí provedené změny FontData newfont = fd.open(); // nezbytná kontrola výběru if (newfont!= null) { // nastavíme nový font pro textovou oblast text.setfont(new Font(shell.getDisplay(), newfont)); // a také nastavíme vybranou barvu text.setforeground( new Color (shell.getdisplay(), fd.getrgb( ))); Touto komponentou zakončíme naši prohlídku standardních dialogů v SWT a v následující obsáhlé kapitole nás čeká prezentace zbývající tříd balíku SWT. 87

93 Příloha B Ostatní komponenty SWT V této kapitole se postupně podíváme na komponenty balíku SWT, které sice nepatří mezi zcela běžné, ale při návrhu komplexního GUI je budeme velmi často potřebovat. U některých z komponent v této kapitole se setkáme i s dalšími posluchači balíku SWT. B.l TabFolder a Tabltem - tvorba záložek První a zároveň také nejjednodušší komponentou, na kterou se v této kapitole podíváme, je nástroj pro tvorbu "záložek". Tyto záložky pak v okně aplikace představují samostatné panely, na které umísťujeme jednotlivé komponenty. Výhodou přítomnosti této komponenty v GUI je určitě spousta ušetřeného místa, neboť okno aplikace nemusí být tak velké. Jen si pochopitelně musíme dávat pozor, abychom na jednotlivé záložky umísťovali logicky související komponenty a nedosáhli tak nepřehlednosti. Použití této komponenty se trochu podobá třídám CoolBar a Cool Item, protože třída TabFolder představuje konstrukci a Tabltem pak jednotlivé záložky (tj. v podstatě kontejnery pro komponenty). Jako popisek jednotlivých záložek nám kromě obyčejného textu může sloužit i obrázek. Svým použitím tedy připomíná komponenty JTabbedPane (Swing) a TTabControl (Delphi). Instanci třídy TabFolder vytvoříme konstruktorem: TabFolder (Composite parent, int style) -rodičovskoukomponentou bude ve většině případů instance třídy Shell a dostupné styly umožňují nastavení, kde se záložky jednotlivých panelů budou zobrazovat: - TOP - umístění záložek v horní části. - BOTTOM - záložky se zobrazují v dolní části. Z dostupných metod jsou užitečné následující: int getltemcount () -vrací počet záložek, které mají naši instanci jako předka. int indexof (Tabltem item) - vrací index zadané záložky. setselection (int index) - užitečná metoda, pokud potřebujeme implicitní výběr jiné položky, než první zleva (s indexem 0). K inicializaci třídy Tabltem slouží konstruktor: Tabltem (TabFolder parent, int style) - nejsou dostupné žádné styly pro tuto třídu, ale přítomnost parametru dává najevo, že se v některé budoucí verzi SWT nějakých stylů dočkáme. 88

94 B.l. TABFOLDER A TABITEM - TVORBA ZÁLOŽEK Tabltem (TabFolder parent, int style, int index) - dovoluje navíc zadat index záložky. Užitečných metod je opět pouze několik: setcontrol (Control control) - důležitá metoda pro přidání komponenty do záložky. V případě potřeby umístění více komponent jsme podobně jako u třídy Cool Item nuceni použít panely (instance třídy Composite či Group). set Image (Image image) - nastaví specifikovaný obrázek jako popisek záložky. settext (String string) - nastaví textový popisek. settooltiptext (String string) - přidání rozbalovací nápovědy. Vytvoříme si jednoduchý příklad se dvěmi záložkami. Na první z nich bude umístěn pouze text v návěští a na druhé obrázek, jak ukazuje obrázek B.l: TabFolderDemo Ukázkový text na prvním panelu TabFolderDemo LOJiSl JAVA Text obrázek Zdrojový kód ukazuje postup: Obrázek B.l: TabFolder - tvorba záložek // nejprve si inicializujeme konstrukci TabFolder tf = new TabFolder(shell, SWT.BOTTOM); // dále si vytvoříme první záložku Tabltem iteml = new Tabltem(tf, SWT.NONE); // nastavíme její popisek iteml.settext("text") ; Label labl = new Label (tf, SWT.NONE); labl.settext("ukázkový text na prvním panelu."); // přidáme návěští na záložku iteml.setcontrol(labl) ; // podobně pro druhou záložku Tabltem item2 = new Tabltem(tf, SWT.NONE); item2.settext("obrázek") ; 89

95 Image image = new Image(display, "./img/je.jpg"); Label lab2 = new Label (tf, SWT.NONE); lab2.setlmage(image); item2.setcontrol(lab2); B.2. SASHFORM Práce s touto třídou je jednoduchá, jen si musíme dát pozor na to, aby instance třídy She 11 (případně některé z panelů), do které umísťujeme naši konstrukci (instanci třídy TabFolder), měla nastavený některý z manažerů rozmístění komponent. V opačném případě bychom museli nastavovat velikost a umístění záložek a tudíž by se naše konstrukce při takovém spuštění vůbec nezobrazila. Přestože tuto komponentu nenajdeme v každém GUI, jedná se o velmi zajímavou možnost pro ušetření místa v aplikačním okně. B.2 SashForm Tato jednoduchá komponenta z balíku swt. custom nám umožňuje vytvářet speciální panely obsahující většinou dvojici komponent, které jsou horizontálně či vertikálně odděleny a uživatel může pomocí posouvání oddělovače měnit jejich velikost v rámci aplikačního okna. Podobné účely má třída JSplitPane v balíku Swing. Ke stejným účelům slouží i třída S ash, obsažená ve standardním balíku, ale práce sní je spíše uzpůsobena poměrně komplikovanému manažeru FormLayout a proto si pro naše účely vystačíme s třídou SashForm, protože práce s ní je velmi jednoduchá a dosáhneme s ní stejných výsledků. Instanci vytvoříme konstruktorem: SashForm (Composite parent, int style) - rodičem může být libovolná instance všech potřebných tříd (Shell, Composite, SashForm atd.). Dostupné styly mění způsoby rozdělení umístěných komponent: - HORIZONTAL - komponenty jsou umístěny vedle sebe. - VERT ICAL - umístění pod sebou. SMOOTH - zajímavá volba, která způsobí "překreslování" komponent při změně jejich velikosti. Například tedy v našem příkladě způsobí postupné zalamování řádků při zmenšování jedné z textových oblastí. Užitečné metody této třídy jsou: setorientation (int orientation) - umožňuje změnit způsob umístění komponent. setweights (int [ ] weights) - důležitá metoda pro nastavení velikosti všech komponent, obsažených v naší instanci. Implicitně je pro dvojici dostupný prostor rozdělen na dvě poloviny. V případě potřeby můžeme změnit velikost oddělovacího posuvníku přímým nastavením vlastnosti SASH.WIDTH. V jednoduché ukázce si vytvoříme okno s instancí třídy SashForm a dvěmi textovými oblastmi tak, jak ukazuje obrázek B.2. Samotný postup je naprosto triviální. 90

96 B.3. TREE, TREEITEM A TREECOLUMN - TVORBA STROMU SashFormDemo Text v prvním panelu Text ve druhém panelu ^Jnjxj! SashFormDemo iľext v prvním panelu Text ve druhém panelu Obrázek B.2: SashForm - změna velikosti panelů // nejprve vytvoříme instanci SashForm sash = new SashForm(shell, SWT.HORIZONTAL SWT.SMOOTH); // dále si vytvoříme panely a vložíme je do ní Composite compl = new Composite(sash, SWT.NONE); compl.setlayout(new FillLayout ()); Composite comp2 = new Composite(sash, SWT.NONE); comp2.setlayout(new FillLayout ()); // textové oblasti umístíme na panely Text textl = new Text(compl, SWT.BORDER SWT.MULTI SWT.WRAP); textl.settext("text v prvním panelu"); Text text2 = new Text(comp2, SWT.BORDER SWT.MULTI SWT.WRAP); text2.settext ("Text ve druhém panelu"); // nastavení velikosti panelů sash.setweights(new int[] {50, 200); Nastavení velikosti panelů je nezbytně nutné provádět až poté, co si na panely přidáme komponenty. V případě, kdy by jsme si nastavili velikosti dříve a teprve poté přidávali komponenty, obdržíme při spuštění našeho programu výjimku. Přestože se jedná o velmi jednoduchou komponentu, její vyžití v praxi je velmi časté a pro její jednoduchost se ji rozhodně vyplatí využívat, protože si pomocí ní může uživatel nastavovat velikosti panelů a ušetříme tím i místo v našem GUI. B.3 Tree, Treeltem a TreeColumn - tvorba stromů Tato dvojice tříd nám umožňuje vytvářet hierarchické stromové struktury tak, jak je známe z klasického prohlížeče ve Windows. Podobně jako třída JTree v balíku Swing či TTreeView v Delphi (v AWT se žádná podobná třída nenachází) nám dovoluje 91

97 B.3. TREE, TREEITEM A TREECOLUMN - TVORBA STROMŮ provádět nejrůznější nastavení přidávaných položek stromu včetně grafické reprezentace. Při výběru některé z položek ve stromu je opět generována událost typu Select i onevent. Dále musíme zpracovávat události typu TreeEvent a pro jejich zpracování slouží posluchač TreeListener, který využijeme například budeme-li chtít dynamicky měnit ikony rodičovských uzlů podle toho, zda jsou rozbaleny. Na rozdíl od komponenty JTree však tato třída neobsahuje implicitně žádné ikony, takže si je v případě potřeby musíme explicitně nastavit. Třída TreeColumn slouží ke tvorbě tzv. vícesloupcových (nebo chcete-li, tabulkových) stromů a jedná se o novinku zavedenou v SWT od verze 3.1. Na její použití se podíváme až v závěru sekce, neboť ke tvorbě běžných stromů potřebujeme pouze třídy Tree a Tree Item. Instanci třídy Tree vytvoříme konstruktorem: Tree (Composite parent, int style) - dostupné styly umožňují nastavit chování komponenty: - S INGLE - klasické chování stromové struktury. - MULTI - umožňuje nastavení vícenásobného výběru položek ve stromu. - CHECK - poměrně neobvyklý styl, zobrazující u položky i zaškrtávací políčko a často se používá v kombinaci se stylem MULTI. - FULL_SELECTI0N - pouze vizuální nastavení pro zvýraznění celého řádku, obsahujícího vybranou položku, v případě výběru. Z dostupných metod si zmíníme následující: addselectionlistener (SelectionListener listener) -přidáníposluchače na zpracování událostí, generovaných při výběru položky ve stromu. addtreelistener(treelistener listener) -přidání posluchače pro události TreeEvent. Treeltem getltem (int index) - vrací položku ve stromu na zadaném indexu. Položky jsou řazeny (pokud není zadáno jinak) za sebe v průběhu jejich vytváření a přidávání do stromu. int get 11 emcount () - vrací počet položek ve stromu. Treeltem [] get Items () -vrací všechny položky obsažené ve stromu. setheadervisible (boolean show) - důležitá metoda při použití sloupců, umožňující zobrazení hlavičky (true). showl t em (Treeltem item) - programově provede vybrání položky a její případné rozbalení. Nyní se podívejme na třídu Treeltem: Treeltem (Tree parent, int style) - pro tvorbu položek, které budou umístěny v kořenu stromu. Žádné styly dosud nejsou dostupné, takže musíme zadat styl SWT.NONE. Treeltem (Treeltem parentltem, int style) - pro vytvoření položky, která se bude nacházet v některé z nižších úrovní stromu. 92

98 B.3. TREE, TREEITEM A TREECOLUMN - TVORBA STROMU Metody pro základní práci s položkami jsou následující: boolean getexpanded () - vrací true je-li položka rozbalena. V opačném případě vrací hodnotu false. int get 11 emcount () - vrací počet přímých potomků. Tree Item [ ] get Items () - metoda k vrácení všech přímých potomků. Treeltem getparent Item () - vrací přímou rodičovskou komponentu. String gettext (int index) - pro zjištění popisku uzlu. set Image (Image image) - nastavení obrázku uzlu. Pro dynamickou změnu musíme použít posluchač TreeListener. settext (String string) - nastaví popisek uzlu. Jako ukázkový příklad nám poslouží grafická reprezentace několika balíků našich ukázkových příkladů. Vytvoříme si tedy strom s balíky a jednotlivými příklady, ukážeme si dynamickou změnu obrázků při rozbalení položky a při kliknutí na list budeme vyvolávat informační hlášení s názvem ukázkového příkladu, abychom si prezentovali práci s oběma používanými posluchači. Naši jednoduchou aplikaci ukazuje obrázek B.3: TreeDemo B"Ě^ zakjadnikomponenty ButtonDemo.java ComboDenno.javaK LabelDemo.java ^í ListDemo.java É-ff^ textovekomponenty É-{^ tvorbamenu CoolBarDemo.java MenuDemo.java ToolBarDerino.java Informace ComboDenno.java V OK ^Jnj_Kj Obrázek B.3: Tree - organizace ukázkových příkladů Zdrojový kód s komentářem nám vysvětlí postup: // nejprve si připravíme obrázky final Image folder = new Image(display, "./img/tree/folder.png") ; final Image opene = new Image(display, "./img/tree/folderopen.png") ; 93

99 B.3. TREE, TREEITEM A TREECOLUMN - TVORBA STROMU // vytvoříme si instanci stromu Tree tree = new Tree(shell, SWT.SINGLE SWT.BORDER); // přidáme pro něj posluchač pro změnu ikon tree.addtreelistener(new TreeListener() { // metoda, vyvolaná při rozbalení uzlu public void treeexpanded(treeevent e) { // všimněme si způsobu načtení položky z události Treeltem ti = (Treeltem) e.item; // pro položku nastavíme patřičnou ikonu ti.setlmage(openlmage); // metoda vyvolávaná při sbalení uzlu public void treecollapsed(treeevent e) { Treeltem ti = (Treeltem) e.item; ti.setlmage(folderlmage) ; ); // posluchač pro události generované při výběru uzlu tree.addselectionlistener(new SelectionAdapter() { public void widgetselected(selectionevent e) { Treeltem ti = (Treeltem) e.item; // ověření, zda se jedná o list if (ti.getltemcount () == 0) { MessageBox box = new MessageBox( shell, ); SWT.ICON_INFORMATION box.settext("informace"); box.setmessage(ti.gettext()); box. open () ; SWT.OK) // nyní inicializujeme položku pro balík a umístíme // ji do kořene stromu Treeltem zk = new Treeltem(tree, SWT.NONE, 0); zk.settext("zakladnikomponenty"); zk.setlmage(folderlmage) ; // vytvoříme listy a umístíme je do našeho balíku Treeltem button = new Treeltem(zk, SWT.NONE); button.settext("buttondemo.java"); Treeltem combo = new Treeltem(zk, SWT.NONE); combo.settext("combodemo.java"); Treeltem label = new Treeltem(zk, SWT.NONE); label.settext("labeldemo.java"); Treeltem list = new Treeltem(zk, SWT.NONE);

100 B.3. TREE, TREEITEM A TREECOLUMN - TVORBA STROMŮ list.settext("listdemo.java"); Pro jistotu si připomeňme, že prostředky proměnných s obrázky musíme uvolnit explicitně. Nyní se ještě podíváme na práci se třídou TreeColumn. Pomocí ní můžeme vytvářet vícesloupcové (někdy nazývané také tabulkové) stromy, z nichž jeden sloupec vždy slouží pro zobrazení samotného stromu a další pak pro zobrazení doprovodných informací k jednotlivým uzlům. Maximální počet takových sloupců je tři. Ke vzniku instance budeme využívat konstruktor: TreeColumn (Tree parent, int style) - rodičovskou komponentou je instance třídy Tree a dostupné styly umožňují nastavit umístění popisku v záhlaví daného sloupce: - LEFT - nastavení popisku do levé části. - RIGHT - popisek se bude nacházet vpravo. - CENTER - umístění do středu. Z dostupných metod si zmíníme jen nejdůležitější: setalignment (int alignment) - nastavení zarovnání textu ve sloupci. Možné hodnoty JSOU Opět SWT.LEFT, SWT. RIGHT a SWT. CENTER. set Image (Image image) - umožňuje nastavit obrázek jako popisek sloupce. setresizable (boolean resizable) - dovoluje znemožnit (false) uživateli změnu velikosti sloupce. settext (String string) - nastavení popisku sloupce. setwidth (int width) - důležitá metoda pro nastavení šířky sloupce. Náš ukázkový příklad si tedy rozšíříme o další dva sloupce, které nám budou složit pro popisky jednotlivých uzlů, jak ukazuje obrázek B.4: Obrázek B.4: Tree - použití více sloupců Do vytvořeného příkladu tedy připíšeme následující kód a modifikujeme přidávání jednotlivých položek: 95

101 B.4. TABLE, TABLEITEM A TABLECOLUMN - PRÁCE S TABULKAMI // vytvoříme si sloupce, nastavíme zarovnání a šířku TreeColumn columnl = new TreeColumn(tree, SWT.LEFT); columnl.settext("strom"); columnl.setwidth(200) ; TreeColumn column2 = new TreeColumn(tree, SWT.CENTER); column2.settext("popis 1"); column2.setwidth(200) ; TreeColumn column3 = new TreeColumn(tree, SWT.RIGHT); column3.settext("popis 2"); column3.setwidth(200) ; // při zadávání položek je nutné zadat textové popisky // pro každý sloupec Treeltem zk = new Treeltem(tree, SWT.NONE); zk.settext(new String[] {"zakladnikomponenty", "Balík základních komponent", ""); zk.setimage(folderimage) ; Treeltem button = new Treeltem(zk, SWT.NONE); button.settext (new String[] {"ButtonDemo.Java", "Práce s~tlačítky", "4 příklady"); Práce s touto komponentou je poměrně jednoduchá a to především díky malému počtu posluchačů (v porovnání s balíkem Swing). Uplatnění této třídy bude všude tam, kde budeme potřebovat vizuálně znázornit libovolnou hierarchickou strukturu. B.4 Table, Tableltem a TableColumn - práce s tabulkami Díky této trojici tříd můžeme v našem GUI vytvářet tabulky, které nám můžou sloužit jak pro přehledné zobrazování hodnot (nejčastěji spolu s propojením s databází) a také slouží jako základ při tvorbě tabulkového procesoru. Pokud bychom hledali ekvivalentní komponentu ve standardní Jávě, tak se nám nabízí JTable v balíku Swing, ale v AWT žádnou podobnou komponentu nenajdeme. Práce s touto trojicí tříd je podobná, jako je tomu u stromů, které jsme si popsali v minulé sekci. Podobně jako u většiny ostatních komponent budeme i zde zpracovávat události typu Select i onevent nejčastěji pomocí adaptéru. Třída Table slouží jako pomyslná konstrukce pro tabulku a vytvoříme ji konstruktorem: Table (Composite parent, int style) - důležité styly umožňují provést řadu nastavení, ovlivňující chování tabulky: - S INGLE - tabulka, která umožní výběr jediného řádku. 96

102 B.4. TABLE, TABLEITEM A TABLECOLUMN - PRÁCE S TABULKAMI - MULT I - umožňuje provádět vícenásobné výběry v tabulce. CHECK - zaškrtávací políčka u jednotlivých řádků. Podobně jako u stromů se jedná o nový a zatím nepříliš využívaný styl. - FULL_SELECTI0N - výběr (vizuální označení) celého řádku při označení položky. - VIRTUAL - optimalizace pro práci s většími objemy dat (při používání filtrů, při třídících operacích apod.). Pro základní práci potřebujeme pouze několik metod: addselectionlistener (SelectionListener listener) - důležitá metoda pro přidání posluchače. int getcolumncount () - vrací počet sloupců tabulky. TableColumn [ ] getcolumns () - vrací všechny sloupce tabulky uspořádané v poli. Tableltem getltem (int index) - slouží ke vrácení položky na zadaném indexu. int get 11 emcount () - vrací počet položek (buněk) tabulky. setheadervisible (boolean show) - důležitá metoda (jako u komponenty Tree) pro zobrazení záhlaví tabulky. Implicitně je toto záhlaví neviditelné a tudíž bychom neviděli popisky jednotlivých sloupců. setlinesvisible (boolean show) - umožňuje zobrazit implicitně vypnutou mřížku, oddělující jednotlivé buňky v tabulce. Třída TableColumn představuje jednotlivé sloupce tabulky a jeji instanci inicializujeme konstruktorem: TableColumn (Table parent, int style)- rodičovskou třídou je samozřejmě samotná tabulka a pomocí stylů můžeme nastavit zarovnání popisku v záhlaví: - LEFT - zarovnání vlevo. - RIGHT - zarovnání vpravo. - CENTER - umístění popisku na střed (asi nejčastěji využívaný styl). Metod potřebujeme opět jen několik málo: set Image (Image image) - nastavení obrázku jako popisku sloupce. setmoveable (boolean moveable) - dovoluje povolit přesouvání sloupce v rámci tabulky (true). Implicitním nastavením je tato možnost zakázána. setresizable (boolean resizable) -metoda pro znemožnění změny velikosti sloupce (false). Implicitně je změna velikosti povolena. 97

103 B.4. TABLE, TABLEITEM A TABLECOLUMN - PRACE S TABULKAMI settext (String string) - nastavení textového popisku sloupce. Umístění textu v záhlaví závisí na zvoleném stylu. setwidth (int width) - důležité nastavení implicitní velikosti sloupce. Jednotlivé položky (respektive při použití více sloupců celé řádky) tabulky nám představuje třída Table Item, jejíž instanci vytvoříme konstruktorem: Tableltem (Table parent, int style) -rodičovskou komponentou je opět tabulka (tedy nikoliv instance třídy TableCol umn). Žádné styly nejsou dostupné, takže musíme za parametr konstruktoru zadat SWT. NONE. Ještě si zmíníme několik základních metod pro práci s položkami: setbackground (Color color) - nastavení pozadí buňky. setfont (Font font) - umožňuje změnu fontu textu, který je v buňce obsažen. setforeground (Color color) - nastavení barvy písma v buňce. set Image (Image image) - umístění obrázku do tabulku. settext (String string) - nastavení textu do buňky. settext (String [ ] strings) - při použití více sloupců nastaví textové popisky pro všechny sloupce. Nyní si tedy můžeme ukázat tuto komponentu v praxi a vytvoříme si jednoduchou tabulku. Přestože v praxi budeme samozřejmě používat tabulky pro zobrazování dat, uložených v databázi, pro prezentaci práce s touto komponentou nám bude stačit "uměle" (tj. pomocí metody settext ()) naplnit tabulku nějakými hodnotami. Výsledek našeho příkladu ukazuje obrázek B.5: TableDemo -Inlxl Číslo Komponenta Cena 1 HardDisk CPU Grafická karta 8000 Obrázek B.5: Table - zobrazování informací Zdrojový kód s komentářem ukazuje poměrně jednoduchý postup: // vytvoříme si tabulku a nastavíme potřebné styly Table table = new Table (shell, SWT.SINGLE SWT.BORDER SWT.FULL_SELECTION); // zobrazení záhlaví 98

104 table.setheadervisible(true); // zobrazení mřížky tabulky table.setlinesvisible(true); B.5. SLIDER A SPINNER - NASTAVOVÁNÍ HODNOT // nyní si vytvoříme instance sloupců TableColumn tcl = new TableColumn(table, SWT.CENTER); TableColumn tc2 = new TableColumn(table, SWT.CENTER); TableColumn tc3 = new TableColumn(table, SWT.CENTER); // nastavíme si popisky sloupců tel.settext("číslo"); tc2.settext("komponenta"); tc3.settext("cena"); // a také jejich šířku tcl.setwidth(loo); tc2.setwidth(100); tc3.setwidth(100); // a nakonec vytvoříme položky a nastavíme jejich obsah Tableltem iteml = new Tableltem(table,SWT.NONE); iteml.settext(new String[] {"1","HardDisk","3000"); Tableltem item2 = new Tableltem(table,SWT.NONE); item2.settext(new String[] {"2","CPU","6000"); Tableltem item3 = new Tableltem(table,SWT.NONE); item3.settext(new String[] {"3","Grafická karta","8000"); Použití této komponenty pro tvorbu tabulkového procesoru je poněkud složitější, takže se jím nebudeme v našem základním přehledu zabývat. V porovnání s jejím ekvivalentem v balíku Swing je komplikovanost práce s ní (především pro prosté zobrazování informací) v podstatě stejná. B.5 Slider a Spinner - nastavování hodnot Přestože se nejedná o dvojici komponent, které by na sobě byly závislé (jak tomu bylo u minulých sekcí), slouží tyto třídy ke stejnému účelu a liší se v podstatě pouze vizuálně. Tímto účelem je umožnit uživateli přehledných způsobem nastavovat a dále upravovat zadávané hodnoty. Obě třídy opět generují události typu Select ionevent a tudíž k jejich obsluze budeme využívat příslušný adaptér. Nejprve se blíže podíváme na třídu Slider. Tato třída v podstatě představuje posuvník (respektive lištu s posuvníkem), která reprezentuje rozsah hodnot, které jsou možné pomocí ní zadat (podobně jako například TTrackBar v Delphi nebo JSlider v balíku Swing). Aktuální pozice posuvníku představuje zvolenou hodnotu v daném rozsahu. Instanci vytvoříme konstruktorem: Slider (Composite parent, int style) - rodičovskou komponentou je opět některý z panelů či samotné aplikační okno. Dostupné styly umožňují nastavit orientaci posuvníku: 99

105 B.5. SLIDER A SPINNER - NASTAVOVÁNÍ HODNOT - HORIZONTAL - vodorovný posuvník, čím více je umístěn vpravo, tím větší hodnotu ve zvoleném rozsahu představuje. - VERT ICAL - vytvoření vertikálního posuvníku. Důležité metody této třídy slouží pro nastavení rozsahu a rychlosti pohybu posuvníku: addselectionlistener (SelectionListener listener) - nezbytné přidání posluchače. int getselection () - vrací aktuální pozici posuvníku (respektive hodnotu z daného rozsahu). set Increment (int value) - nastavení, o kolik se zvýší (sníží) zadaná hodnota a pozice posuvníku, pokud uživatel stiskne tlačítko pro zvýšení (snížení). Obvyklou hodnotou pro toto nastavení je 1. setmaximum (int value) - určuje maximální hodnotu rozsahu. setminimum (int value) - nejmenší hodnota rozsahu. setpagelncrement (int value) - umožňuje nastavit, o kolik bude hodnota zvýšena (snížena) při kliknutí na lištu vpravo (vlevo) od posuvníku. setselection (int value) - nastavení iniciální pozice posuvníku v daném rozsahu hodnot. setthumb (int value) -velikostposuvníku. Je nutné si uvědomit, že například při nastavení rozsahu 0-50 pomocí odpovídajících metod a velikosti posuvníku 10, bude maximální možná hodnota, kterou bude možné pomocí něj nastavit, 40. Jako příklad nám poslouží okno s textovým polem a instancí třídy Slider. Aktuální hodnota, určená pozicí posuvníku, se bude zobrazovat v textovém poli. Naše jednoduché okno ukazuje obrázek B.6: Obrázek B.6: Slider - nastavení hodnoty z rozsahu Postup je jednoduchý a jedná se v podstatě o aplikaci výše zmíněných metod: // připravíme si textové pole final Text text = new Text (shell, SWT.SINGLE SWT.CENTER SWT.BORDER); text.settext("0"); text.seteditable(false); 100

106 B.5. SLIDER A SPINNER - NASTAVOVÁNÍ HODNOT // vytvoříme instanci final Slider slider = new Slider(shell, SWT.HORIZONTAL); // nastavení nejmenší hodnoty slider.setminimum(0); // nejvyšší hodnota slider.setmaximum(50) ; // nastavení pohybu posuvníku při použití tlačítek slider.setincrement(1); // pohyb posuvníku při kliknutí na lištu slider.setpageincrement(10); // velikost (šířka) posuvníku slider.setthumb(1); // a nakonec implementujeme posluchač slider.addselectionlistener(new SelectionAdapter( ) { public void widgetselected(selectionevent e) { text.settext( new Integer(slider.getSelection( )).tostring( )); ); Přestože je v našem příkladě nastaven rozsah 0-50, je maximální možná hodnota, kterou můžeme zadat, 49. Například při nastavení šířky posuvníku na 5 by se jednalo o maximální hodnotu 45. Nyní se podíváme na třídu Spinner. Jedná se opět o nástroj pro modifikaci hodnot, jen s tím rozdílem, že umožňuje navíc hodnotu zadat a následně ji modifikovat. Za výhodu lze považovat skutečnost, že tato komponenta už sama o sobě obsahuje textové pole pro zobrazování hodnoty. Obě tlačítka pro modifikaci hodnoty připomínají instance třídy Button s použitím stylu ARROW. Za ekvivalentní komponenty můžeme považovat JSpinner z balíku Swing, případně také TSpinEdit z Delphi. Instanci vytvoříme prostřednictvím konstruktoru: Spinner (Composite parent, int style) - dostupné styly nebudeme nijak často využívat: - READ_ONLY - znemožnění uživatelského zadávání hodnot. - WRAP - nastavení zalamování řádků textu v přidruženém textovém poli. Metody jsou identické, jako v předchozím případě (samozřejmě však chybí metoda pro nastavení šířky posuvníku). Díky možnosti přímého zadávání hodnot je při překročení nastaveného rozsahu (podobně jako třeba u číselných oborů hodnot) nastavena hodnota 0. Za výhodu můžeme považovat skutečnost, že pro vizualizaci nastavené hodnoty nemusíme ani implementovat posluchač (jinými slovy, změnu čísla v textovém poli provádí tato komponenta automaticky při stisku tlačítek pro zvyšování či snižování hodnoty). V příkladě si ukážeme jen samotnou komponentu v okně a ukazuje ji obrázek B.7. Jak již jsme si uvedli, použití je v podstatě identické, jako tomu bylo v předchozím případě: 101

107 B.6. PROGRESSBAR - ZOBRAZENI PRŮBĚHU OPERACE // vytvoříme instanci a provedeme nastavení rozsahu final Spinner spinner = new Spinner(shell, SWT.BORDER); spinner.setminimum(0); spinner.setmaximum(50); spinner.setincrement(1);! SpinnerDemo I ID E SpinnerDemo ^^^^^^^^ F~ d 1* d Obrázek B.7: Spinner - použití komponenty Pro stejné funkční vlastnosti obou komponent se budeme v návrhu GUI pro jednu z nich rozhodovat spíše podle toho, která z nich se do našeho okna více hodí (jak rozměrově, tak vizuálně). B.6 ProgressBar - zobrazení průběhu operace Tato třída nám nabízí nástroj pro vizualizaci průběhu nějaké (typicky dlouhotrvající) akce. Její použití je v podstatě identické, jako je tomu u komponent JProgressBar v balíku Swing a TProgressBar v Delphi. Instanci vytvoříme konstruktorem: ProgressBar (Composite parent, int style) -dostupné styly umožňují nastavit vizuální podobu komponenty: - SMOOTH - umožňuje jemnější zobrazení průběhu, než je tomu v implicitním případě. - HORIZONTAL - horizontální ukazatel průběhu. VERT ICAL - vertikální ukazatel. - INDETERMINATE - zajímavá (ale zřejmě nepříliš často potřebná) možnost pro vytvoření neustále probíhajícího ukazatele. Názvy (a v podstatě i funkcionalita) jednotlivých nezbytných metod jsou stejné, jako tomu bylo u komponent v minulé sekci: int get Select ion () -vrací aktuální pozici průběhu. setmaximum (int value)- nastavuje maximální hodnotu ukazatele. Protože se většinou jedná o procentuální vyjádření, je obvykle využívanou hodnou 100. setminimum (int value) - minimální hodnota, nejčastěji se jedná o číslovku 0. setselection (int value) - iniciální nastavení ukazatele v daném rozsahu. 102

108 B.6. PROGRESSBAR - ZOBRAZENI PRŮBĚHU OPERACE Jako příklad si vytvoříme okno s instancí naší komponenty a tlačítkem, které odstartuje vlákno, jehož průběh budeme monitorovat v ukazateli, jak nám ukazuje obrázek B.8.! ProgressBarDe! ProgressBarDemo [ 5tart ^^^^^^^H 5tartf^ Obrázek B.8: ProgressBar - vizualizace průběhu operace Postup je opět triviální: // vytvoříme si instanci ukazatele final ProgressBar pb = new ProgressBar(shell, SWT.HOŘIZONTAL SWT.SMOOTH); // nastavíme minimum a maximum pb.setminimum(0); pb.setmaximum(10 0); // klasicky si vytvoříme tlačítko Button start = new Button(shell, SWT.PUSH SWT.CENTER) start.settext("start"); start.addselectionlistener(new SelectionAdapter( ) { public void widgetselected(selectionevent e) { for (int i = pb.getminimum(); i <= pb.getmaximum try { Thread.sleep (100); catch (Throwable th) { System.err.println("Chyba při zpracování"); // nastavíme průběh ukazatele pb.setselection (i); ); i + + ) { Použití této komponenty je velmi jednoduché a její schopnosti se uplatní všude, kde potřebujeme uživateli ukázat průběh operace. Typicky se jedná například o načítaní souborů z pevného disku nebo zobrazení průběhu načítání webové stránky. 103

109 B.7. BROWSER - WEBOVÝ PROHLÍŽEČ B.7 Browser - webový prohlížeč Poslední komponentou, na kterou se v této práci podíváme, je plně funkční prohlížeč webových stránek. Jedná se o vskutku vynikající komponentu, kterou můžeme snadno využít pro zobrazování nápovědy k našemu programu a samozřejmě také pro vytvoření webového prohlížeče. Pro svoji komplexnost (kterou ovšem pro základní účely ani nepotřebujeme) se jedná o celý balík org. eclipse. swt.browser, který obsahuje mimo jiné všechny potřebné posluchače. Jak si ale ukážeme, k vytvoření vlastního prohlížeče nám díky SWT stačí jen opravdu málo kroků, které zvládne skutečně každý začínající programátor. Instanci si vytvoříme konstruktorem: Browser (Composite parent, int style) - první parametrem je opět instance třídy Shell, či případně některý z panelů. Žádné speciální styly dostupné nejsou (tj. nejčastěji budeme používat SWT.NONE). Z dostupných metod si zmíníme alespoň následující (přičemž se nebudeme zajímat metodami na registraci posluchačů): boolean back () - vrátí se na předchozí zobrazenou stránku z historie. boolean execute (String script) - provedení zadaného skriptu. boolean forward () - akce, zobrazující následující stránku z historie. String geturl () - vrací adresu aktuálně zobrazené stránky. refresho - znovunačtení stránky. boolean seturl (String url) - nastavení adresy požadované stránky. stop () - zastaví probíhající načítání a zobrazování webové stránky. Za další výhodu lze považovat skutečnost, že (podobně jako třeba komponenta Text) tato komponenta již obsahuje implicitní pop-up menu, které obsahuje všechny potřebné akce pro práci s ní. Jako ukázkový příklad si "vytvoříme" základ webového prohlížeče s nastavenou domovskou stránkou vývojového prostředí Eclipse. Uvozovky v předchozí větě jsme si uvedli zcela záměrně, neboťcelá tvorba prohlížeče spočívá skutečně jen ve vytvoření jeho instance a tudíž je celý princip neuvěřitelně jednoduchý. Náš příklad ukazuje obrázek B.9. Postup snad ani nemůže být jednodušší: // připravíme si instanci okna shell = new Shell(display); shell.settext("browserdemo"); shell.setlayout(new FillLayout ()); // inicializujeme prohlížeč Browser browser = new Browser(shell, SWT.BORDER); 104

110 // nastavíme adresu požadované stránky browser.setur1(" B.7. BROWSER - WEBOVÝ PROHLÍŽEČ BrowserDemo ^Jn x feci ipse Welcome to eclipse.org about us projects downloads articles newsgroups community search \±\ Eclipse is an open source community whose projects are focused on providing an extensible development platform and application frameworks for building software. Eclipse provides extensible tools and frameworks that span the software development lifecycle, including support for modeling, language development environments for Java, C/C++ and others, testing and performance, -,+,-,11: ^ Obrázek B.9: Ukázka webového prohlížeče Pro tvorbu komplexnějšího webového prohlížeče bychom museli využít dostupných posluchačů. Především z rozsahových důvodů se však již touto problematikou nebudeme zabývat a je zřejmé, že jsme si již dostali do fáze, kdy už není problém se v SWT naučit něco nového, protože veškeré základy tohoto grafického prostředí již máme dávno za sebou. Právě z těchto důvodů byla tato komponenta poslední, se kterou se v této práci setkáme. Všem čtenářům, kteří se dočetli až sem, bych chtěl poblahopřát, protože dle mého názoru jsou plně připraveni začít programovat vlastní aplikace prostřednictvím SWT, případně si rozšířit znalosti a začít se učit JFace, jehož zvládnutí je při znalosti samotného SWT otázkou několika dní. Ještě si připomeňme, že další ukázkové příklady lze nalézt na serveru Java2s [Examples] a také na domovských stránkách SWT [Snippets]. 105