# JFrame mit Zeigeruhr updaten



## Jason (7. Nov 2005)

Ich hab ein JFrame und dort dann mit der paint() Methode eine Zeiger Uhr gemalt. Ausserdem erhalte ich durch einen thread immer die aktuelle Zeit und die Zeiger stellung hab ich auch schon fertig. Wie kann ich aber den JFrame sagen das es sich nach jeder Sekunde auch erneuern soll?


----------



## Campino (7. Nov 2005)

Jason hat gesagt.:
			
		

> Ich hab ein JFrame und dort dann mit der paint() Methode eine Zeiger Uhr gemalt. Ausserdem erhalte ich durch einen thread immer die aktuelle Zeit und die Zeiger stellung hab ich auch schon fertig. Wie kann ich aber den JFrame sagen das es sich nach jeder Sekunde auch erneuern soll?


Im Thread JFrame.repaint() aufrufen...


----------



## lin (7. Nov 2005)

Oder machs mit nem Timer
http://java.sun.com/j2se/1.4.2/docs/api/java/util/Timer.html
http://www.galileocomputing.de/open...avainsel_090003256DieKlassenTimerundTimerTask


----------



## Guest (7. Nov 2005)

muss ich repaint nicht im thread machen damit immer nach jeder sekunde neugeschrieben wird?


----------



## lin (7. Nov 2005)

kannst du mal bisserl code posten, plz 

sonst wie gesagt, mit Timer, da kannste ne TimerTask übergeben, in welcher du immer ne bestimmte Methode aufrufst und diese TimerTask kannst du mit schedule alle x milisekunden aufrufen.


----------



## Jason (7. Nov 2005)

```
public class ClockGui extends JFrame implements TimeCustomer { 
   private JLabel timeLabel; 
   private ClockThread clock; 
   private DateFormat formatter; 

    
   public ClockGui(String title) { 
      super(title); 
      setSize(250, 100); 
      setLocationRelativeTo(null); 
      setDefaultCloseOperation(EXIT_ON_CLOSE); 
      
      //formatter = new SimpleDateFormat("HH:mm:ss"); 
      
      
      timeLabel = new JLabel("00:00:00", (int)JLabel.CENTER_ALIGNMENT); 
      
      getContentPane().add(timeLabel); 

      clock = new ClockThread(this); 
      clock.start(); 
     
   } 

   public void getTime() { 
    timeLabel.setText(clock.getDate().toString());  
   	//timeLabel.setText(formatter.format(clock.getDate())); 
   } 
    
   
}
```

der thread

```
public class ClockThread extends Thread {  
   private TimeCustomer tc; 
   private Date date;
   private AnalogUhrGui gui;

   public ClockThread(TimeCustomer tc) { 
      this.tc = tc; 
   } 

   public void run() {
	while (true) 
	{
		date = new Date();
		try 
		{
			
			System.out.println(date);
			tc.getTime();
			
			sleep(1000);
			
		}
		catch (Exception e) 
		{
			System.out.println("");
		}
	}
}

   public Date getDate() {
      return date;
   }
}
```


interface

```
public interface TimeCustomer {
	public void getTime(); 
}
```

gui

```
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Date;

public class AnalogUhrGui extends JFrame implements TimeCustomer{

	int mystunde;
	int myminute;
	int mysekunde;
	private ClockThread thread;
	private Date date = new Date();
	
	public AnalogUhrGui(int stunde, int minute, int sekunde)
	{
		
		super("Uhr");
		
		mystunde = stunde;
		System.out.println(mystunde);
		myminute = minute;
		System.out.println(myminute);
		mysekunde = sekunde;
		System.out.println(mysekunde);
		
		
		this.setBackground(Color.lightGray);
		this.setLocation(200,250);
		this.setSize(400,300);
		this.setDefaultCloseOperation( EXIT_ON_CLOSE );
		this.setVisible(true);
		
		thread = new ClockThread(this);
		thread.start();
		
		
	}
	
	
	public void paint(Graphics g)
	   { code für die uhr
	
	public void getTime() { 
		date = thread.getDate();
		mystunde = date.getHours();
		myminute = date.getMinutes();
		mysekunde = date.getSeconds(); 
	 } 
	
	
	
	
	
}
```


----------



## Jason (8. Nov 2005)

Kannst du damit was anfangen lin?


----------



## L-ectron-X (8. Nov 2005)

Hm... Teile des Codes kommen mir irgendwie bekannt vor... :wink: 
 :arrow: http://www.java-forum.org/de/viewtopic.php?t=23788

Die Methoden:

```
Date#getHours()
Date#getMinutes()
Date#getSeconds()
```
sind allesamt deprecated. Es ist besser, wenn du statt diesen die Methoden aus Calandar/GregorianCalendar verwendest.


----------



## Guest (8. Nov 2005)

Die oberste Klasse war eh falsch. Die kommt da gar nicht rein bzw gehört nicht zu dem Projekt.
dafür fehlte


```
import java.util.Date;


public class AktuelleZeit {
	
	public static int getstunde()
	{
		Date a = new Date();
		return a.getHours();
	}
	
	public static int getminute()
	{
		Date a = new Date();
	    return a.getMinutes();
	}
	
	public static int getsekunde()
	{
		Date a = new Date();
		return a.getSeconds();
	}
}
```


----------



## Guest (8. Nov 2005)

und starten tut alles in der mainklasse


```
public class Main {

	private AnalogUhrGui uhranzeige;
	
	public static void main(String[] args) {
		try
		{
		UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		Main test = new Main();
		
		}
		catch(Exception e) {};
	}
	
	public Main()
	{
		
		int stunde = AktuelleZeit.getstunde();
		int minute = AktuelleZeit.getminute();
		int sekunde = AktuelleZeit.getstunde();
		if (stunde == 13)
		{
			stunde = 1; 
		}
		else if (stunde == 14)
		{
			stunde = 2;
		}
		else if (stunde == 15)
		{
			stunde = 3;
		}
		else if (stunde == 16)
		{
			stunde = 4;
		}
		else if (stunde == 17)
		{
			stunde = 5;
		}
		else if (stunde == 18)
		{
			stunde = 6;
		}
		else if (stunde == 19)
		{
			stunde = 7;
		}
		else if (stunde == 20)
		{
			stunde = 8;
		}
		else if (stunde == 21)
		{
			stunde = 9;
		}else if (stunde == 22)
		{
			stunde = 10;
		}else if (stunde == 23)
		{
			stunde = 11;
		}else if (stunde == 24)
		{
			stunde = 12;
		}
		
		System.out.println(stunde + "." + minute + "." + sekunde); //Testausgabe
		
		uhranzeige = new AnalogUhrGui(stunde,minute,sekunde);
		
	}
	
	
	
	
}
```


----------



## lin (8. Nov 2005)

So, ich hab das jetzt mal alles n bisserl zusammengekürzt, weiss nicht ob du das so wolltest: 


```
import javax.swing.*;

import java.text.SimpleDateFormat;
import java.util.*;
import java.util.Timer;

public class Main {
	AnalogUhrGui uhranzeige = new AnalogUhrGui();

	public static void main(String[] args) {
		try {
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
			new Main();

		} catch (Exception e) {
			System.out.println(e);
		}
	}

	public Main() {
		TimerTask task = new TimerTask() {
			public void run() {
				long time = System.currentTimeMillis();
				SimpleDateFormat formater = new SimpleDateFormat();
				formater.applyPattern("ss");
				int sec = Integer.parseInt(formater.format(time));
				formater.applyPattern("mm");
				int min = Integer.parseInt(formater.format(time));
				formater.applyPattern("hh");
				int h = Integer.parseInt(formater.format(time));

				uhranzeige.setTime(h, min, sec);
			}
		};
		new Timer().schedule(task, 0, 1000);

	}
}
```


```
import javax.swing.JFrame;
import javax.swing.JTextField;

public class AnalogUhrGui extends JFrame {

	private JTextField f;

	public AnalogUhrGui() {
		super("Uhr");
		setLocation(200, 250);
		setDefaultCloseOperation(EXIT_ON_CLOSE);

		f = new JTextField();
		getContentPane().add(f);

		pack();
		setVisible(true);
	}

	public void setTime(int h, int min, int sec) {
		f.setText(h + ":" + min + ":" + sec);
	}
}
```

Wenn du Fragen hast, einfach fragen :wink:


----------



## Jason (9. Nov 2005)

Soweit ich das sehe füllst du die zeit daten in das TextField. Das wäre dann eine digitale Uhr. Ich wollte aber eine Uhr mit Zeigern  Also auf die altmodische Art


----------



## André Uhres (9. Nov 2005)

```
/*
 * Clock.java
 */

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;

class Clock extends JPanel implements ActionListener {

    private Color gold = new Color(220, 185, 50);
    private int xM = 200,  yM = 200;
    private int hour,  minute,  second;
    private int xCoord[] = new int[5];
    private int yCoord[] = new int[5];
    private Timer timer;

    public Clock() {
        setPreferredSize(new Dimension(400, 400));
        timer = new Timer(1000, this);
        timer.setInitialDelay(0);
        timer.start();
    }

    private void drawClock(final Graphics g) {
        //Zifferblatt:
        for (int i = 0; i <= 12; i++) {
            if (i < 5 | i > 6) {
                g.setColor(gold);
            } else {
                g.setColor(Color.red);
            }
            g.drawOval(xM - 140 + i, yM - 140 + i, 280 - 2 * i, 280 - 2 * i);
        }
        //Stunden Marken:
        g.setColor(Color.red);
        for (int i = 1; i <= 12; i++) {
            double xAbstand = 120 * Math.cos(Math.PI / 2 - i * Math.PI / 6);
            double yAbstand = 120 * Math.sin(Math.PI / 2 - i * Math.PI / 6);
            int x = xM + (int) xAbstand;
            int y = yM - (int) yAbstand;
            int xStd = x - 5;
            int yStd = y + 5;
            g.drawString("" + i, xStd, yStd);
        }
        //Stunden Zeiger:
        double schritt = minute * Math.PI / 360;
        double winkel = hour * Math.PI / 6 + schritt;
        int xiR = xM + (int) (4 * Math.cos(-winkel));
        int yiR = yM - (int) (4 * Math.sin(-winkel));
        int xaR = xiR + (int) (90 * Math.cos(Math.PI / 2 - winkel));
        int yaR = yiR - (int) (90 * Math.sin(Math.PI / 2 - winkel));
        int xs = xM + (int) (100 * Math.cos(Math.PI / 2 - winkel));
        int ys = yM - (int) (100 * Math.sin(Math.PI / 2 - winkel));
        int xaL = xaR + (int) (8 * Math.cos(Math.PI - winkel));
        int yaL = yaR - (int) (8 * Math.sin(Math.PI - winkel));
        int xiL = xaL + (int) (90 * Math.cos(3 * Math.PI / 2 - winkel));
        int yiL = yaL - (int) (90 * Math.sin(3 * Math.PI / 2 - winkel));
        xCoord[0] = xiR;
        xCoord[1] = xaR;
        xCoord[2] = xs;
        xCoord[3] = xaL;
        xCoord[4] = xiL;
        yCoord[0] = yiR;
        yCoord[1] = yaR;
        yCoord[2] = ys;
        yCoord[3] = yaL;
        yCoord[4] = yiL;
        g.setColor(Color.blue);
        g.fillPolygon(xCoord, yCoord, 5);
        g.fillOval(xM - 15, yM - 15, 30, 30);
        //Minuten Zeiger:
        schritt = minute * Math.PI / 30;
        xiR = xM + (int) (3 * Math.cos(-schritt));
        yiR = yM - (int) (3 * Math.sin(-schritt));
        xaR = xiR + (int) (112 * Math.cos(Math.PI / 2 - schritt));
        yaR = yiR - (int) (112 * Math.sin(Math.PI / 2 - schritt));
        xaL = xaR + (int) (6 * Math.cos(Math.PI - schritt));
        yaL = yaR - (int) (6 * Math.sin(Math.PI - schritt));
        xiL = xaL + (int) (112 * Math.cos(3 * Math.PI / 2 - schritt));
        yiL = yaL - (int) (112 * Math.sin(3 * Math.PI / 2 - schritt));
        xCoord[0] = xiR;
        xCoord[1] = xaR;
        xCoord[2] = xaL;
        xCoord[3] = xiL;
        yCoord[0] = yiR;
        yCoord[1] = yaR;
        yCoord[2] = yaL;
        yCoord[3] = yiL;
        g.fillPolygon(xCoord, yCoord, 4);
        //Sekunden Zeiger:
        schritt = second * Math.PI / 30;
        int xSek = xM + (int) (115 * Math.cos(Math.PI / 2 - schritt));
        int ySek = yM - (int) (115 * Math.sin(Math.PI / 2 - schritt));
        g.setColor(Color.red);
        g.drawLine(xM, yM, xSek, ySek);
        g.fillOval(xM - 6, yM - 6, 12, 12);
    }

    @Override
    public void paintComponent(final Graphics g) {
        super.paintComponent(g);
        ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        drawClock(g);
        g.dispose();
    }

    public void actionPerformed(final ActionEvent e) {
        GregorianCalendar heute = new GregorianCalendar();
        hour = heute.get(Calendar.HOUR_OF_DAY);
        minute = heute.get(Calendar.MINUTE);
        second = heute.get(Calendar.SECOND);
        repaint();
    }

    public static void main(final String args[]) {
        JFrame f = new JFrame("Zeiger-Uhr");
        f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        f.getContentPane().add(new Clock());
        f.pack();
        f.setLocationRelativeTo(null);
        f.setVisible(true);
    }
}
```


----------



## lin (10. Nov 2005)

Jason hat gesagt.:
			
		

> Soweit ich das sehe füllst du die zeit daten in das TextField. Das wäre dann eine digitale Uhr. Ich wollte aber eine Uhr mit Zeigern  Also auf die altmodische Art



Die Daten die da über die setTime Methode kommen, musst du dann halt noch mit sinus und cosinus entsprechend umrechnen... Oder kannst natürlich auch von Anfang an ne fertig programmierte Uhr nehmen ^^ :wink:


----------



## Jason (10. Nov 2005)

Hi. Habs nun auch geschafft wobei mir die Uhr von Andre besser gefällt. Ich habs nämlich die Grafi schlecht programmiert. Eigentlich total peinlich auch wenn es funktioniert. Ich hab die Zeigerdarstellung per if else gemacht 

```
....
if (myminute == 1) {
		g.drawLine(200,150,210,52); }//01 Sekunden
		else if (myminute == 2) {
		g.drawLine(200,150,220,55); }//02 Sekunden
		else if (myminute == 3) {
		g.drawLine(200,150,230,58); }//03 Sekunden
.....
```

Der Rest geht eigentlich:
Meine Uhr:


```
public class Main {
	
	private AnalogUhrGui uhranzeige;
	
	public static void main(String[] args) {
		try
		{
		UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		new Main();
		
		}
		catch(Exception e) {
			System.out.println(e);
		};
	}
	
	public Main()
	{	
		int stunde = AktuelleZeit.getstunde();
		int minute = AktuelleZeit.getminute();
		int sekunde = AktuelleZeit.getstunde();
		if (stunde > 11)
		{
			stunde = stunde - 12; 
		}
		
		
		System.out.println(stunde + "." + minute + "." + sekunde); //Testausgabe
		
		uhranzeige = new AnalogUhrGui(stunde,minute,sekunde);
	}
}
```



```
import java.util.Date;


public class AktuelleZeit {
	
	public static int getstunde()
	{
		Date a = new Date();
		return a.getHours();
	}
	
	public static int getminute()
	{
		Date a = new Date();
	    return a.getMinutes();
	}
	
	public static int getsekunde()
	{
		Date a = new Date();
		return a.getSeconds();
	}
}
```




```
import java.awt.*;
import javax.swing.*;
import java.util.Date;

public class AnalogUhrGui extends JFrame /*implements TimeCustomer*/{

	int mystunde;
	int myminute;
	int mysekunde;
	private ClockThread thread;
	private Date date = new Date();
	
	private JPanel p = new JPanel();
	
	public AnalogUhrGui(int stunde, int minute, int sekunde)
	{
		
		super("Uhr");
		
		mystunde = stunde;
		System.out.println(mystunde);
		myminute = minute;
		System.out.println(myminute);
		mysekunde = sekunde;
		System.out.println(mysekunde);
		
		
		this.setBackground(Color.lightGray);
		this.setLocation(200,250);
		this.setSize(400,300);
		this.setDefaultCloseOperation( EXIT_ON_CLOSE );
		this.setContentPane(p);
		this.setVisible(true);
		
		thread = new ClockThread(this);
		thread.start();
		
		
	}
	
	
	
	public void paint(Graphics g)
	   {
		g.setColor( Color.blue );
		g.drawOval(100,50,200,200); //Kreis
		
		g.setColor(Color.red);
		//System.out.println("die Stunde is" + stunde);
		if (mystunde > 11) {
			mystunde -= 12;
		}
		
		if (mystunde == 12) {
		g.drawLine(200,150,200,50);} //12 Uhr
		else if (mystunde == 1) {
......................
.........PEINLICH:)
................
else  {
	g.drawLine(200,150,200,50); }//60 Sekunden und 0 Sekunden ELSE
		
		g.drawString("12", 195, 45);
		g.drawString("3",  305, 150);
		g.drawString("9", 90, 150);
		g.drawString("6", 195, 265);
	}
	
	
	public void setTime(Date date) { 
		
		mystunde = date.getHours();
		myminute = date.getMinutes();
		mysekunde = date.getSeconds(); 
	 } 
	
	public void erneuern() {
		p.updateUI();
		this.repaint();
		//this.setVisible(false);
		//this.setVisible(true);
	}
	
	public static void
	drawThickLine( int x, int y, int x2, int y2, int thickness, Graphics g )
	{
	  int b = Math.round( thickness /2), deltax, deltay;
	  double angle;
	  //if (y2==y) alpha = 0; else
	  angle = Math.atan( (double)((y2-y)/(x2-x)) );
	  deltay = (int)Math.round( (Math.cos(angle)*b) );
	  deltax = (int)Math.round( (Math.sin(angle)*b) );
	  Polygon p = new Polygon();
	  p.addPoint( x-deltax, y+deltay );
	  p.addPoint( x+deltax, y-deltay );
	  p.addPoint( x2+deltax, y2-deltay );
	  p.addPoint( x2-deltax, y2+deltay );
	  g.fillPolygon( p );
	}
	
	
}
```





```
import java.util.*;



public class ClockThread extends Thread {  
   //private TimeCustomer tc; 
   private Date date;
   private AnalogUhrGui gui;
/*
   public ClockThread(TimeCustomer tc) { 
      this.tc = tc; 
   }*/ 
   public ClockThread(AnalogUhrGui gui1) {
   this.gui = gui1;
   }

   public void run() {
	while (true) 
	{
		date = new Date();
		try 
		{
			
			System.out.println(date);
			//tc.getTime();
			//gui.repaint();
			gui.setTime(date);
			gui.erneuern();
			sleep(1000);
			
		}
		catch (Exception e) 
		{
			System.out.println("");
		}
	}
}

   public Date getDate() {
      return date;
   }
}
```


----------



## lin (10. Nov 2005)

> Ich hab die Zeigerdarstellung per if else gemacht


Hilfeeee!! Was für ne Arbeit, wie lange hattest du denn dafür?  :wink:


----------



## Jason (10. Nov 2005)

hehe so ne stunde 
aber ich setzt mich nun ran das allein umzuschreiben. Muss ich nochmal meine Mathebücher auskramen ^^


----------

