Interfata grafica cu utilizatorul
Interfata cu utilizatorul (User Interface) reprezinta principala modalitate de comunicare intre utilizatori si sistemele informatice. Limbajul Java ofera utilizatorilor diverse clase pentru implementarea functionalitatilor interfetei utilizator.
Principalele tipuri de interfete utilizator sunt urmatoarele:
• interfata utilizator in mod text: utilizatorul comunica cu sistemul informatic transmitand comenzi sub forma de linii de text prin intermediul unui limbaj de comanda;
• interfata utilizator grafica (GUI – Graphical User Interface): permite utilizatorului sa dea comenzi si sa introduca date prin actionarea unor obiecte grafice (butoane, meniuri, casete de dialog); in prezent comunicarea intre utilizatori si sistemele informatice se realizeaza, in general, prin intermediul interfetelor utilizator grafice (comunicare vizuala); cele mai raspandite interfete utilizator grafice sunt Windows (Microsoft), XWindow (Unix, Linux), Macintosh (Apple).
Pentru dezvoltarea de aplicatii Java cu interfata grafica trebuie avuta in vedere independenta de platforma. Acest aspect a fost rezolvat prin punerea la dispozitia utilizatorilor a unor componente grafice abstacte care sa poata fi implementate pe diferite platforme.
Limbajul Java pune la dispozitia programatorilor doua modalitati de implementare a interfetelor grafice pentru aplicatii, prin intermediul a doua pachete principale de clase:
• java.awt: AWT (Abstract Window Toolkit) este disponibil incepand cu primele versiuni ale limbajului Java; ofera un set de clase care permit realizarea de interfete grafice in care se utilizeaza obiecte grafice (componente) specifice platformei pe care se executa programul; afisarea unei componente awt pe ecran utilizeaza cod nativ; astfel, la executia unei aplicatii cu interfata grafica pe un sistem Windows sunt utilizate elemente ale interfetei grafice corespunzatoare unui sistem Windows, in vreme ce la executia aceleiasi aplicatii pe un sistem Macintosh sunt utilizate elemente specifice interfetei grafice Macintosh;
• javax.swing: face parte dintr-un proiect mult mai amplu, JFC (Java Foundation Classes), care ofera facilitati pentru dezvoltarea de interfete grafice, precum si adaugarea de elemente grafice si interactivitate in aplicatii; adauga noi clase la cele oferite de java.awt, clase care permit imbunatatirea interfetelor grafice; ofera posibilitatea realizarii de interfete grafice ale caror aspect nu depinde de platforma pe care se executa programul.
Crearea unei aplicatii cu interfata grafica presupune realizarea urmatorilor pasi:
• crearea unei suprafete de afisare pe care vor fi dispuse obiectele grafice;
• crearea si asezarea componentelor pe suprafata de afisare;
• definirea unor actiuni care trebuie sa se execute in momentul in care utilizatorii interactioneaza cu obiectele grafice ale aplicatiei;
• gestionarea evenimentelor generate de obiectele grafice in momentul interactiunii cu utilizatorul si executarea unor actiuni corespunzatoare;
• afisarea interfetei grafice.
package ro.virtualcampus.gui; | |
import javax.swing.*; | |
public class InterfataGrafica { | |
public static void main(String args[]) { | |
JFrame fereastra = new JFrame("Exemplu interfata grafica"); | |
fereastra.setSize(300, 100); | |
fereastra.setLocation(200, 200); | |
fereastra.getContentPane().add(new JLabel("Eticheta fereasta principala")); | |
fereastra.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); | |
fereastra.setVisible(true); | |
} | |
} |
La afisarea unei interfete grafice interpretorul porneste un nou fir de executie pentru a urmari interactiunea utilizatorului cu interfata grafica. Acest fir de executie asteapta pana cand utilizatorul apasa o tasta, muta cursorul, face selectii prin intermediul mouse-ului sau orice alta actiune care afecteaza interfata grafica. La aparitia unui astfel de eveniment este apelat unul din analizoarele de evenimente care au fost stabilite pentru interfata grafica. Tratarea evenimentelor aparute se va realiza prin intermediul aceluiasi fir de executie.
Pachetele awt si swing
Pachetul java.awt (Abstract Window Toolkit) reprezinta primul set de componente grafice introdus in Java API. Contine clase care permit atat crearea interfetelor grafice, cat si crearea si prelucrarea imaginilor. Conform AWT, un obiect specific interfetelor grafice poarta numele de componenta grafica sau obiect grafic. Unele componente grafice au atasate evenimente care permit interactiunea cu utilizatorul. Pentru gestionarea evenimentelor declansate de componentele grafice este utilizata ierarhia AWTEvent.
De asemenea, pachetul java.awt introduce conceptul de container. Un container reprezinta o componenta care poate contine atat componente grafice, cat si alte containere. Unui container ii este asociat un manager (gestionar) de pozitionare, care stabileste modul de afisare a componentelor in interiorul containerului.
Dupa cum se poate observa din figura urmatoare, obiectele grafice oferite in pachetul java.awt au la baza superclasa abstacta Component. O alta clasa importanta din pachetul java.awt este clasa Container, care reprezinta superclasa pentru clasele care permit definirea suprafetelor de afisare.
Din clasa Component sunt derivate clase pentru obiecte grafice, precum Button(butoane), Checkbox (butoane de marcaj), RadioButton (butoane radio),TextComponent (componente text), Label (etichete), Scrollbar (bare de derulare), Container (suprafete de afisare), Choice (liste ascunse) sau List (liste).
Pachetul javax.swing este construit plecand de la componentele grafice descrise in pachetul java.awt. In plus, acesta ofera o arhitectura pentru componente grafice care permite configurarea, atat a aspectului, cat si a comportamentului componentelor grafice. Componentele grafice din AWT si Swing pot fi utilizate impreuna, oferind posibilitatea adaugarii de suport Swing la aplicatii grafice realizate prin intermediul AWT.
In pachetul javax.swing clasele care descriu componente grafice au nume care incep cu litera J si extind clasa abstracta JComponent. Acest pachet contine nu mai putin de 250 noi clase si 75 interfete.
Suprafete de afisare
Suprafetele de afisare sunt componente grafice care pot include alte componente. In limbajul Java suprafetele de afisare mai sunt denumite si containere, si sunt descrise prin intermediul claselor derivate din clasa abstacta Container. Avand in vedere faptul ca un container este tot o componenta grafica, acesta poate include la randul lui alte containere.
Suprafetele de afisare reprezinta suportul pentru componentele grafice. Oricarei aplicatii cu interfata grafica ii corespunde o suprafata de afisare principala (de tip Frame) si una sau mai multe suprafete de afisare aditionale.
In pachetul java.awt sunt oferite doua subclase pentru clasa care descrie suprafetele de afisare (Container):
• Window: permite implementarea de suprafete de afisare de tip fereastra; din clasa Window sunt derivate clasele Frame (pentru suprafetele de afisare principale dintr-o aplicatie cu interfata grafica) si Dialog (pentru ferestre de dialog);
• Panel: permite implementarea de suprafete de afisare fara reprezentare grafica care sunt utilizate pentru gruparea componentelor grafice.
Clasele pentru suprafete de afisare din pachetul java.awt (Window, Frame, Dialog, Panel) prezinta clase corespondente in pachetul javax.swing (JWindow, JFrame, JDialog, JPanel).
Clasa JFrame permite crearea unei fereste de aplicatie grafica, fereastra care include urmatoarele elemente: o bara de titlu, o margine si butoane sistem (butoane de minimizare, maximizare si inchidere). Clasa JFrame din pachetul javax.swing este derivata direct din clasa Frame a pachetului java.awt. Componentele grafice adaugate la o fereastra constituie continutul ferestrei respective si sunt administrate prin intermediul unui panou implicit, contentPane. Pentru a adauga o componenta in interiorul unei ferestre de tip JFrame, aceasta trebuie adaugata in panoul de continut.
myJFrame.getContentPane().add(component);
Urmatoarea aplicatie grafica stabileste o fereastra principala care are titlul Interfata grafica si care contine o eticheta. Pentru fereastra principala sunt stabilite dimensiunile, prin metoda setSize(), si locatia de afisare pe ecran, prin metoda setLocation().
package ro.virtualcampus.gui; | |
import javax.swing.*; | |
public class InterfataGrafica { | |
public static void main(String args[]) { | |
JFrame fereastra = new JFrame("Interfata grafica"); | |
fereastra.setSize(300, 100); | |
fereastra.setLocation(200, 200); | |
fereastra.getContentPane().add(new JLabel("Eticheta fereasta principala")); | |
fereastra.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); | |
fereastra.setVisible(true); | |
} | |
} |
Pentru a obtine inchiderea automata a unei aplicatii atunci cand este apasat butonul de inchidere corespunzator unei ferestre se poate utiliza urmatoarea metoda:
myJFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Clasa JWindow permite crearea unei ferestre care spre deosebire de cele de tip JFrame nu contine o bara de titlu, butoane sistem si nu poate fi redimensionata. O astfel de fereastra se utilizeaza, in general, pentru a afisa mesaje.
Clasa JDialog permite crearea unei ferestre de dialog care este dependenta de o fereastra principala de tip JFrame. Ferestrele de dialog permit interactiunea utilizatorilor cu interfata grafica si pot fi modale (blocheaza aplicatia pana la inchiderea dialogului) sau nemodale (nu blocheaza aplicatia). La un moment dat nu poate fi creata decat o singura fereastra de dialog modala si atata timp cat aceasta este activa fereastra principala ignora actiunile utilizatorului. In schimb, intr-o fereastra principala pot fi create oricate ferestre de dialog nemodale, fiecare dintre ele operand independent de celelalte. In acest caz utilizatorul are control independent asupra ferestrei principale a aplicatiei grafice.
In plus, pachetul javax.swing ofera clase pentru ferestre de dialog specializate, precum JFileChooser (permite selectarea unui fisier) si JColorChooser (permite alegerea unei culori).
Suprafetele de afisare fara reprezentare grafica (JPanel, JScrollPane) reprezinta containere prin intermediul carora pot fi organizate intr-un mod eficient componentele unei aplicatii grafice. Containerele de tip JPanel sau JScrollPane mai sunt denumite panouri si pot fi imbricate.
Clasa JPanel este derivata din clasa Panel a pachetului java.awt. Adaugarea unei componente grafice la panou se realizeaza prin intermediul metodei add().
myJPanel.add(componenta);
Clasa JScrollPane permite crearea unei panou care ofera suport pentru derularea pe orizontala si verticala a componentelor a caror reprezentare grafica nu incape in suprafata de afisare.
Clasa Container contine metode comune tuturor suprafetelor de afisare, precum:
• add(): permite adaugarea unei componente grafice in interiorul unei suprafete de afisare;
• remove(): elimina o componenta grafica de pe o suprafata de afisare;
• setLayout(): stabileste modalitatea de pozitionare (dispunere) a componentelor grafice intr-un container.
Gestionarea pozitionarii
Daca intr-un container sunt introduse mai multe componente este foarte important sa se stabileasca pozitia acestora pe suprafata de afisare. Acest lucru este realizat prin intermediul unuia din managerii de pozitionare (LayoutManager) pusi la dispozitie prin intermediul pachetelor de clase care permit realizarea de interfete grafice.
Un manager de pozitionare (Layout Manager) asigura dispunerea si redimensionarea automata a componentelor situate intr-un container atat la crearea containerului, cat si la modificarea dimensiunii acestuia. Atasarea explicita a unui manager de pozitionare la un container se face cu metoda setLayout().
container.setLayout(managerPozitionare);
Fiecare clasa care extinde clasa Container detine un manager de pozitionare implicit. Astfel, pentru suprafete de afisare de tip Frame sau JFrame implicit se utilizeaza BorderLayout, iar pentru suprafete de afisare de tip Panel sau JPanel se utilizeaza FlowLayout.
Dispunerea componentelor grafice poate fi realizata in mai multe feluri, in functie de managerul de pozitionare utilizat:
• FlowLayout: dispunere secventiala; componentele grafice sunt plasate una dupa alta, in flux liniar (de la stanga la dreapta si de sus in jos); numarul de componente de pe o linie depinde atat de dimensiunea componentelor, cat si de dimensiunea containerului; poate fi specificat modul de aliniere al componentelor prin intermediul constructorului sau a metodei setAlignment() cu unul din urmatorii parametri: FlowLayout.RIGHT, FlowLayout.LEFT, FlowLayout.CENTER;
package ro.virtualcampus.gui; | |
import java.awt.*; | |
import javax.swing.*; | |
public class FlowLayoutApp { | |
public static void main(String args[]) { | |
JFrame container = new JFrame("Flow Layout"); | |
container.setLayout(new FlowLayout(FlowLayout.CENTER)); | |
container.setLocation(100, 100); | |
container.add(new JLabel("Eticheta 1")); | |
container.add(new JLabel("Eticheta 2")); | |
container.add(new JLabel("Eticheta 3")); | |
container.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); | |
container.pack(); | |
container.setVisible(true); | |
} | |
} |
• BoxLayout: dispunere pe directii; componentele grafice sunt pozitionate dupa o singura directie, orizontala sau verticala; permite stabilirea unor limite pentru fiecare componenta prin setMinimumSize() si setMaximumSize(); componentele pot fi aliniate prin intermediul metodelor setAlignmentX() si setAlignmentY(); pot fi stabilite spatii de dimensiune fixa, respectiv variabila, intre componente prin: createHorizontalGlue(), createVericalGlue(), createRigidArea();
package ro.virtualcampus.gui; | |
import java.awt.*; | |
import javax.swing.*; | |
public class BoxLayoutApp { | |
public static void main(String args[]) { | |
JFrame container = new JFrame("Box Layout"); | |
JPanel panou = new JPanel(); | |
panou.setLayout(new BoxLayout(panou, BoxLayout.Y_AXIS)); | |
JButton buton1, buton2, buton3; | |
panou.add(buton1 = new JButton("Buton 1")); | |
buton1.setAlignmentX(Component.LEFT_ALIGNMENT); | |
panou.add(Box.createRigidArea(new Dimension(0, 10))); | |
panou.add(buton2 = new JButton("Buton 2")); | |
buton2.setAlignmentX(Component.CENTER_ALIGNMENT); | |
buton2.setMinimumSize(new Dimension(100, 25)); | |
buton2.setMaximumSize(new Dimension(500, 500)); | |
panou.add(Box.createVerticalGlue()); | |
panou.add(buton3 = new JButton("Buton 3")); | |
buton3.setAlignmentX(Component.RIGHT_ALIGNMENT); | |
container.add(panou); | |
container.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); | |
container.pack(); | |
container.setVisible(true); | |
} | |
} |
• BorderLayout: dispunere marginala; componentele grafice sunt dispuse pe margini, iar una dintre ele este plasata in centru; imparte suprafata de afisare in cinci regiuni corespunzatoare celor patru puncte cardinale si centrului; la adaugarea unei componente, metoda add() va specifica si zona in care aceasta va fi amplasata: NORTH, SOUTH, EAST, WEST, CENTER; in fiecare zona poate fi adaugata o singura componenta sau un singur container;
package ro.virtualcampus.gui; | |
import java.awt.*; | |
import javax.swing.*; | |
public class BorderLayoutApp { | |
public static void main(String args[]) { | |
JFrame container = new JFrame("Border Layout"); | |
container.setLayout(new BorderLayout()); | |
container.setLocation(100, 100); | |
container.add(new JButton("North"), BorderLayout.NORTH); | |
container.add(new JButton("South"), BorderLayout.SOUTH); | |
container.add(new JButton("East"), BorderLayout.EAST); | |
container.add(new JButton("West"), BorderLayout.WEST); | |
container.add(new JButton("Center"), BorderLayout.CENTER); | |
container.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); | |
container.pack(); | |
container.setVisible(true); | |
} | |
} |
• GridLayout: dispunere tabelara; componentele grafice sunt plasate in celulele unei grile rectangulare, de la stanga la dreapta si de sus in jos; prezinta doi constructori care permit stabilirea numarului de linii, respectiv coloane, dar si a spatiului dintre componente; GridLayout(int rows, int cols); GridLayout(int rows, int cols, int hgap, int vgap);
package ro.virtualcampus.gui; | |
import java.awt.*; | |
import javax.swing.*; | |
public class GridLayoutApp { | |
public static void main(String args[]) { | |
JFrame container = new JFrame("Grid Layout"); | |
container.setLayout(new GridLayout(2, 2)); | |
container.setLocation(100, 100); | |
container.add(new JButton("Buton 1")); | |
container.add(new JButton("Buton 2")); | |
container.add(new JButton("Buton 3")); | |
container.add(new JButton("Buton 4")); | |
container.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); | |
container.pack(); | |
container.setVisible(true); | |
} | |
} |
• GridBagLayout: dispunere tabelara neproportionala; componentele grafice sunt plasate in celulele unei grile, dar unele dintre ele pot acoperi mai multe celule.