A CLASSE BASICSTROKE.
A classe de BasicStroke define um jogo básico de atributos para os esboços dos gráficos primitivos, os mesmos tem um rendimento com ao de um objeto de Graphics2D, onde tem seu atributo do curso ajustado ao BasicStroke.
Os atributos definidos por BasicStroke descrevem a forma da marca feita por uma pena extraída ao longo do esboço de uma forma e das decorações aplicadas nas extremidades e juntam-na de segmentos do trajeto da forma, incluindo a largura, onde a largura da pena, é perpendicular a sua medida.
Classes Principais do BasicStroke são:
java.lang.Object
java.awt.Component
java.awt.Container
javax.swing.JComponent
javax.swing.JPanel
Image
A classe Image define uma imagem gráfica simples, genérica e bidimensional. A classe Graphics (usada pelo método paint) pode desenhar imagens com o método drawImage :
Image minhaImagem;
minhaImagem = createImage(50, 50);
g.drawImage(minhaImagem, 0, 0, this);
O método drawImage recebe quatro parâmetros - a imagem, as coordenadas x e y e a referência para ela mesma através da variável especial (this). Os formatos de gravura suportados pelos browsers, os mais comuns são os que possuem extensão GIF (Graphics Interchange Format) e o Joint Photographic Experts Group (JPEG). Essas imagens podem demorar um tempo para serem descarregadas.
import java.applet.*;
import java.awt.*;
public class draw_image extends Applet {
Image img;
public void init() {
img = getImage(getCodeBase(), "cow.gif");
}
public void paint(Graphics g) {
g.drawImage(img, 0, 0, this); } }
// Adiciona imagens
Formas, fontes e cores
Os recursos gráficos como formas, fontes e cores são utilizados a partir da classe java.awt, que proporciona o melhor acabamento visual da linguagem Java.
A maioria das operações básicas de desenho é composta de métodos definidos na classe Graphics. Não é necessário criar um objeto "Graphics" para desenhar algo, basta lembrar que um dos argumentos do método paint() é um objeto Graphics, como é demonstrado logo abaixo no exemplo que vai nos acompanhar por todo esse capítulo, demonstrando todo o processo de criação de um mapa da Flórida:
import java.awt.Graphics;
import java.awt.Polygon;
public class Map extends java.applet.Applet {
public void paint(Graphics screen) {
screen.drawString("Florida", 185, 75);
. . . . . . .} }
Esse applet usa o método drawString() do objeto screen para desenhar o string "Flórida" nas coordenadas 185,75. Assim como acontece com drawString(), todos os métodos de desenho possuem argumentos que indicam coordenadas x, y. Alguns exigem mais do que um conjunto de coordenadas, como uma linha que possui uma coordenada x, y para identificar seu ponto inicial e outra para seu ponto final. Lembrando que todos os valores em pixel são inteiros, não podendo ser usados números decimais para apresentar algo entre os valores inteiros.
Linhas
O método drawLine() é usado para desenhar uma linha entre dois pontos. O método recebe quatro argumentos: as coordenadas x e y do ponto inicial e as coordenadas x e y do ponto final. A espessura da linha fica fixa em 1 pixel. Será inserida a seguinte linha no código do Map:
screen.drawLine(185, 80, 222, 80);
Retângulos
Para desenhar um retângulo normal, use o método drawRect para os contornos e o método fillRect para as figuras preenchidas. Esses métodos recebem os seguintes argumentos - coordenadas x e y do canto superior esquerdo do retângulo, a largura e a altura do retângulo. Insira a seguinte instrução no applet:
screen.drawRect(2, 2, 345, 345);
Os retângulos cm cantos arredondados exigem os métodos drawRoundRect() e fillRoundRect() que recebem os quatro primeiros argumentos que os normais, com dois argumentos incluídos no final que definem a largura e a altura da área onde os cantos são arredondados, insira a seguinte instrução no applet:
screen.drawRoundRect(182, 61, 43, 24, 10, 8);
Polígonos
Podem ser desenhados com os métodos drawPolygon() e fillPolygon(), onde são necessárias as coordenadas x, y de cada ponto. São considerados como uma série de linhas unidas, onde ficam declarados o início e o fim de cada uma. Adicione as seguintes instruções ao método paint() do applet Map para ver os polígonos em ação :
int x[] = { 10, 234, 253, 261, 344, 336, 295, 259, 205, 211,
195, 191, 120, 94, 81, 12, 10 };
int y[] = { 12, 15, 25, 71, 209, 278, 310, 274, 188, 171, 174,
118, 56, 68, 49, 37, 12 };
int pts = x.length;
Polygon poly = new Polygon(x, y, pts);
screen.drawPolygon(poly);
Elipses
Essa forma segue a mesma novela das formas anteriores, possui os métodos drawOval() e fillOval() usados para desenhar círculos e elipses, possuem os quatro argumentos que definem as coordenadas x e y, a largura e a altura. Inclua as seguintes instruções para o applet:
screen.fillOval(235,140,15,15);
screen.fillOval(225,130,15,15);
screen.fillOval(245,130,15,15);
Exemplo - Formato de uma carinha através dos círculos preenchidos
Arcos
De todas as formas de desenho, os arcos são os mais complexos de se construir, possuindo seis argumentos - as coordenadas x e y, a largura e a altura da elipse, o ângulo em que se deve iniciar o arco e o número de graus percorrido pelo arco. Verifique a sintaxe para esses métodos através do código completo do programa Map.java :
import java.awt.Graphics;
import java.awt.Polygon;
public class Map extends java.applet.Applet {
public void paint(Graphics screen) {
screen.drawString("Florida", 185, 75);
screen.drawLine(185,80,222,80); //linha
screen.drawRect(2, 2, 345, 345);//retângulo
screen.drawRoundRect(182,61,43,24,10,8);//retangulo arredondado
int x[] = { 10, 234, 253, 261, 344, 336, 295, 259, 205, 211,
195, 191, 120, 94, 81, 12, 10 };
int y[] = { 12, 15, 25, 71, 209, 278, 310, 274, 188, 171, 174,
118, 56, 68, 49, 37, 12 };
int pts = x.length;
Polygon poly = new Polygon(x, y, pts);
screen.drawPolygon(poly);
screen.fillOval(235,140,15,15);//círculo preenchido
screen.fillOval(225,130,15,15);
screen.fillOval(245,130,15,15);
for (int ax = 50; ax < 150; ax += 10)
for (int ay = 120; ay < 320 ; ay += 10)
screen.drawArc(ax, ay, 10, 10, 0, -180);//Arco
}
}
Exemplo- Utilização das formas através de um mapa
Textos
Os objetos da classe java.awt.Font são usados para se utilizar o método drawString() com diferentes fontes. Os objetos Font representam o nome, o estilo e o tamanho em pontos de uma fonte. Outra classe, FontMetrics, fornece métodos para se determinar o tamanho dos que caracteres que estão sendo apresentados com uma fonte específica, o que pode ser usado para detalhes com formatação e centralização do texto.
Um objeto fonte é criado enviando-se três argumentos para o seu construtor :
Nome - pode ser específico como as fontes internas da linguagem Java: TimesRoman, Helvetica, Courier, Dialog e DialogInput;
Estilo - podem ser definidos como Font.PLAIN, Font.BOLD e Font.ITALIC;
O tamanho em pontos da fonte.
As fontes apresentam, portanto, a seguinte sintaxe :
Font f = new Font("Dialog", Font.ITALIC, 36);
Depois é só definir a fonte atual através do método setFont() que segue a sintaxe:
screen.setFont(f);
O applet SoLong apresenta um string no centro da janela Applet, usando FontMetrics para medir a largura do string com a fonte atual
import java.awt.Font;
import java.awt.Graphics;
import java.awt.FontMetrics;
public class SoLong extends java.applet.Applet {
public void paint(Graphics screen) {
Font f = new Font("Courier", Font.BOLD, 18);
FontMetrics fm = getFontMetrics(f);
screen.setFont(f);
String s = "So long, and thanks for all the fish.";
int x = (size().width - fm.stringWidth(s)) / 2;
int y = size().height / 2;
screen.drawString(s, x, y);
}
}
Utilização das fontes através do applet SoLong
O método size() pode não estar compatível com a versão 1.2, se durante a compilação ou execução do programa houver alguma rejeição referente a esse método, basta substituí-lo pelo método getSize().
Cores
As classes Color e ColorSpace do pacote java.awt pode ser usadas para tornar seus applets e aplicativos mais coloridos. Com essas classes, podem ser definidas a cor atual e ser usada nas operações de desenho, bem como a cor de fundo de um applet e de outras janelas. Também podem ser convertidas uma cor de um sistema de descrição de cores para outro.
Por definição, Java usa cores de acordo com um sistema de definição de cores chamado RGB ( essas letras provém das palavras Red, Green e Blue). Cada um dos três componentes pode ser representado por um inteiro de 0 a 255. Como será visto posteriormente no quadro de cores.
A cor atual do desenho é designada pelo método setColor() da classe Graphics. Uma forma de definir a cor é usando uma das cores padrão disponíveis, como as variáveis de classe na classe Color que apresentam os seguintes parâmetros :
black(0,0,0)
blue(0,0,255)
cyan(0,255,255)
darkGray(64,64,64)
orange(255,200,0)
pink(255,175,175)
gray(128,128,128)
red(255,0,0)
green(0,255,00)
white(255,255,255)
yellow(255,255,0)
lightGray(192,192,192)
Tabela -- Cores para applets
A instrução a seguir define a cor atual do objeto screen usando as variáveis de classe padrão:
screen.setColor(Color.orange);
Para criar um objeto cor com definições próprias, deve ser introduzido um código semelhante a esse:
Color novacor = new Color(255,204,102);
screen.setColor(novacor);
O método setBackground() define a cor de fundo de uma janela e o método setForeground() altera a cor de um componente de interface como um botão ou uma janela. Esses métodos recebem como argumento o objeto cor.
setBackground(Color.blue);
Ex:
import java.awt.*;
import java.awt.event.*;
public class janelaDesenho2 extends Frame {
private final int startPos = 50;
private int incremento = 15;
private int tamanho = 40;
class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent we) {
dispose();
System.exit(0);
}
}
public janelaDesenho2() {
setTitle("Janela e desenho 2");
setSize(320,200);
addWindowListener(new WindowHandler());
}
public void paint(Graphics g) {
int x=startPos;
int y=startPos;
Dimension d = getSize();
int finalPos = Math.min(d.width, d.height)-tamanho;
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(new
BasicStroke(10.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
g2.drawString("Desenhando...", 10, 40);
while (x < finalPos) {
g2.setColor(new Color((float)Math.random(),
(float)Math.random(),
(float)Math.random()));
g2.drawRect(x, y, tamanho, tamanho);
x += incremento;
y += incremento;
}
g2.setFont(g.getFont().deriveFont(Font.BOLD));
g2.setColor(Color.red);
g2.drawString("...pronto!", 100, 40);
}
public static void main(String[] args) {
janelaDesenho2 j = new janelaDesenho2();
j.setVisible(true);
}
}
import java.awt.*;
import java.awt.event.*;
public class janelaDesenho2 extends Frame {
private final int startPos = 50;
private int incremento = 15;
private int tamanho = 40;
class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent we) {
dispose();
System.exit(0);
}
}
public janelaDesenho2() {
setTitle("Janela e desenho 2");
setSize(320,200);
addWindowListener(new WindowHandler());
}
public void paint(Graphics g) {
int x=startPos;
int y=startPos;
Dimension d = getSize();
int finalPos = Math.min(d.width, d.height)-tamanho;
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(new
BasicStroke(10.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
g2.drawString("Desenhando...", 10, 40);
while (x < finalPos) {
g2.setColor(new Color((float)Math.random(),
(float)Math.random(),
(float)Math.random()));
g2.drawRect(x, y, tamanho, tamanho);
x += incremento;
y += incremento;
}
g2.setFont(g.getFont().deriveFont(Font.BOLD));
g2.setColor(Color.red);
g2.drawString("...pronto!", 100, 40);
}
public static void main(String[] args) {
janelaDesenho2 j = new janelaDesenho2();
j.setVisible(true);
}
}
