2D-Grafik timer bei Analoguhr

[maxe]

Hallo, ich bin gerade daran eine Analoguhr zu programmieren, bei der man eine Uhrzeit eingibt und dann die Uhrzeit angezeigt wird. Zusätzlich soll die Uhrzeit an der Seite von dem angegebenen Zeitpunkt weiterlaufen. Anbei liegt der bisher geschriebene Code. Meine Frage ist dem timer gewidmet: Ich müsste die Variablen innerhalb einer Funktion aufrufen. Diese Funktion wird jedoch durch ein Runnable wiederholt. Die Variablen sollen aber nur am Anfang den vorher festgelegten Wert annehmen und in den weiteren durchgängen sollen sie sich immer wieder updaten. Ich hoffe ich konnte meine Frage Präzise genug formulieren. Ein Blick in den Code denke ich ist sogar noch verständlicher.
Ein Danke schonmal im Vorraus an jeden, der sich mit meinem Problem befasst.

 

[mihe7]

Ein Blick in den Code denke ich ist sogar noch verständlicher.

Ein Blick in diesen Code nicht wirklich... static, nicht static, direktes Zeichnen, zig Variablen, Benennungskonventionen nicht eingehalten, alles in einer Klasse... Da braucht man Stunden, um durchzublicken. Ganz davon abgesehen, dass die Berechnung der Zeiger falsch ist. Kurz: der Timer ist wirklich Dein kleinstes Problem.

Teil das ganze vernünftig auf Klassen auf. Beispiel: Du brauchst keine drei Variablen für eine Uhrzeit. Java hat dafür Klassen, z. B. LocalTime kann das richtig gut. Aber selbst, wenn Du nicht auf LocalTime zurückgreifen willst, hält Dich nichts davon ab, eine Klasse dafür zu implementieren. Die Analoguhr selbst ist eine Komponente, also schreib auch eine (extends JComponent und paintComponent überschreiben).

Ganz am Schluss hast Du das Programmfenster, in dem sich neben der Aanaloguhr auch die Eingabe befindet. Dort kannst Du auch einen Timer starten, die Zeit in der Analoguhr setzen, fertig.

 

[Blender3D]

Ein Blick in den Code denke ich ist sogar noch verständlicher.
Ein Danke schonmal im Vorraus an jeden, der sich mit meinem Problem befasst.

Da der Blick in den Code leider nicht wirklich verständlich war, habe ich diesen etwas überarbeitet. Zum Testen die jar einfach herunterladen.

import javax.swing.JFrame;

public class StartWatch {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Watch");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        WatchPanel watch = new WatchPanel(300, 300);
        frame.add(watch);
        frame.setResizable(false);
        frame.pack();
        frame.setVisible(true);
    }
}

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import javax.swing.JPanel;

@SuppressWarnings("serial")
public class WatchPanel extends JPanel implements WatchObserver {
    private GraphicWatch watch = new GraphicWatch(23, 59, 45);

    public WatchPanel(int width, int height) {
        setPreferredSize(new Dimension(width, height));
        watch.start();
        int size = 200;
        watch.setSize(size);
        watch.setPos((width - size) / 2, (height - size) / 2);
        watch.setObserver(this);
        setBackground(Color.DARK_GRAY);
    }

    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        watch.draw(g, this);
    }

    @Override
    public void update(Object sender) {
        repaint();
    }

}

public interface WatchObserver {
    public void update(Object sender);
}

import java.awt.Graphics;
import java.awt.Point;

public class GraphicWatch extends Watch {
    private int x = 0;
    private int y = 0;
    private int size = 100;
    private WatchView view = new DefaultWatchView();

    public GraphicWatch(int hour, int min, int sec) throws IllegalArgumentException {
        super(hour, min, sec);
    }

    @Override
    public void draw(Graphics g) {
        view.draw(g, this);
    }

    public Point getCenter() {
        int radius = getRadius();
        return new Point(x + radius, y + radius);
    }

    public int getRadius() {
        return size / 2;
    }

    public int getSize() {
        return size;
    }

    public Point getPos() {
        return new Point(x, y);
    }

    public void setPos(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public void setView(WatchView view) {
        this.view = view;
        if (view == null)
            view = new DefaultWatchView();
    }

}

public class Watch implements Runnable {
    private int hour;
    private int min;
    private int sec;
    public static final int HOUR_PER_DAY = 24;
    public static final int MIN_PER_HOUR = 60;
    public static final int SEC_PER_MIN = 60;
    private static final int MILLI_SEC_PER_SEC = 1000;
    private Thread timer;
    private boolean running = false;
    private WatchObserver observer;

    public Watch(int hour, int min, int sec) throws IllegalArgumentException {
        Watch.checkTimeRange(hour, min, sec);
        this.hour = hour;
        this.min = min;
        this.sec = sec;
        start();
    }

    public boolean isRunning() {
        return timer != null && timer.isAlive();
    }

    private static void checkTimeRange(int hour, int min, int sec) {
        checkHourRange(hour);
        checkMinRange(min);
        checkSecRange(sec);
    }

    private static void checkHourRange(int hour) {
        if (hour < 0 || hour >= HOUR_PER_DAY)
            throw new IllegalArgumentException("Hour range is from 0-" + (HOUR_PER_DAY - 1));
    }

    private static void checkMinRange(int min) {
        if (min < 0 || min >= MIN_PER_HOUR)
            throw new IllegalArgumentException("Minute range is from 0-" + (MIN_PER_HOUR - 1));
    }

    private static void checkSecRange(int sec) {
        if (sec < 0 || sec >= SEC_PER_MIN)
            throw new IllegalArgumentException("Second range is from 0-" + (SEC_PER_MIN - 1));
    }

    public int getHours() {
        return hour;
    }

    public int getMinutes() {
        return min;
    }

    public int getSeconds() {
        return sec;
    }

    public void resetTime() {
        hour = min = sec = 0;
    }

    @Override
    public void run() {
        while (running) {
            try {
                Thread.sleep(MILLI_SEC_PER_SEC);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            tick();
            if (observer != null)
                observer.update(this);
        }
    }

    public void setObserver(WatchObserver observer) {
        this.observer = observer;
    }

    public void start() {
        stop();
        running = true;
        timer = new Thread(this);
        timer.start();
    }

    public void stop() {
        running = false;
        while (isRunning())
            ;
        timer = null;
    }

    private void tick() {
        sec++;
        if (sec >= SEC_PER_MIN) {
            sec = 0;
            min++;
            if (min >= MIN_PER_HOUR) {
                min = 0;
                hour++;
                if (hour >= HOUR_PER_DAY)
                    resetTime();
            }
        }
    }

    @Override
    public String toString() {
        return String.format("%02d:%02d:%02d", hour, min, sec);
    }

}

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.RenderingHints;

public class DefaultWatchView implements WatchView {

    @Override
    public void draw(Graphics g, GraphicWatch w) {
        Graphics2D g2 = (Graphics2D) g;
        drawDial(g2, w);
        drawShortHand(g2, w);
        drawMinuteHand(g2, w);
        drawSecondHand(g2, w);
    }

    public void drawDial(Graphics g, GraphicWatch w) {
        Graphics2D g2D = (Graphics2D) g;
        g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2D.setBackground(Color.BLACK);
        Point pos = w.getPos();
        int size = w.getSize();
        g2D.fillOval((int) (pos.x), (int) (pos.y), (int) size, (int) size);
        g2D.setColor(Color.WHITE);
        g2D.setStroke(new BasicStroke(2));
        g2D.drawOval(pos.x, pos.y, size, size);
        drawNumbers(g2D, w);
    }

    private void drawNumbers(Graphics2D g2d, GraphicWatch w) {
        Point pos = w.getCenter();
        g2d.setStroke(new BasicStroke(10));
        g2d.setColor(Color.WHITE);
        double angle;
        int x, y;
        double radius = w.getRadius() * .8;
        Font font = g2d.getFont().deriveFont((float) (radius / 3));
        int fontSize = font.getSize();
        g2d.setFont(font);
        FontMetrics fm = g2d.getFontMetrics();
        for (int i = 1; i <= Watch.HOUR_PER_DAY / 2; i++) {
            angle = i * Math.PI / 6;
            x = (int) (radius * Math.sin(angle));
            y = (int) (radius * Math.cos(angle));
            String val = i + "";
            int width = fm.stringWidth(val);
            g2d.drawString(val, pos.x + x - width / 2, pos.y - y + fontSize / 2);
        }
    }

    public void drawHand(GraphicWatch w, Graphics2D g, Point handPos) {
        Point center = w.getCenter();
        g.drawLine(center.x, center.y, handPos.x, handPos.y);
    }

    private void drawMinuteHand(Graphics2D g2, GraphicWatch w) {
        Point handPos = getHandTopPos(w, w.getMinutes(), Watch.MIN_PER_HOUR, 3 * w.getRadius() / 4);
        g2.setColor(Color.WHITE);
        g2.setStroke(new BasicStroke(1.5f));
        drawHand(w, g2, handPos);
    }

    private void drawSecondHand(Graphics2D g2, GraphicWatch w) {
        Point handPos = getHandTopPos(w, w.getSeconds(), Watch.SEC_PER_MIN, 7 * w.getRadius() / 8);
        g2.setColor(Color.RED);
        g2.setStroke(new BasicStroke(1.5f));
        drawHand(w, g2, handPos);
        Point center = w.getCenter();
        int size = (int)(w.getSize()*.07);
        g2.fillOval(center.x-size/2, center.y-size/2, size, size);
    }

    private void drawShortHand(Graphics2D g2, GraphicWatch w) {
        Point handPos = getHandTopPos(w, w.getHours(), Watch.HOUR_PER_DAY / 2, w.getRadius() / 2);
        g2.setColor(Color.WHITE);
        g2.setStroke(new BasicStroke(2.5f));
        drawHand(w, g2, handPos);
    }

    private Point getHandTopPos(GraphicWatch w, int timeValue, int maxTimeValue, double handSize) {
        Point pos = w.getPos();
        Point center = w.getCenter();
        double angle = timeToAngle(timeValue, maxTimeValue);
        pos.x = center.x + (int) ((int) handSize * Math.cos(angle));
        pos.y = center.y + (int) ((int) handSize * Math.sin(angle));
        return pos;
    }

    private double timeToAngle(int time, int maxTime) {
        return Math.toRadians((time * (360.0 / maxTime)) - 90);
    }
}

import java.awt.Graphics;

public interface WatchView {
    public void draw(Graphics g, GraphicWatch w);
}