[quote=entanglement]Tio, ainda não entendi o lance de você ficar incrementando horas, minutos e segundos.
[/quote]
É que a ideia é nao ficar consultando o SO todo segundo e gerando instancias de Date() a torda e a direita se eu posso incrementa-la… alem da manipulacao de string…
Tudo bem, entendi o que vc quis dizer com o meio segundo.
Acho que assim eu pude aproveitar a idéia dos dois:
[code]package main;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.Line2D;
import java.awt.image.BufferedImage;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.imageio.ImageIO;
import javax.swing.WindowConstants;
import javax.swing.JFrame;
public class RelogioAnalogico extends javax.swing.JPanel {
/**
* Auto-generated main method to display this
* JPanel inside a new JFrame.
*/
private int tamanho;
private int segundo;
private int minuto;
private int hora;
private Color cSegundo;
private Color cMinuto;
private Color cHora;
private int tamanhoPino;
private BufferedImage fundo;
private BufferedImage pinoRelogio;
public static void main(String[] args) {
JFrame frame = new JFrame();
frame.setSize(750, 750);
frame.getContentPane().add(new RelogioAnalogico(700,Color.red,Color.gray,Color.black,2));
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
frame.setVisible(true);
}
private void normalizeSegundos (Graphics2D g2d, Dimension dim) {
g2d.translate(dim.width / 2, dim.height/2);
g2d.scale((((dim.width)/2)-(this.tamanho/7)), -(((dim.height)/2)-(this.tamanho/7)));
}
private void normalizeMinutos (Graphics2D g2d, Dimension dim) {
g2d.translate(dim.width / 2, dim.height/2);
g2d.scale((((dim.width)/2)-(this.tamanho/5)), -(((dim.height)/2)-(this.tamanho/5)));
}
private void normalizeHoras (Graphics2D g2d, Dimension dim) {
g2d.translate(dim.width / 2, dim.height/2);
g2d.scale((((dim.width)/2)-(this.tamanho/3.5)), -(((dim.height)/2)-(this.tamanho/3.5)));
}
/**
* Skin==1 > Preto
* Skin==2 > Branco
* Skin==3 > Madeira
* @param tamanho
* @param cSegundo
* @param cMinuto
* @param cHora
* @param skin
*/
public RelogioAnalogico(int tamanho, Color cSegundo,Color cMinuto, Color cHora, int skin){
try{
this.tamanho=tamanho;
tamanhoPino = this.tamanho/25;
this.cSegundo=cSegundo;
this.cMinuto=cMinuto;
this.cHora=cHora;
if (skin == 1){
fundo = ImageIO.read(getClass().getClassLoader().getResource("img/relogio_preto.png"));
}
else if (skin == 2){
fundo = ImageIO.read(getClass().getClassLoader().getResource("img/relogio_branco.png"));
}
else if (skin == 3){
fundo = ImageIO.read(getClass().getClassLoader().getResource("img/relogio_madeira.png"));
}
pinoRelogio = ImageIO.read(getClass().getClassLoader().getResource("img/pino_relogio.png"));
String strHora = new SimpleDateFormat("hhmmss").format(new Date());
/**
* Os numeros de minuto e horas sao exageradamente maiores para se obter um movimento uniforme desses ponteiros, senao, o ponteiro
* do minuto ia dar um pulo como o do segundo, e na verdade entre cada um dos 60 minutos existe mais 60 movimentos (60*60=3600). O mesmo
* ocorre com as horas, se a cada hora tem 60 minutos e cada minuto tem 60 segundos, (((60*60)*12)=43200) em cada hora o
* ponteiro se move 3600 vezes, a cada 12 horas se move 43200 vezes. Ja pensou o ponteiro da hora pulando do "1" para o "2"
* de uma so vez? oO.. seria bem esquesito...
*/
segundo = Integer.parseInt(strHora.substring(4,6));
minuto = (60*Integer.parseInt(strHora.substring(2,4)));
hora = (3600*Integer.parseInt(strHora.substring(0,2)))+minuto;
if (hora>43199){
hora = minuto;
}
Runnable runnable = new Runnable() {
public void run() {
long ticker = System.currentTimeMillis();
while(true){
segundo++;
minuto++;
hora++;
if (segundo>59){
segundo=0;
}
if (minuto>3599){
minuto=0;
}
if (hora>43199){
hora=0;
}
/**
* Verificando se houve delay
*/
if(((System.currentTimeMillis() - ticker)%1000)!=0){
System.out.println(((System.currentTimeMillis() - ticker)%1000));
System.out.println("Atualizando com o SO");
String strHora = new SimpleDateFormat("hhmmss").format(new Date());
ticker = System.currentTimeMillis();
/**
* Os numeros de minuto e horas sao exageradamente maiores para se obter um movimento uniforme desses ponteiros, senao, o ponteiro
* do minuto ia dar um pulo como o do segundo, e na verdade entre cada um dos 60 minutos existe mais 60 movimentos (60*60=3600). O mesmo
* ocorre com as horas, se a cada hora tem 60 minutos e cada minuto tem 60 segundos, (((60*60)*12)=43200) em cada hora o
* ponteiro se move 3600 vezes, a cada 12 horas se move 43200 vezes. Ja pensou o ponteiro da hora pulando do "1" para o "2"
* de uma so vez? oO.. seria bem esquesito...
*/
segundo = Integer.parseInt(strHora.substring(4,6));
minuto = (60*Integer.parseInt(strHora.substring(2,4)));
hora = (3600*Integer.parseInt(strHora.substring(0,2)))+minuto;
if (hora>43199){
hora = minuto;
}
}
repaint();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
};
Thread thread = new Thread(runnable);
thread.start();
}
catch(Exception ex){
ex.printStackTrace();
}
}
public void paintComponent(Graphics g){
Graphics2D g2d = (Graphics2D) g.create();
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
super.paintComponent( g );
/**
* Circulo do relogio
*/
//g2d.drawArc(0, 0, this.tamanho, this.tamanho, 0, 360);
/**
* Imagem de fundo
*/
g2d.drawImage(fundo, 0, 0, this.tamanho, this.tamanho, null);
/**
* Ponteiro da hora
*/
g2d.setColor(this.cHora);
double theta = (2 * Math.PI * 1/43200) * hora;
normalizeHoras(g2d, new Dimension(this.tamanho,this.tamanho));
g2d.setStroke(new BasicStroke (0.07f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
g2d.draw (new Line2D.Double(0, 0, Math.sin(theta), Math.cos(theta)));
g2d.dispose();
/**
* Ponteiro do minuto
*/
g2d = (Graphics2D) g.create();
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2d.setColor(this.cMinuto);
theta = (2 * Math.PI * 1/3600) * minuto;
normalizeMinutos(g2d, new Dimension(this.tamanho,this.tamanho));
g2d.setStroke(new BasicStroke (0.04f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
g2d.draw (new Line2D.Double(0, 0, Math.sin(theta), Math.cos(theta)));
g2d.dispose();
/**
* Ponteiro do segundo
*/
g2d = (Graphics2D) g.create();
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2d.setColor(this.cSegundo);
theta = (2 * Math.PI * 1/60) * segundo;
double seno = Math.sin(theta);
double cosseno = Math.cos(theta);
normalizeSegundos(g2d, new Dimension(this.tamanho,this.tamanho));
g2d.setStroke(new BasicStroke (0.02f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
g2d.draw (new Line2D.Double(-0.25*seno, -0.25*cosseno, seno, cosseno));
g2d.dispose();
/**
* Pino
*/
g2d = (Graphics2D) g.create();
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2d.drawImage(pinoRelogio, (this.tamanho/2)-(tamanhoPino/2), (this.tamanho/2)-(tamanhoPino/2), tamanhoPino,tamanhoPino, null);
g2d.dispose();
}
}
[/code]
