# Graphics auf JFrame Koordinatensystem



## MarkusKirch (21. Mai 2011)

Hallo!
Ich habe eine GUI gebastelt, in die ich einen Funktionsterm eingeben kann und möchte diese Funktion zeichnen lassen.
Ich habe eine Methode, in der alle X-Werte von -10 - 10 in schritten von 0.02 (1px bei 1000px Fenstergröße) durchgerechnet werden und die X- und Y-Werte bereits als Koordinaten ausgerechnet (als für das JFrame indem sie gezeichnet werden sollen) in eine List<Point> eingetragen werden, die ich theoretisch nurnoch zeichnen müsste.

Also habe ich in der Liste z.B. folgende Punkte:
(500/500)
(501/490)
(502/460)
(503/400)
[...]

Ich möchte nun, dass diese Punkte der Reihe nach mit einer Linie verbunden werden, wenn ich die Funktion dazu aufrufe und diese Linien in meinem JFrame (oder von mir aus auch einem untergeordnetem JPanel) angezeigt werden...

Bisher habe ich noch nicht mit paint(Graphics g) gearbeitet und habe mit folgenden Codeansatz erarbeitet:


```
public List<Point> punkte = new LinkedList<Point>();
	public Point letzterPunkt, aktuellerPunkt;
	public JFrame f;

	public void paint(Graphics g) {
		Iterator<Point> it = punkte.iterator();

		while(it.hasNext()) {
			if(aktuellerPunkt!=null) {
				letzterPunkt=aktuellerPunkt;
			}
			aktuellerPunkt = it.next();
			if(letzterPunkt!=null) {
				g.drawLine(letzterPunkt.x, letzterPunkt.y, aktuellerPunkt.x, aktuellerPunkt.y);
			}
		}
	}
```

Nur:
Wann wird paint(g) aufgerufen (habe gelesen bei f.setVisible(true), bzw. wie kann ich es manuell tun?
Was bedeutet eigentlich genau das Ojekt Graphics g?! Was wäre es in meinem Falle? Muss ich noch ein erzeugen?
Oder noch besser: Gibt es eine Alternative, mit der ich die Punkte ohne Graphics g verbinden kann?!

VG und Danke für die Hlfe!

Markus


----------



## MarkusKirch (22. Mai 2011)

Also ich habe das Tutorial zu diesem Thema entdeckt ;-)

Jetzt habe ich nach den Anweisungen des Tuts folgendes geschrieben:


```
public void actionPerformed(ActionEvent e) {
		System.out.println("ActionPerformed für "+e.getSource()+" ausgeführt");
		if(e.getSource()==zeichneFunktion) {

			while(it.hasNext()) {
				if(aktuellerPunkt!=null) {
					letzterPunkt=aktuellerPunkt;
				}
				aktuellerPunkt = it.next();
				if(aktuellerPunkt!=null) {
					paintComponent.setBounds(0, formelHoehe, 1000, 1000);
					paintComponent.setVisible(true);
					paintComponent.zeichneLinie(letzterPunkt.x, letzterPunkt.y, aktuellerPunkt.x, aktuellerPunkt.y);
					paintComponent.repaint();
				}
			}
		}

	}
}

class MeinePaintingComponent extends JComponent {
	private int letzteX=0, letzteY=0, aktuelleX=0, aktuelleY=0;
	
    
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        
		if(letzteX!=0 && letzteY!=0 && aktuelleX!=0 && aktuelleY!=0) {
			g.drawLine(letzteX, letzteY, aktuelleX, aktuelleY);
		}
    }
    
    public void zeichneLinie(int vonX, int vonY, int bisX, int bisY) {
        letzteX=vonX;
        letzteY=vonY;
        aktuelleX=bisX;
        aktuelleY=bisY;
    }

}
```

Leider funktioniert es immernoch nicht!
Ich bekomme noch nicht einmal eine 1000*1000px große JComponent angezeigt (Auch nicht wenn ich sofort bei der Init setVisible auf true habe bzw eine BGColor gesetzt habe).

Könnt ihr mir BITTE helfen?!

VG Markus


----------



## Marco13 (22. Mai 2011)

Ja, die richtige Lösung wäre eine Mischung aus beidem. "paint" (bzw. paintComponent) wird sozusagen(!) "vom Betriebssystem" (bzw. dem Fenstermanager, Windows zum Beispiel) aufgerufen, und zwar immer dann, wenn das Fenster neu gezeichnet werden muss. Z.B. wenn das Fenster kurz verdeckt war, und wieder sichtbar wird. Das "Graphics", das dort übergeben wird, ist sozusagen der "Zugang" zu dem Bereich auf dem Bildschirm, wo hingezeichnet werden kann. (Alles sehr vereinfacht...).

Damit ist vielleicht der Ablauf etwas klarer: ALLES, was gezeichnet wird, muss von der paintComponent-Methode aus gezeichnet werden. Und zwar immer alles "in einem Rutsch". Ganz grob bräuchtest du sowas wie

```
class PlotPanel extends JPanel
{
    private List<Point> points = ...

    @Override
    public void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        Point previous = points.get(0);
        for (int i=1; i<points.size(); i++)
        {
            Point current = points.get(i);
            g.drawLine(previous.x, previous.y, current.x, current.y);
            previous = current;
        }
    }
}
```


----------



## MarkusKirch (22. Mai 2011)

Ok, danke für die Erklärung von paintComponent(g)!

Den Code, den du gepostet hast, hatte ich fast genau so schon implementiert, habe nur vergessen, die Methode punkteHinzufuegen() aufzurufen, die Werte in die List<Point> einträgt...

Des wegen konnte ja nur eine leere Liste gezeichnet werden ;-)

Meistens scheitert es an so banalen Dingen 


Trotzdem Danke für die Hilfe, jetzt funktioniert es!!!

VG Markus


----------

