Graafikakomponendi loomine

Omatehtud jooniste ning komponentide aluseks sobib lõuend (Canvas). Ta 
sobib lihtsaks joonistamiseks, kuid samas saab ta panna ka teateid vastu võtma, s.t. 
näiteks hiirevajutusele reageerima.  Kui oled kord komponendi loonud, siis saad 
seda tervikuna kasutada seal kus parajasti vaja on. Kui oled komponendi tööga 
rahul, siis võid tarvitada teda ilma sisemisse ehitusse süvenemata. Alati ei pea 
komponendi loomisel kõike otsast tegema, vaid võib kasutada juba varem olemas 
olevaid tükke. Samuti võib luua varemvalmistatud komponendile alamklassi ning 
seal soovitud meetodid muuta. Nii võib kerge vaevaga lisada tekstialale võimaluse, 
et ta väljastaks oma sees oleva ridade arvu või paneks lisatavatele ridadele tühikud 
ette. Kui aga tahetakse sündmused ja kujundused täiesti ise määrata, siis tuleb 
aluseks võtta tühi pind ehk lõuend. 
	Siin näites joonistatakse lõuendile soovitud nurkade arvuga hulknurk. 
Nurkade arvu saavad väljapoolsed muuta vaid meetodi abil. Iga muutmisega 
kaasneb uus joonistamine.


import java.awt.*;
public class Nurgad extends Canvas{
  protected int nurkadearv;
  public Nurgad(){
    nurkadearv=3;
  }
  public Nurgad(int uusarv){
    nurkadearv=uusarv;
  }

  public void muudaNurkadeArv(int uusarv){
    nurkadearv=uusarv;
    repaint();
  }

  public void paint(Graphics g){
    int korgus=getSize().height;
    int laius=getSize().width;
    double nurgavahe=2*Math.PI/(double)nurkadearv;
    int raadius=Math.min(korgus, laius)/3;
    int keskx=laius/2;
    int kesky=korgus/2;
    int vanax=keskx;
    int vanay=kesky+raadius;
    int uusx, uusy;
    for(int i=1; i<=nurkadearv; i++){
      uusx=keskx+(int)(raadius*Math.sin(i*nurgavahe));
      uusy=kesky+(int)(raadius*Math.cos(i*nurgavahe));
      g.drawLine(vanax, vanay, uusx, uusy);
      vanax=uusx;
      vanay=uusy;
    }
  }
}

Loodud komponenti saab kasutada seal, kus vaja hulknurki joonistada. Siin näites 
pannakse rakendi ekraanile üheksa hulknurka, nurkade arvuga kolmest 
üheteistkümneni. 

import java.applet.Applet;
public class Nurgarakend extends Applet{
  public void init(){
    setLayout(new java.awt.GridLayout(3, 3));
    for(int nr=3; nr<12; nr++){
      add(new Nurgad(nr));
    }
  }
}

Samuti saab loodud komponendi abil lasta kasutajal valida, mitme nurgaga 
hulknurka soovib. Selleks panin rakendile kerimisriba ning loodud komponendi. 
Rakendi panin kerimisriba kuulajaks (AdjustmentListener). Kui kerimisriba 
määratud koha väärtust muudetakse, siis saadetakse uus väärtus rakendile, kes selle 
omakorda saadab hulknurka joonistavale komponendile. 

import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class Nurgarakend2 extends Applet implements 
AdjustmentListener{
  Nurgad ng=new Nurgad();
  Scrollbar sb=new Scrollbar(
    Scrollbar.VERTICAL, 3, 2, 2, 20
  );
  public void init(){
    setLayout(new BorderLayout());
    add("West", sb);
    add("Center", ng);
    sb.addAdjustmentListener(this);
  }

  public void adjustmentValueChanged(AdjustmentEvent e){
    ng.muudaNurkadeArv(e.getValue());
  }
}


Graphics2D
Põhilised joonistamisfunktsioonid on klassis java.awt.Graphics. Alates 
versioonist 1.2 pakub laiendatud joonistamisvõimalusi eelmise alamklass 
Graphics2D. Kui esimesel juhul tuli alati arvutada ekraanikoordinaatides ning joone 
laiuseks oli üks punkt, siis siin võib valida omale sobiva taustsüsteemi ning ka 
joonistamisel saab enam parameetreid määrata. Kuna Graphics2D on klassi 
Graphics alamklass, siis ta oskab kõike mida eellanegi ning vajadusel saab temaga 
joonistada samade meetoditega, mis klassist Graphics omale sisse harjunud. 
Ühilduvuse huvides on komponendi meetodi paint parameetriks endiselt Graphics, 
kuid tegelikult antakse sellesse meetodisse joonistamiseks isend, kes suudab ka 
Graphics2D klassis kirjeldatud operatsioone täita. Juhul, kui spetsiifilisi omadusi 
vajatakse, tuleb muutuja tüüp enne teisendada. 
Joone omadused
	Joone tõmbamisel saab Graphics2D juures klassi BasicStroke abil määrata 
joone laiust, otsa kuju ning kahe joone ühendust (võimalused leiad API 
dokumetatsioonist). 

import java.awt.*;
public class Joon1 extends Canvas{
  public void paint(Graphics alggr){
    Graphics2D g=(Graphics2D)alggr;
    float laius=15;
    int jooneots=BasicStroke.CAP_ROUND;
    int uhendus=BasicStroke.JOIN_BEVEL;
    g.setStroke(new BasicStroke(laius, jooneots, uhendus));
    g.drawRect(10, 10, 70, 100);
    g.drawLine(100, 10, 140, 200);
  }
}
Joonistusala piiramine
Joonistamisala on võimalik piirata käsuga clip, andes ette kujundi, mille piires tohib 
joonistada. Siin näites määratakse joonistamise alaks ellipsi pind ning seejärel 
joonestatakse seest täidetud ristkülik. Tulemusena tekib ekraanile vaid ellipsi ning 
ristküliku ühisosa. 

import java.awt.*;
import java.awt.geom.*;
public class Kujund1 extends Canvas{
  public void paint(Graphics alggr){
    Graphics2D g=(Graphics2D)alggr;
    Shape kujund=new Ellipse2D.Float(10, 10, 300, 100);
    g.clip(kujund);
    g.fillRect(20, 20, 400, 60);
  }
}

Venitamine, keeramine
Joonistuspinda saab liigutada, venitada ja keerata. AffineTransform'i abil saab 
määrata, kuidas ja kui palju. Esimese näite puhul lükatakse koordinaatide 
alguspunkti saja ühiku võrra paremale ning alla. 

import java.awt.*;
import java.awt.geom.AffineTransform;
public class Transform2 extends Canvas{
  public void paint(Graphics alggr){
    Graphics2D g=(Graphics2D)alggr;
    g.setTransform(AffineTransform.getTranslateInstance(100, 100));
    g.fillRect(20, 20, 40, 20);
  }
}

rida
g.setTransform(AffineTransform.getScaleInstance(3, 1.5));
suurendab joonist x-telje suunas 3 ning y-suunas 1,5 korda. 

g.setTransform(AffineTransform.getRotateInstance(Math.PI/4, 100, 75));
keerab joonist Pi/4 ehk 45 kraadi võrra ümber punkti 100, 75

g.setTransform(AffineTransform.getShearInstance(Math.PI/4, 0));
keerab püsttelge Pi/4 võrra. 

Kui soovida mitut muutust üheskoos, siis võib luua AffineTransform tüüpi isendi 
ning talle soovitud muutusi järjekorras rakendada. 

import java.awt.*;
import java.awt.geom.AffineTransform;
public class Transform6 extends Canvas{
  public void paint(Graphics alggr){
    Graphics2D g=(Graphics2D)alggr;
    AffineTransform tr=new AffineTransform();
    tr.rotate(Math.PI/4, 50, 100);
    tr.translate(150, 0);
    g.setTransform(tr);
    g.fillRect(20, 20, 40, 20);
  }
}

Muster, värviüleminek
Joonistamisel saab lisaks ühele värvile soovi korral pinda katta ka nii 
värviülemineku kui piltidest koostatud mustriga. Soovitud katmisstiil tuleb määrata 
Graphics2D meetodiga setPaint. Värviülemineku andmeid kannab GradientPaint. 
Konstruktoris tuleb määrata kaks punkti ning kummagi punkti juurde kuuluv värv. 
Nendes punktides vastab joonise värv sinna määratud värvile, punkte ühendaval 
sirget mööda muutub värv sujuvalt ühest värvist teiseks. Tavajuhul jääb kummagi 
punkti "selja taha" punktile vastav värv, kuid kui lisada konstruktorisse 
tõeväärtusmuutuja, siis saab panna värvi tsükliliselt lainetama nii, et laine pikkuseks 
jääb kahe punkti vahe. 


import java.awt.*;
import java.awt.geom.*;
public class Kujund2a extends Canvas{
  public void paint(Graphics alggr){
    Graphics2D g=(Graphics2D)alggr;
    g.setPaint(new GradientPaint(0, 100, Color.yellow,
               getSize().width, 100, new Color(0, 200, 100)
    ));
    g.fillRect(0, 0, getSize().width, getSize().height);
  }
}
	Pinna mustriga katmisel tuleks kasutada klassi TexturePaint võimalusi, 
andes konstruktorile parameetriks pildi millega katta, lisaks ka pildi suuruse ja 
asukoha, millest alates pilte kõrvuti laduda. 
Kujundi äärejooned
	Kujundi (näiteks ellipsi) äärejooned annab BasicStroke meetod 
createStrokedShape. Nii näiteks on võimalik kujundist vaid äärejooned välja 
joonistada või siis teise värviga esile tuua.

public void paint(Graphics alggr){
    Graphics2D g=(Graphics2D)alggr;
    BasicStroke b1=new BasicStroke(15);
    Shape kujund=b1.createStrokedShape(
      new Ellipse2D.Float(100, 100, 50, 70)
    );
    g.fill(kujund);
    g.setColor(Color.green);
    g.draw(kujund);
  }

	Kuna nii ellips on kujund ning ka jämedajoonelise ellipsi äärejooned on 
samuti kujundid, siis juhul, kui annan äärejoontele jämeduse, võin ka nendelt 
omakorda äärejooned küsida. Nii saan tulemuseks juba neli joont: kaks üksteisele 
lähedal asuvat ovaali sees ning teised kaks ovaali välisringis. 

  public void paint(Graphics alggr){
    Graphics2D g=(Graphics2D)alggr;
    BasicStroke b1=new BasicStroke(15);
    BasicStroke b2=new BasicStroke(3);
    Shape kujund=b1.createStrokedShape(
      new Ellipse2D.Float(100, 100, 50, 70)
    );
    Shape kujund2=b2.createStrokedShape(kujund);
    g.draw(kujund2);
  }

Kui sooviksin nende joontega midagi eraldi teha, näiteks neid igaüht 
isevärvi värvida, siis on mul võimalik kujund joonteks jagada klassi PathIterator 
abil. Selle abil saan kätte iga joone andmed. Sirgjoonel piisab kahest punktist. 
Kolme punkti abil määratakse kõverjoon, kus kaks punkti on otspunktideks ning 
kolmas näitab, milline peab kaar tulema. Nelja punktiga määratud joone puhul on 
samuti kaks otspunktideks, ülejäänud kahe punkti abil aga määratakse joone suunda 
otspunktist väljumisel.
	Uusi kujundeid aitab kombineerida  klass GeneralPath. Talle tuleb lihtsalt 
öelda millise koha peale joon või ring või muu olemasolev kujund paigutada. 
Kriipsujuku saab tema abil küllalt kergesti valmis ning siis võib seda kasutada nagu 
iga muud kujundit. 

public void paint(Graphics alggr){
    Graphics2D g=(Graphics2D)alggr;
    GeneralPath gp=new GeneralPath();
    gp.append(new Ellipse2D.Float(20, 50, 40, 40), false);
    gp.append(new Line2D.Float(40, 100, 40, 150), false);
    g.draw(gp);
}



Pilditöötlus

Image on java jaoks nii väljastpoolt failist võetud kui ise joonistatud pilt. 
Tühja pildi joonistamiseks saab luua meetodi createImage abil.  Image osutab pildi 
andmetele, tema kaudu saab pilti kusagil näidata. Pildi muutmiseks tuleb pildilt 
küsida klass Graphics (või tema alamklass Graphics2D). Selle nn. graafilise 
konteksti juures on meetodid, mille abil saab pildile midagi (juurde) joonistada.  
Valmis pilti kuhugile joonistades saab määrata tema kõrgust ja laiust, Graphics2D 
abil ka keerata või venitada. Võib mitmest pildist ühe kokku kombineerida ning 
sinna vajadusel jooni,  ringe ja muid kujundeid juurde joonistada. Keerulisemate 
kujundite loomisel on kiiremaks mooduseks ta mälus punkti kaupa välja arvutada 
ning siis loodud massiivist pilt luua. Nii saab näiteks värviüleminekute juures ilusti 
igale punktile värvi arvutada ning hoolitseda, et ükski punkt värvita ei jääks. Pilti 
arvudeks muutes saab pildi andmed näiteks faili salvestada või Interneti kaudu 
teisele kasutajale saata. Ka on selle abil võimalik pilti analüüsida. Kui pildi käest 
andmed küsida ning pärast nende muutmist andmetest uus pilt luua, siis saab pilti 
päris mitut moodi mõjutada. Võib ühe värvi teisega asendada, kujundite piirpindu 
silendada või teravdada. Suurema mõttetöö korral ka olemasolevast pildist 
kujundeid eraldada ning nendega omaette midagi ette võtta (näiteks raamatust 
kopeeritud pildist teksti välja lugeda).
Animatsiooni puhul on mõistlik uus ekraanipilt enne mälus valmis teha 
ning alles siis ekraanile joonistada. Sellisel juhul ei hakka pilt uue kujundi loomise 
ajal vilkuma. Animatsioon võtab suhteliselt palju ressursse, kuid võtete abil saab 
liikumist näidata ka  aeglasema arvuti peal. Kui taust püsib paigal ning vaid 
esiplaani kujund liigub, siis piisab tausta korra valmistamisest ning iga uue pildi 
loomiseks joonistada taust alla ning kujund sobivasse kohta peale. Veelgi enam: 
piisab, kui taust joonistada vaid selle osa peale, kus liikuv kujund viimati oli 
(meetod clip laseb määrata, millisesse pildi piirkonda joonistada, mujale suunatud 
joonistuskäsud jäävad täitmata). Kui liikumine piirdub vaid mõne(teistkümne) pildi 
vahetamisega, siis on mõistlikum pildid enne välja arvutada/joonistada ning siis 
ükshaaval ringis vahetada. 


Kopeerimine

Programmide sees ning ka programmide vahel kasutatakse andmete 
vahetamiseks mälupuhvrit (clipboard). Sinna saab andmeid paigutada ning sealt 
vajadusel kopeerida. Kui puhver on operatsioonisüsteemi juures ning sinna pääsevad 
ligi mitmed programmid, siis saab selle abil nende vahel andmeid vahetada. Et 
andmeid sobiksid, peavad osapooled aru saama andmete formaadist. Kõige 
lihtsamaks formaadiks on lihtne tekst, kuid selle kaudu saab kõike vahetada, mida 
on võimalik baitideks muundada.
Järgnevast näitest suurem osa kulub kujundusele, kus luuakse raam, 
pannakse sinna sisse tekstiväli, tekstiala ning menüü. Kopeerimine ja kleepimine 
asub meetodis actionPerformed, mis  käivitub menüüst valiku tegemisel. Vastavalt 
menüürea nimele käivitatakse tegevus. Meetodi algul küsitakse juurdepääs 
operatsioonisüsteemi mälupuhvrile.
Clipboard clipboard = getToolkit().getSystemClipboard();
Kui antakse korraldus Copy, siis võetakse tekstiväljast tekst ning muudetakse ta 
StringSelection'iks. Viimatinimetatud klassis on tekst kujul, mida saab 
mälupuhvrisse panna ning mida teised programmid lugeda mõistavad. 
StringSelection data = new StringSelection(tf.getText());
Seejärel öeldakse, et mingu see tekst mälupuhvrisse. Meetodi teiseks parameetriks 
on ClipboardOwner, kellele saadetakse teade puhvri sisu vahetumisest. 
      clipboard.setContents(data, data);
	Kleepimise puhul võetakse teade mälupuhvrist välja ning pannakse ta 
tekstialasse. Puhvrist saadakse andmed kätte esialgu tüübina Transferable, mis tuleb 
seejärel sobivaks tüübiks muundada. Transferable käest on võimalik küsida millisel 
kujul ta andmeid kannab. Siin aga eeldame, et tegemist on sõnega ning palume tal 
sellisena need andmed ka välja anda.
Transferable clipData = clipboard.getContents(this);
String s = 
(String)(clipData.getTransferData(DataFlavor.stringFlavor));
Tulemuseks on programm, mille abil saab andmeid tekstina programmide 
vahel vahetada. Selgitust vajab ka ehk menüü loomine. Algul luuakse menüüriba 
(MenuBar), sinna külge pannakse menüü(d)  (Menu) ning viimasesse menüüread 
(MenuItem). Menüüridadele öeldakse, kellele nende peale vajutamisel teateid saata. 

import java.io.*;
import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.event.*;

public class ClipMe extends Frame 
 implements ActionListener {
  TextField tf;
  TextArea ta;
  public static void main (String args[]) {
    new ClipMe().show();
  }
  public ClipMe() {
    super("Clipping Example");
    add(tf = new TextField("Welcome"), "North");
    add(ta = new TextArea(), "Center");
    MenuBar mb = new MenuBar();
    mb.add(makeEditMenu());
    setMenuBar(mb);
    setSize(250, 250);
   
  }

     
  Menu makeEditMenu() {

    Menu editMenu = new Menu("Edit");
    MenuItem mi = new MenuItem("Cut");
    mi.addActionListener(this);
    editMenu.add(mi);
    mi = new MenuItem("Copy");
    mi.addActionListener(this);
    editMenu.add(mi);
    mi = new MenuItem("Paste");
    mi.addActionListener(this);
    editMenu.add(mi);
    mi = new MenuItem("Clear");
    mi.addActionListener(this);
    editMenu.add(mi);
    return editMenu;
  }


  public void actionPerformed (ActionEvent evt) {

    Clipboard clipboard = getToolkit().getSystemClipboard();
    String cmd = evt.getActionCommand();
    if (cmd.equalsIgnoreCase("copy")) {
       StringSelection data = new StringSelection(tf.getText());
       clipboard.setContents(data, data);
    }
    else if (cmd.equalsIgnoreCase("clear")) {
      tf.setText("");
    } 
    else if (cmd.equalsIgnoreCase("paste")) {
      Transferable clipData = clipboard.getContents(this);
      String s;
      try {
        s = 
(String)(clipData.getTransferData(DataFlavor.stringFlavor));
      } 
      catch (Exception e) {
        s = e.toString();
      }
      ta.setText(s);
    }
    else if (cmd.equalsIgnoreCase("cut")) {
       StringSelection data = new StringSelection(tf.getText());
       clipboard.setContents(data, data);
       tf.setText("");
    }
  }
}


Andmete vedamine (Drag and Drop)

Lisaks mälupuhvri abil kopeerimisele püütakse andmete ülekannet ka 
hiirega vedamise abil kasutajale intuitiivsemaks muuta. Enamik meist on 
tõenäoliselt hiirega Word'i redaktoris sõnu lauses ringi tõstnud või Windows 
Exploreri aknas faile ühest kataloogist teise lohistanud. Andmete allikaks või 
suudmeks saab määrata ükskõik millise komponendi, kes on võimeline hiire teateid 
vastu võtma. Komponendile tuleb määrata sündmus, mille peale ta end andmete 
allikaks loeb. Sageli on selleks näiteks hiire vajutus ning lohisemine tema peal 
vähemalt viie punkti ulatuses. Kui andmed on kord liikuma pandud, saab nende 
"käekäigu" üle teateid andmeveo kuulari abil, kes teatab hiire sattumisest võimaliku 
vastuvõtja alasse.
Andmete vastuvõtjalgi on kuular. Tema saab teateid enesele sattunud 
andmetega varustatud hiirest ning on võimeline vastavalt nendele teadetele käituma. 
Ta saab võrrelda pakutavat andmete tüüpi enese poolt vastu võtta suudetavate 
andmetüüpidega ning sellest kasutajale teadma andma. Kui hiire klahv lastakse 
vastuvõtja kohal lahti, siis saabub teade drop ning andmed võib vastu võtta. 
Siin näites luuakse raam kolme sildiga. Ülemised kaks on andmete allikaks 
ning nende siltide pealt vedama hakkamisel kaasneb andmetena sildi peal olev kiri. 
Kolmas silt on vastuvõtja. Kui selle peal vabastakse andmeid kandva kursoriga hiire 
klahv, siis jääb saabunud tekst sildi sisse. 
Nii allika kui suudme olen loonud sildi alamklassina. 
AndmeveoAlguseKuularis on kirjas, mida tuleb teha, kui DragSource poolt loodud 
DefaultDragGestureRecognizer on märganud, et sildi pealt hakatakse andmeid 
vedama. Sel puhul võetakse sildi tekst, muutetakse ta Transferable tingimustele 
vastavaks StringSelection'iks, et teda saaks üle kanda ning siis käivitatakse vedu 
käsuga startDrag. Parameetriteks on vedamise ajal näidatav kursor, kantavad 
andmed ning kuular, kellele saadetakse teated andmetega teel toimuva kohta. 
Suudmel on isend DropTarget, kelle poolt loodud 
AndmeteSaabumiseKuular saabuvate andmetega tegeleb. Kui suudme kohal lastakse 
andmehulk, saab ta selle tüüpide sobivuse korral vastu võtta. Esialgu küsitakse 
meetodi parameetrilt Transferable-tüüpi andmed, sealt oodatud kujul Objectina ning 
lõpuks tuleb nad kasutatavale kujule muudada. Siis võib nendega edasi toimida, siin 
näites andmete sees paiknev tekst oma sildile paigutada. 



import java.awt.*;
import java.awt.dnd.*;
import java.awt.datatransfer.*;

public class Allikas extends Label {
  private DragSource dragSource; 
  public Allikas(String s) {    
    setText(s);
    dragSource = DragSource.getDefaultDragSource();    
    dragSource.createDefaultDragGestureRecognizer(
      this, DnDConstants.ACTION_COPY,  new AndmeveoAlguseKuular()); 
    } 

  class AndmeveoAlguseKuular implements DragGestureListener {  
    public void dragGestureRecognized(DragGestureEvent e) {
      Transferable andmed = new StringSelection( getText() );
        e.startDrag(DragSource.DefaultCopyDrop,
          andmed, new AndmeveoKuular());
    }
  }
  

  class AndmeveoKuular implements DragSourceListener {     
    public void dragDropEnd(DragSourceDropEvent e) { }
    public void dragEnter(DragSourceDragEvent e) {  }
    public void dragOver(DragSourceDragEvent e) {  }
    public void dragExit(DragSourceEvent e) { }
    public void dropActionChanged (DragSourceDragEvent e) { }
  }
}


import java.awt.*;
import java.awt.dnd.*;
import java.awt.datatransfer.*;
import java.io.*;
public class Suue extends Label {
  private DropTarget dropTarget;  
  public Suue(String s) {    
    setText(s);  
    dropTarget = new DropTarget(this, 
      DnDConstants.ACTION_COPY,
      new AndmeteSaabumiseKuular(), true);
  }

  class AndmeteSaabumiseKuular implements DropTargetListener {
    public void dragOver(DropTargetDragEvent e) { }
    public void dropActionChanged(DropTargetDragEvent e) { }   
    public void dragExit(DropTargetEvent e) { }
    public void dragEnter(DropTargetDragEvent e) { }
    public void drop(DropTargetDropEvent e) {
     try{
        e.acceptDrop(DnDConstants.ACTION_COPY);
        Object data = e.getTransferable().
                      getTransferData(DataFlavor.stringFlavor);
        setText(data.toString());
     }catch(Exception ex){ ex.printStackTrace(); }
    }
  }
}


import java.awt.*;
public class Vedamine{
  public static void main(String argumendid[]){
    Frame f=new Frame("Andmeveo raam");
    f.setLayout(new GridLayout(3, 1));
    f.add(new Allikas("Karu"));
    f.add(new Allikas("Rebane"));
    f.add(new Suue("Vea siia!"));
    f.setSize(200, 100);
    f.setVisible(true);
  }
}



Swing

	Lisaks kümnekonnale paketis java.awt asuvale komponendile saab 
kasutajaga suhtlemiseks kasutada ka paketi javax.swing graafilisi komponente. Nagu 
eelpool graafikakomponentide peatükis kirjeldatud, palutakse awt-komponendid 
joonistada operatsioonisüsteemil, swing-komponente joonistatakse Java 
vahenditega. Sellest tulenevalt näevad esimesed välja nii nagu vastavas 
operatsioonsiüsteemis tavaks, swingi nupp või silt aga on igal pool tavajuhul 
peaaegu ühesugune. UIManageri abil aga on võimalik panna ka swing-komponente 
vastavalt operatsioonisüsteemile välja nägema. 
	Swingi graafikakomponendid algavad tähega J. Tõenäoliselt seetõttu, et 
neid oleks kerge eristada analoogilistest awt komponentidest. Järgnevas näiteks on 
raamiks JFrame, selle sees on silt JLabel ning nupp JButton. Nii nupule kui sildile 
(ja ka mitmetele muudele komponentidele) saab tema ilmestamiseks määrata ikooni. 
ImageIcon loob ikooni kasutades aluseks pildifaili, kuid vajadusel saab ikooni ka 
käskude abil joonistada. Kõikidele swingi komponentidele saab määrata 
ToolTipText'i. Seda näidatakse ekraanile juhul, kui kasutaja on hiirega vastava 
komponendi peale liikunud. Enamasti vastav tekst seletab komponendi otstarvet või 
annab kasutajale tegutsemissoovitusi. Korraldus setMnemonic lubab 
klahvikombinatsiooni (Alt + täht) võrdsustada hiirega nupule vajutamisele. 
	Komponentide raami lisamisel tuleb swingi puhul määrata, millisesse kihti 
ta paigutada. Harilikult kasutatava alumise kihi saab kätte getContentPane() abil. 
Pealmist kihti nimetatakse GlassPane ning vahepealsetesse kihtidesse paigutamiseks 
saab kasutada LayeredPane vahendeid. Kihtidega mängides saab komponente 
mitmesse kihti paigutada. 

import java.awt.*;
import javax.swing.*;
public class Pildid{
  public static void main(String argumendid[]){
    JLabel silt=new JLabel("Maja silt");
    Font suurkiri=new Font("Serif", Font.BOLD+Font.ITALIC, 30);
    Icon majapilt=new ImageIcon("maja.gif");
    silt.setFont(suurkiri);
    silt.setIcon(majapilt);

    JButton nupp=new JButton("Maja nupp", majapilt);
    nupp.setToolTipText("Head vajutamist!");
    nupp.setMnemonic(java.awt.event.KeyEvent.VK_M);

    JFrame f=new JFrame("Sildiraam");
    Container p=f.getContentPane();
    p.setLayout(new GridLayout(2, 1));
    p.add(silt);
    p.add(nupp);
    f.pack();
    f.setVisible(true);
  }
}
	HTML-kujundus
	Swingi komponentidel näidatavat teksti saab HTMLi abil kujundada. Täpne 
väljanägemine võib sõltuda intepretaatorist, kuid selliselt on programmi 
väljanägemist lihtsam pilkupüüdvaks muuta kui awt vahenditega kujundades. Nagu 
lihtsat teksti kandva sildi puhul, nii ka siin on võimalik programmi töö käigus sildi 
sisu muuta. 

import javax.swing.*;
public class HtmlLabel{
  public static void main(String argumendid[]){
    JFrame f=new JFrame("Kujundatud silt");
    JLabel silt=new JLabel(
      "<html><h2>Pealkirja</h2>\n"+
      "ja <font color=red>punase tekstiga</font> silt</html>"
    );
    f.getContentPane().add(silt);
    f.pack();
    f.setVisible(true);
  }
}

Sisemised raamid
	Mõnes programmis on näha, et pearaami sees on omaette väiksemad 
raamid. Nii näiteks Wordi puhul võib iga tekst olla lahti omaette raamis, need aga 
omakorda suure Wordi raami sees. Sellist olukorda Java keskkonnas saab tekitada 
JInternalFrame abil. Nemad käituvad JDesktopPane sees samuti nagu harilikud 
raamid suure ekraani sees. Tema sees paiknevasse paneeli saab lisada komponente 
nagu ikka. Ka sisemisi raame saab muuta ikooniks alla serva, suurendada ja 
vähendada. Kui suure raami teateid püüab WindowListener, siis siseraamiga 
toimuva teada saamiseks aitab InternalFrameListener. Vorm on küll erinev, kuid 
võimalused samad. 

import javax.swing.*;
public class SiseraamigaRaam{
  public static void main(String argumendid[]) throws Exception{
    JInternalFrame siseraam1=new JInternalFrame("Esimene");
    JInternalFrame siseraam2=new JInternalFrame("Teine",
                                  true, true, true, true);
    siseraam2.getContentPane().add(new JTextArea());

    JDesktopPane paneel=new JDesktopPane();
    siseraam1.setSize(200, 100);
    siseraam1.setLocation(10, 80);
    siseraam1.setVisible(true);
    paneel.add(siseraam1);
    siseraam1.setSelected(true);
    siseraam2.setVisible(true);
    paneel.add(siseraam2);
    siseraam2.setSize(150, 150);
    siseraam2.setLocation(120, 50);
    JFrame f=new JFrame("Kest");
    f.setContentPane(paneel);
    f.setSize(300, 300);
    f.setVisible(true);
  }
}
Värvivalija
	Kasutajapoolseks värvi valimiseks saab vajadusel kirjutada ise 
dialoogiakna, kust hiirega omale sobiv värv leida võimalik on. Swingi all aga on 
programmeerimisvaeva vähendamiseks loodud komponent JColorChooser, mille 
abil kasutaja saab pakutavate hulgast sobiva värvi välja valida. Värvivalikuks pakub 
komponent kolme võimalust: esimesel juhul saab hiirega vajutada sobivat värvi 
ruudule. Teisel puhul saab valida värvi ning teiselt skaalalt värvile vastava 
tumeduse. Kolmandas valikuaknas lastakse kasutajal määrata punase, rohelise ning 
sinise vahekord loodavas värvis. Vaikimisi kujul näitab komponent otsitavat värvi 
mitmesuguste kujundite ning ingliskeelse teksti peal. Selle kujundi saab aga 
vajadusel programmi ilmele sobivama või hoopis tühja pisikese paneeli vastu välja 
vahetada (järgnevas näites vastav rida välja kommenteeritud). Värvivaliku 
registreerimiseks ning temale reageerimiseks saab kasutada kuularit. Värvivaliku 
klassi juurde on loodud meetodid ka dialoogiakna kaudu värvi valimiseks. 

import javax.swing.*;
import javax.swing.event.*;
public class Varvivalik{
  public static void main(String argumendid[]){
    final JTextArea tekstiala=new JTextArea("Värvilised tervitused");
    final JColorChooser valija=new JColorChooser();
//    valija.setPreviewPanel(new JPanel());
    valija.getSelectionModel().addChangeListener(
      new ChangeListener(){
        public void stateChanged(ChangeEvent e){
          tekstiala.setForeground(valija.getColor());
        }
      }
    );
    JFrame f=new JFrame("Värvivalik");
    java.awt.Container p=f.getContentPane();
    p.add("Center", tekstiala);
    p.add("South", valija);
    f.setSize(300, 500);
    f.setVisible(true);
  }
}
Failinime valija
	Ka failinime failinime valimise dialoogi saab ise suurema vaevata 
kirjutada, kuid swingi klass JFileChooser on juba vastavaks otstarbeks loodud 
ilusasti kujundatud komponent. Saab määrata, millisest kataloogist alates faili 
otsima saab hakata. Meetod showOpenDialog avab dialoogi ning programm jääb 
kasutajapoolset valikut ootama. Kui fail on valitud või valimine tühistatud, läheb 
programm edasi ning komponendi meetodite kaudu saab teada kasutaja vastuse. Kui 
soovitud fail on käes, saab temaga samuti toimida nagu failiga ikka, s.t. tema kohta 
infot küsida, sealt lugeda või sinna kirjutada. 

import javax.swing.*;
import java.io.*;
public class Failivalik{
  public static void main(String argumendid[]){
    JFileChooser valija=new JFileChooser(new File("."));
    valija.showOpenDialog(new JFrame());
    System.out.println("Valiti "+valija.getSelectedFile());
  }
}

	Failivalikut saab veidi programmiga kohandada. Näiteks võib määrata 
avamisnupu peal olevat kirja. Samuti võib lubada korraga mitut faili valida. 
Järgnevas näites lisatakse filtri abil võimalus eraldi vaid pildifailide hulgast kasutajal 
sobivat otsida. Filtri loomisel tuleb üle katta meetodid accept ning getDescription. 
Esimesele antakse järjekorras ette kõik failid, mida parasjagu oleks võimalik valida. 
See meetod peab igaühe kohta neist ütlema, kas vastavat faili kasutajale näidata või 
mitte. Meetod getDescription väljastab filtrile sobivate failide ühisnimetaja, siin 
näites "Pildifailid".

import javax.swing.*;
import javax.swing.filechooser.FileFilter;
import java.io.*;
public class Failivalik2{
  public static void main(String argumendid[]){
    JFileChooser valija=new JFileChooser(new File("."));
    valija.addChoosableFileFilter(new Pildifilter());
    valija.showDialog(new JFrame(), "Vali fail");
    System.out.println("Valiti "+valija.getSelectedFile());
  }
}

class Pildifilter extends FileFilter{
  public boolean accept(File f){
    String failinimi=f.getName();
    if(failinimi.endsWith(".gif")|failinimi.endsWith(".jpg"))
      return true;
    else return false;
  }
  public String getDescription(){
    return "Pildifailid ";
  }
}


Puud

	Infohulgas orienteerumiseks saab andmeid esitada puuna. Siis on kasutajal 
võimalik ekraanilt kasutu kõrvaldada ning hierarhia abil enesele sobiv üles leida. 
Puu abil on näiteks esitatud failid ja kataloogid FileManageris ja 
WindowsExploreris. Puusse saab lisada kõiki objekte. Vaikimisi juhul määrab JTree 
ise okstele ja lehtedele sobivad ikoonid ning objekti kirjelduseks kasutab sõnet mille 
väljastab ta toString meetod. Vajadusel aga saab nii ikooni kui kirjeldust muuta. 
	Puu hierarhia saab kokku panna DefaultMutableTreeNode abil. Kui ta on 
reas viimane, on ta leht, keskel oks ning algul juur. Puu ekraanile kuvamiseks tuleb 
luua JTree, kellele määrata juur, millest alates elemente näidata tuleb. Siin näites on 
pandud juureks ülikool, tema alla paar teaduskonda ning teaduskonna alla mõni 
õppetool. Võib jääda mulje, nagu tuleks puu loomiseks hirmus palju kirjutada, kuid 
suuremate andmehulkade korral saab luua või kasutada olemasolevaid 
alamprogramme ning puu tegemine polegi kuigi keeruline.

import javax.swing.*;
import javax.swing.tree.*;
public class Puu{
  public static void main(String argumendid[]){
    DefaultMutableTreeNode juur=new DefaultMutableTreeNode("Ülikool");
    DefaultMutableTreeNode teaduskond=new DefaultMutableTreeNode(
       "Matemaatika-Loodusteaduskond");
    teaduskond.add(new DefaultMutableTreeNode("Informaatika 
õppetool"));
    teaduskond.add(new DefaultMutableTreeNode("Bioloogia  õppetool"));
    juur.add(teaduskond);
    juur.add(new DefaultMutableTreeNode("Kultuuriteaduskond"));
    JTree puu=new JTree(juur);
    JFrame f=new JFrame("Puu");
    f.getContentPane().add(puu);
    f.setSize(200, 200);
    f.setVisible(true);
  }
}

	Kasutaja tegevuse registreerimiseks saab tarvitada mitmesuguseid 
kuulareid. Saab teada, millal ta puu nähtavat osa suurendas või vähendas, mis osa 
puust nähtav on, millal mõni element valiti. Ka pärast puu loomist saab temasse 
elemente lisada ja sealt eemaldada. Käsklus 
puu.putClientProperty("JTree.lineStyle", "Angled"); palub puu osad omavahel 
joontega ühendada. Siin näites trükitakse igal valikul välja valitud komponent. 
TreeSelectionEvent'i meetod getPath() annab tulemuseks kogu rea alates juurest 
kuni märgitud leheni. Selle kaudu oleks võimalik ükskõik millise tee peale jääva 
komponendi poole pöörduda. Meetod getLastPathComponent() annab tulemuseks 
tee viimase elemendi, ehk selle, millele kasutaja vajutas. 

import javax.swing.*;
import javax.swing.tree.*;
import javax.swing.event.*;
public class Puu2a{
  public static void main(String argumendid[]){
    DefaultMutableTreeNode juur=new DefaultMutableTreeNode("Ülikool");
    DefaultMutableTreeNode teaduskond=new DefaultMutableTreeNode(
       "Matemaatika-Loodusteaduskond");
    teaduskond.add(new DefaultMutableTreeNode("Informaatika 
õppetool"));
    teaduskond.add(new DefaultMutableTreeNode("Bioloogia  õppetool"));
    juur.add(teaduskond);
    juur.add(new DefaultMutableTreeNode("Kultuuriteaduskond"));
    JTree puu=new JTree(juur);
    puu.addTreeSelectionListener(
      new PuuKuular()
    );
    puu.putClientProperty("JTree.lineStyle", "Angled");
    JFrame f=new JFrame("Puu");
    f.getContentPane().add(puu);
    f.setSize(200, 200);
    f.setVisible(true);
  }
}

class PuuKuular implements TreeSelectionListener{
  public void valueChanged(TreeSelectionEvent e){
    System.out.println(e.getPath().getLastPathComponent());
  }
}

	Paigutus

	JSplitPane võimaldab temale eraldatud pinna jaotada kahe komponendi 
vahel. Tuleb vaid määrata, kas pind jaotatakse kaheks horisontaalselt või 
vertikaalselt ning komponendid, mis kummasegi ossa panna. Lisameetoditega saab 
määrata ja muuta jagamise kohta, samuti kasutajapoolset vahepiiri nihutamise 
võimalusi. Jagatud paneelidena näevad välja mitut lehte sisaldavad brauseri aknad, 
kus vasakul näiteks sisukord ja paremal sisu.

import javax.swing.*;
public class Jaotuspaneel{
  public static void main(String argumendid[]){
    JSplitPane paneel=new JSplitPane(
      JSplitPane.VERTICAL_SPLIT,
      new JButton("Ülemine"),
      new JToggleButton("Alumine")
    );
    JFrame f=new JFrame("Jagatud raam");
    f.getContentPane().add(paneel);
    f.setSize(200, 200);
    f.setVisible(true);
  }
}

	Kui määranguaknas on võimalusi rohkem kui kasutajale korraga mõistlik 
näidata on, siis JTabbedPane abil saab muud paneelid ülekuti paigutada. Sarnaselt 
on loodud näiteks Exceli lahtrimäärangute dialoogiaken, kus ühel paneelil saab 
määrata andmete tüüpi, teisel kujundust jne. Soovi korral saab paneelivaliku 
nuppudele lisada ikoonid, eemaldada, vahetada ja lisada paneele, mõne valiku 
tegemist keelata, automaatselt soovitud paneel esile tuua ning mitmel moel kasutaja 
tegevuse kohta teateid saada.

import javax.swing.*;
public class Valikupaneel{
  public static void main(String argumendid[]){
    JPanel p1=new JPanel(new java.awt.GridLayout(2,1));
    p1.add(new JButton("Ülemine"));
    p1.add(new JButton("Alumine"));

    JTabbedPane paneel=new JTabbedPane();
    paneel.add("Esimene", p1);
    paneel.add("Teine", new JLabel("Suur silt"));

    JFrame f=new JFrame("Valikupaneeli näide");
    f.getContentPane().add(paneel);
    f.setSize(200, 200);
    f.setVisible(true);
  }
}


Swingi kokkuvõte

	Swingi paketis on hulk klasse, mis peaksid aitama kasutajal programmiga 
meeldivalt suhelda. Samuti on püütud nende loomisel silmas pidada erivahendite 
kasutajaid (ekraanilt lugejad, lihtsustatud klaviatuurid). Lisaks eelnevalt 
kommenteeritutele kuuluvad siia paketti veel mitmed sageli kasutust leidvad 
komponendid: JMenuBar, JMenu, JSeparator, JMenuItem, JCheckBoxMenuItem ja 
JPopupMenu menüüde loomiseks; JToolBar tööriistariba tarvis. Action-liidese abil 
saab samastada menüüelemendi ning tööriistariba nupu. Tabelisse paigutada aitab 
JTable ning teksti näidata ja redigeerida saab JEditorPane ning mitme muu klassi 
abil. 


13