Laborator 9

Desenarea în Java

9.1. Contextul grafic

Un context grafic este, de fapt, un obiect prin intermediul căruia se poate controla procesul de
desenare al altui obiect. Un context grafic este specificat prin intermediul unui obiect din clasa
Graphics primit ca parametru în metodele paint() sau repaint();

Inainte ca utilizatorul să poată desena, el trebuie să obțină un context de desenare pentru

suprafața căreia îi aparține regiunea pe care se va desena. Suprafața de desenare se numeste
zonă Canvas (« panză de pictor ») și de obicei este albă. In biblioteca AWT exista clasa Canvas
tocmai pentru a ușura munca desenatorului

Clasa Graphics pune la dispoziție metode pentru:

• desenarea de figuri geometrice, texte și imagini (primitive grafice)
• stabilirea proprietăților contextului grafic, adică stabilirea culorii și fontului curent cu care se
face desenarea

9.2. Primitive grafice

Un program Java care are interfață grafică cu utilizatorul, trebuie să deseneze pe ecran toate
componentele sale care au o reprezentare vizuală. Această desenare include componentele
standard folosite în aplicație precum și cele definite de către programator.

Metodele care controlează procesul de desenare se găsesc în clasa Component :

void paint(Graphics g) - Desenează o componentă.

Este o metodă supradefinită de fiecare componentă în parte pentru a furniza reprezentarea sa

grafică specifică. Metoda este apelată de fiecare dată când conținutul componentei trebuie
desenat sau redesenat și nu va fi apelată explicit.

void update(Graphics g) - Actualizează starea grafică a unei componente.

Acțiunea acestei metode se realizează în trei pași:

1. șterge componenta prin supradesenarea ei cu culoarea fundalului;
2. stabilește culoarea (foreground) componentei;
3. apelează metoda paint pentru a redesena componenta.

void repaint() - Execută explicit un apel al metodei update pentru a actualiza reprezentarea
grafică a unei componente.

După cum se observă, singurul argument al metodelor paint și update este un obiect g de tip
Graphics. Acesta reprezintă contextul grafic în care se execută desenarea componentelor
Toate desenele care trebuie să apară pe o suprafață de desenare se realizează în metoda paint a
unei componente, în general apelată automat sau explicit cu metoda repaint ori de câte ori
componenta respectivă trebuie redesenată. Există posibilitatea de a desena și în afara metodei
paint, însă aceste desene se vor pierde la prima operație de minimizare, maximizare,
redimensionare a suprafeței de afișare.

Prin primitive grafice ne vom referi în continuare la metodele clasei Graphics, care permit
desenarea de figuri geometrice și texte.

Desenarea textelor se face cu uzual cu metoda drawString care primește ca argumente un șir
și colțul din stânga-jos al textului. Textul va fi desenat cu fontul și culoarea curentă a contextului
grafic.

drawString("Hello", 10, 20);

Desenarea figurilor geometrice se realizează cu următoarele metode:

Metodele care încep cu ”fill” vor desena figuri geometrice care au interiorul colorat, adică
”umplut” cu culoarea curentă a contextului de desenare, în timp ce metodele care încep cu
”draw” vor desena doar conturul figurii respective.

Așadar, clasa Graphics contine o serie de primitive de desenare. Ele pot fi împărțite în două mari
categorii: cele fără umplere - trasează doar conturul obiectului grafic, respectiv cele cu umplere -
trasează doar interiorul. Pentru a obține o figură cu un contur și un interior în culori diferite se va
utiliza o pereche corespunzătoare dintre aceste funcții.
Funcții fără umplere (în paranteze sunt dați parametrii funcției și tipul lor):

 void draw3DRect (int x, int y, int width, int height, boolean raised)

 void drawArc (int x, int y, int width, int height, int startAngle, int angle)
 void drawLine (int x1, int y1, int x2, int y2)
 void drawOval (int x, int y, int width, int height)
 void drawPolygon (int[] xPoints, int[] yPoints, int nPoints)
 void drawPolyline (int[] xPoints, int[] yPoints, int nPoints)
 void drawRect (int x, int y, int width, int height)
 void drawRoundRect (int x, int y, int width, int height, int arcW, int arcH)
 void drawstring (String str, int x, int y)

Primitive de desenare cu umplere:

 void fill3DRect (int x, int y, int width, int height, boolean raised)

 void fillArc (int x, int y, int width, int height, int startAngle, int angle)
 void fillOval (int x, int y, int width, int height)
 void fillPolygon (int[] xPoints, int[] yPoints, int nPoints)
 void fillRect (int x, int y, int width, int height)
 void fillRoundRect (int x, int y, int width, int height, int arcW, int arcH)

Sarcina 1
Rulați programul următor pentru a vedea trasarea diferitelor tipuri de linii:

import javax.swing.* ;
import java.awt.* ;
class Fereastra extends JFrame
{ Fereastra ()
{ setTitle ("Tipuri de linii") ;
setSize (300, 150) ;
pan = new Panel() ;
getContentPane().add(pan) ;
}
private JPanel pan ;
}
class Panel extends JPanel
{ public void paintComponent(Graphics g)
{ super.paintComponent(g) ;
g.drawRect (20, 10, 60, 40) ;
g.drawLine (20, 100, 150, 20) ;
g.drawOval (130, 60, 110, 50) ;
}
}
public class FiguriGeom1
{ public static void main (String args[])
{ Fereastra fer = new Fereastra() ;
fer.setVisible(true) ;
}
}
 Sarcina 2. Rulați programul următor și observați ce funcții se folosesc pentru desenarea
diferitelor figuri geometrice :

import java.awt.*;
import javax.swing.*;

class PanouDesen extends JPanel {

final int xMax = 400;
final int yMax = 1200;

public PanouDesen() {
super();
setPreferredSize(new Dimension(xMax, yMax));
}

public void paint(Graphics g) {

g.clearRect(0, 0 , xMax, yMax); // sterge suprafata

g.drawLine(xMax / 2, 0, xMax / 2, yMax); // trasare caroiaj

vertical
for(int i=1; i<8; i++)
g.drawLine(0, i*(yMax / 8), xMax, i*(yMax / 8));//
trasare caroiaj orizontal

// figuri - doar contur

g.drawString("draw3DRect", 10, 15);

g.draw3DRect(10, 30, 170, 90, true);
g.drawString("drawArc", 10, 165);
g.drawArc(10, 190, 170, 90, 30, 170);
g.drawString("drawLine", 10, 315);
g.drawLine(10, 330, 170, 370);
g.drawString("drawOval", 10, 465);
g.drawOval(10, 480, 170, 90);
g.drawString("drawPolygon", 10, 615);
int xPoints[] = { 10, 110, 170, 160, 50 };
int yPoints[] = { 680, 630, 650, 720, 720 };
g.drawPolygon(xPoints, yPoints, xPoints.length);
g.drawString("drawPolyline", 10, 765);
int xPoints1[] = { 10, 110, 170, 160, 50 };
int yPoints1[] = { 830, 780, 800, 870, 870 };
g.drawPolyline(xPoints1, yPoints1, xPoints1.length);
g.drawString("drawRect", 10, 915);
g.drawRect(10, 930, 170, 90);
g.drawString("drawRoundRect", 10, 1065);
g.drawRoundRect(10, 1080, 170, 90, 45, 45);

// figuri – pline

g.drawString("fill3DRect", 210, 15);

g.fill3DRect(210, 30, 170, 90, true);
g.drawString("fillArc", 210, 165);
g.fillArc(210, 190, 170, 90, 30, 170);
g.drawString("fillOval", 210, 315);
g.fillOval(210, 330, 170, 90);
g.drawString("fillPolygon", 210, 465);
int xPoints3[] = { 210, 310, 370, 360, 250 };
int yPoints3[] = { 530, 480, 500, 570, 570 };
g.fillPolygon(xPoints3, yPoints3, xPoints3.length);
g.drawString("fillRect", 210, 615);
 g.fillRect(210, 630, 170, 90);
g.drawString("fillRoundRect", 210, 765);
g.fillRoundRect(210, 780, 170, 90, 45, 45);

}
}

class PanouScroll extends JScrollPane {

public PanouScroll() {
super();
createViewport();
PanouDesen panou = new PanouDesen();
setViewportView(panou);
int dim = (int)panou.getPreferredSize().getWidth();
int dimScroll = 18;
setPreferredSize(new Dimension(dim+dimScroll, 400));
}
}

public class GraphPrim extends JFrame {

public static void main(String args[]) {

GraphPrim app = new GraphPrim();

app.getContentPane().add(new PanouScroll());
app.pack();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
app.show();
}
}

9.3. Gestionarea culorilor

Orice culoare este formată prin combinația culorilor standard roșu (red), verde (green) și
albastru (blue), la care se adaugă un anumit grad de transparență (alpha). Fiecare din acești
patru parametrii poate varia într-un interval cuprins fie între 0 și 255 (dacă dorim să specificăm
valorile prin numere întregi), fie între 0.0 și 1.0 (dacă dorim să specificăm valorile prin numere
reale).

Pentru gestionarea culorii la afișare se folosește clasa java.awt.Color

Color( r, g, b, a)

unde r,g,b (rosu, verde, albastru) pot fi de tip float sau întreg iar a – "alfa" specifică transparența
(ce poate lipsi).

Color(float red, flot green, float blue)

Color(flot red, float green, float blue, float alpha)
Color(int red, int green, int blue)
Color(int red, int green, int blue, int alpha)
Color(int rgb)

Implicit culorile sunt complet opace.

Constante statice pt culori:

BLACK, BLUE, CYAN, DARK_GRAY, GRAY, GREEN, LIGHT_GRAY, MAGENTA, ORANGE, PINK, RED,
WHITE, YELLOW.

Stabilirea culorii de desenare se va face prin functia setColor() a contextului grafic:

g.setColor(Color c)

Sarcina 3
Rulați programul următor pentru a vedea utilizarea culorilor la desenare și la umplere :

import java.awt.*;
import javax.swing.*;

class PanouDesenCulori extends JPanel {

final int xMax = 400;
final int yMax = 1200;

public PanouDesenCulori() {
super();
setPreferredSize(new Dimension(xMax, yMax));
this.setBackground(Color.WHITE);
}

public void paint(Graphics g) {

Color myColor;

g.setColor(Color.WHITE);
g.fillRect(0, 0 , xMax, yMax); // sterge suprafata

g.setColor(Color.BLACK);
g.drawLine(xMax / 2, 0, xMax / 2, yMax); // trasare caroiaj
vertical
for(int i=1; i<8; i++)
g.drawLine(0, i*(yMax / 8), xMax, i*(yMax / 8));//
trasare caroiaj orizontal

// figuri - doar contur

myColor = new Color(210, 50, 100);
g.setColor(myColor);
g.drawString("draw3DRect", 10, 15);
g.drawString(myColor.toString(), 10, 28);
g.draw3DRect(10, 30, 170, 90, true);
g.setColor(Color.BLUE);
g.drawString("drawArc (BLUE)", 10, 165);
g.drawArc(10, 190, 170, 90, 30, 170);
g.setColor(Color.CYAN);
g.drawString("drawLine (CYAN)", 10, 315);
g.drawLine(10, 330, 170, 370);
g.setColor(Color.GRAY);
g.drawString("drawOval (GRAY)", 10, 465);
g.drawOval(10, 480, 170, 90);
g.setColor(Color.MAGENTA);
g.drawString("drawPolygon (MAGENTA)", 10, 615);
int xPoints[] = { 10, 110, 170, 160, 50 };
int yPoints[] = { 680, 630, 650, 720, 720 };
g.drawPolygon(xPoints, yPoints, xPoints.length);
g.setColor(Color.ORANGE);
g.drawString("drawPolyline (ORANGE)", 10, 765);
int xPoints1[] = { 10, 110, 170, 160, 50 };
int yPoints1[] = { 830, 780, 800, 870, 870 };
g.drawPolyline(xPoints1, yPoints1, xPoints1.length);
g.setColor(Color.GREEN);
g.drawString("drawRect (GREEN)", 10, 915);
g.drawRect(10, 930, 170, 90);
g.setColor(Color.PINK);
g.drawString("drawRoundRect (PINK)", 10, 1065);
g.drawRoundRect(10, 1080, 170, 90, 45, 45);

// figuri - pline
g.setColor(Color.RED);
g.drawString("fill3DRect (RED)", 210, 15);
g.fill3DRect(210, 30, 170, 90, true);
myColor = new Color(85, 130, 200);
g.setColor(myColor);
g.drawString("fillArc", 210, 165);
g.drawString(myColor.toString(), 210, 178);
g.fillArc(210, 190, 170, 90, 30, 170);
g.setColor(Color.DARK_GRAY);
g.drawString("fillOval (DARK_GRAY)", 210, 315);
g.fillOval(210, 330, 170, 90);
g.setColor(Color.LIGHT_GRAY);
g.drawString("fillPolygon (LYGHT_GRAY)", 210, 465);
int xPoints3[] = { 210, 310, 370, 360, 250 };
int yPoints3[] = { 530, 480, 500, 570, 570 };
g.fillPolygon(xPoints3, yPoints3, xPoints3.length);
myColor = new Color(137, 166, 95);
g.setColor(myColor);
g.drawString("fillRect", 210, 615);
g.drawString(myColor.toString(), 210, 628);
g.fillRect(210, 630, 170, 90);
myColor = new Color(182, 233, 27);
g.setColor(myColor);
g.drawString("fillRoundRect", 210, 765);
g.drawString(myColor.toString(), 210, 778);
g.fillRoundRect(210, 780, 170, 90, 45, 45);

// suprapunere cu transparenta 20 %
myColor = new Color(230, 33, 33);
g.setColor(myColor);
g.drawString("Tansparenta 20% cu contur", 210, 915);
g.fillRoundRect(210, 930, 170, 90, 45, 45);
myColor = new Color(33, 230, 33, 51); // aplha = 51
g.setColor(myColor);
g.fillOval(255, 960, 140, 80);
g.setColor(Color.BLACK);
g.drawOval(255, 960, 140, 80);

// suprapunere cu transparenta 80 %
myColor = new Color(230, 33, 33, 205); // aplha = 205
g.setColor(myColor);
g.drawString("Tansparenta 80%", 210, 1065);
g.fillRoundRect(210, 1080, 170, 90, 45, 45);
myColor = new Color(33, 230, 33, 127); // aplha = 127
g.setColor(myColor);
 g.fillOval(255, 1110, 140, 80);
}
}

class PanouScrollCulori extends JScrollPane {

public PanouScrollCulori() {
super();
createViewport();
PanouDesenCulori panou = new PanouDesenCulori();
setViewportView(panou);
int dim = (int)panou.getPreferredSize().getWidth();
int dimScroll = 18;
setPreferredSize(new Dimension(dim+dimScroll, 400));
}
}

public class GraphCulori extends JFrame {

public static void main(String args[]) {

GraphCulori app = new GraphCulori();

app.getContentPane().add(new PanouScrollCulori());
app.pack();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
app.show();
}
}

Sarcina 4
Realizați propriul desen la liberă alegere pe o suprafață Canvas