ArrayList<Line2D> mit g2d.draw() aufrufen

S

Schaaaf

Bekanntes Mitglied
Hallo,

ich habe eine ArrayList entworfen:

Java: 
public static ArrayList<Line2D> MyLines = new ArrayList<Line2D>();

Jetzt möchte ich aus dieser Liste jedes i-te Element grün färben und darstellen. Aber irgendwas haut nicht hin. Zumindestens sehe ich keinen Linie. :-(

Java: 
 public static Graphics2D g2d_high;

Java: 
protected void paintComponent( Graphics g){
super.paintComponent(g);
g2d_high = (Graphics2D)g;

Java: 
public static void getRelValues(Float RelVal, int RelValPos){
int step = 3;
for (int i = step; i < MyLines.size(); i=i+step){
g2d_high.setColor(Color.green);
g2d_high.drawLine(MyLines.get(i));
}
}


Was mache ich falsch?
 
So sollte man mit nem Graphics Objekt nicht umgehen. Es ist nicht garantiert, dass dein zwischengespeichertes Graphics Objekt noch gültig ist wenn deine getRelValues() Methode aufgerufen wird.

Wenn du zeichnest, dann mach das in der paintComponent() Methode.
 
Okay...
Mein Problem hierbei ist, dass ich getRelValue() aufrufe, wenn ein Button gedrückt wurde. Dann schaue ich halt nach welcher gedrückt wurde und so und anschließend lege ich damit die "step" Variable fest.

Wie kann ich das denn dann in die paintComponent() Methode einbauen, so dass es ja erst nach Button Klick ausgeführt/gemalt wird ?!
 
Wenn du den Button drückst veränderst du irgendwelche Werte und stößt dann per repaint() das neuzeichnen an. Die paintComponent() Methode schaut sich dann die Werte an und zeichnet dementsprechend.
 
Wo? Direkt nachdem du deine Daten geändert hast.
Wie? deineComponentDieDuAktualisierenWillst.repaint();
 
Aber wie gesagt, sieht meine paintComp so aus:

Java: 
protected void paintComponent( Graphics g){
super.paintComponent(g);
...

Wenn ich die jetzt aufrufe, dann muss ich ja paintComponent(g) aufrufen, aber g ist ja nicht public, da es in paintComp definiert wird.

Komme da irgendwie durcheinander.
 
Um das Graphics-Objekt brauchst du dich nicht weiter kümmern, es ist einfach da und stellt genau den Bereich deines Bildschirmes dar, den du halt grade brauchst...
 
Schreibe ich nur :

Java: 
paintComponent().repaint();

kommt diese Meldung :

The method paintComponent(Graphics) in the type Polygon is not applicable for the arguments ()
 
Wenn ich repaint() in meiner

Java: 
public static void getRelValues();

aufrufe, kommt dies.

Cannot make a static reference to the non-static method repaint() from the type Component

Ich weiß auch nicht was ich noch an Code posten sollte.
 
Wenn du nicht mehr Code posten kannst/willst, dann ließ dir das Tutorial durch, da werden all deine Fehler erklärt.
 
Habe das Tutorial durch, aber bin noch keinen Schritt weiter. Was soll ich noch posten? Was ist denn noch relevant für euch? Könnte heulen...
 
Grundsätzlich kann man nur sagen: Gezeichnet wird ausschließlich in der paintComponent. Ansonsten hilft: Grundlagen über Modifier und Zugriffsmöglichkeiten auf unterschiedlich deklarierte Variablen. Denken in Objekten...
 
Ansich ist ja jetzt dein prob, dass du repaint() nicht aus statischem Kontext aufrufen kannst... wuesste auch nicht wie das gehen sollte... aber wenn du den Rest auch nicht statisch machst, wuerdest du sie aufrufen koennen... hatte das prob vorhin auch selber, habe dan alles non-static gemacht...

Und es ist immer gut, möglichst viel Quellcode zu posten, dann kann man auch gleich Tips geben wie du es ummodelieren koenntest und etc....
 
Kann allen meinen Vorredner zustimmten.

Hier eine mögliche Lösung:
Java: 
// actionPerformed deines Buttons:
public void actionPerformed(ActionEvent evt) {
	/*
	 * drawingArea ist eine Instanz deiner Zeichenklasse, d.h. welche
	 * bei AWT von Panel oder Canvas und bei Swing von JPanel oder
	 * JComponent erbt. Evtl auch die Klasse selbst -> in diesem Fall
	 * anstatt von drawingArea.repaint(); dann this.repaint() aufrufen.
	 */
	drawingArea.repaint();
}

// deine Zeichenmethode, die paintComponent():
protected void paintComponent(Graphics g) {
	super.paintComponent(g);
	Graphics2D g2 = (Graphics2D) g;
	for(int i = 3; i<MyLines.size(); i+=3) {
		g2.setColor(Color.GREEN);
		g2.drawLine(MyLines.get(i));
	}
}

Dennoch solltest du dir unbedingt das Zeichnen in Swing Tutorial anschauen und verstehen. Evtl. hilft auch das KEIN Swing-Tutorial.
 
Da der Button in einer anderen Klasse ist, kann ich bei dem Aufruf nicht das static weglassen. Ich werde mir die Nacht noch den Kopf zerbrechen... Vlt. verstehe ich ja noch, was ich machen muss.
 
Du kannt der Klasse, die den Button enthaelt, get/set methoden geben, sprich den Button kapseln oder du machst den Button public und und sprichst ihn direkt an MeineKlasse.ButtonName, was die unschönere variante waere, wie ich finde ^^

[Java]
public JButton getButton(){
return deinButton;
}

public void setButton(JButton btn){
deinButton = btn;
}
[/Java]

aber alles statisch machen ist nicht schön... ^^
 
Hmja, sinngemäß: So, wie du bisher das Graphics weitergereicht hast, kannst du auch die Zeichen-Component weiterreichen. Aber mit dem static ist das halt in jedem Fall häßlich. Poste am besten einfach mal mehr Code, ein KSKB ist immer am besten.
 
Okay, danke für eure Mühen. Ich bastel jetzt erstmal meinen gesamten Code so um, dass static verschwindet und dann sortiere ich alles aus der paintComponent() Methode raus, was da nix zu suchen hat. Vlt. geht auch mir dabei ein Licht auf...Ich hoffe es.
 
So, das ist mein neuer Code:

1. Alles aus der paintComp rausgeworfen, was da nix zu suchen hat:

Java: 
public class PaintingClass extends JComponent
{
    private ArrayList<Shape> shapes = new ArrayList<Shape>();
    private ArrayList<JLabel> labels = new ArrayList<JLabel>();
    private ArrayList<Shape> lines = new ArrayList<Shape>();
    
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D)g;
        System.out.println("s: "+shapes.size()+"   l: "+lines.size()+"   lab: "+labels.size());
        if(shapes.size() != 0 ){
        	for (Shape s : shapes ) {
        		g2d.draw(s);
        	}
        } 
        
        if(lines.size() != 0 ){
        	for (Shape line : lines ) {
        		g2d.draw(line);
        	}
        }
        
        if (labels.size() != 0){
        	for (JLabel l : labels) {
        		this.add(l);
        	}
        }
    }
    
    public void setAllShapes(ArrayList<Shape> shapes) {
    	this.shapes = shapes;
    }
    
    public void setAllLines(ArrayList<Shape> lines) {
    	this.lines = lines;
    }
    
    public void setAllLabel(ArrayList<JLabel> labels) {
    	this.labels = labels;
    }
}

2. alles statische gelöscht. nur noch die Main ist static.

3. Die Button Methode :

Java: 
private Polygon polygon = new Polygon ();

private JButton neuMalen() {
		if (showBtn == null) {
			showBtn = new JButton("Neu malen");
			showBtn.setMaximumSize(new Dimension(150, 2));
			showBtn.addActionListener(new ActionListener() {
				public void actionPerformed(ActionEvent e) {
					polygon.getRelValues();	
				}
			});
		}
		return showBtn;
	}

4. aufgerufene Klasse polygon.getRelValues()

Java: 
public void getRelValues(Float RelVal, int RelValPos){
		
lines.clear();
		
Shape line = new Line2D.Float(120,120,200,200);
lines.add(line);

paintingComponent.setAllLines(lines);
paintingComponent.setAllShapes(shapes);
paintingComponent.repaint();
}

Jetzt sollte doch alles funktionieren, d.h. alle bisher gezeichnete Lines weg und nur die neue Linie malen.... dachte ich... aber geht wieder nicht. Was mache ich denn noch falsch?
 
ich weiß zwar nicht genau wie man ein KSKB macht, aber hier mal der Code (sind 4 Klassen)

Java: 
import java.awt.BorderLayout;

import javax.swing.JFrame;

	@SuppressWarnings("serial")
	public class ParallelCoordClass extends JFrame {
		
		public static void main(String[] args) {

			ParallelCoordClass pc = new ParallelCoordClass(); 
	        pc.setTitle("Mein Prog");    
   
	        Properties prop = new Properties();	        
	        pc.add(prop, BorderLayout.EAST);
	        
	        Polygon polygon = new Polygon();
	        pc.add(polygon, BorderLayout.WEST);

	        pc.setSize(1024,700); 
	        pc.setDefaultCloseOperation(EXIT_ON_CLOSE);
	        pc.setVisible(true);	
  
	   }			
	}

Java: 
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Shape;
import java.awt.geom.Line2D;
import java.util.ArrayList;

import javax.swing.BorderFactory;
import javax.swing.JPanel;

public class Polygon extends JPanel{
	
	private PaintingClass paintingComponent = new PaintingClass();
	private ArrayList<Shape> lines = new ArrayList<Shape>();
	
	public Polygon() {
		super();	
		initialize();
		createPaintComp();
	}
	
	private void initialize() {		
		this.setBorder(BorderFactory.createTitledBorder(null, "Many-to-Many Relational Parallel Coordinates Dispaly"));
		paintingComponent.setPreferredSize(new Dimension(760,450));
		this.add(paintingComponent,BorderLayout.CENTER);
		this.setVisible(true);
	}
	
	private void createPaintComp() {
        
		Shape line = new Line2D.Float(150,150,300,300);
		lines.add(line);
		 
		paintingComponent.setAllLines(lines);
		paintingComponent.repaint();
	}
	
	public void getRelValues(){
        
		lines.clear();
		        
		Shape line = new Line2D.Float(120,120,200,200);
		lines.add(line);
		 
		paintingComponent.setAllLines(lines);
		paintingComponent.repaint();
		}	
}

Java: 
import java.awt.BorderLayout;
import java.awt.Choice;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.border.TitledBorder;

@SuppressWarnings("serial")
public class Properties extends JPanel{
	
	private Polygon polygon = new Polygon ();
	private PaintingClass paintingComponent = new PaintingClass();
	
	private JPanel VarNamesPanel = null;
	private JPanel PropPanel = null;
	private ButtonGroup ButtonGroup = null;
	private JRadioButton NameBtn = null;
	public String CurrentVar = "...";
	public String[] splitNames;
	private Choice choice;
	private String values;
	private JButton showBtn;
	
	public static float RelValue;
	public static int RelValPos;

	public Properties() {
		super();
		initialize();
		this.add(getVarNamesPanel(), null);			
	}	
	
	private void initialize() {
		this.setBorder(BorderFactory.createTitledBorder(null, "Properties"));
		this.setPreferredSize( new java.awt.Dimension(250, 410));	
	}
	
	private JPanel getVarNamesPanel() {
		if (VarNamesPanel == null) {
			VarNamesPanel = new JPanel();
			VarNamesPanel.setPreferredSize( new java.awt.Dimension(230, 200));
			VarNamesPanel.setBorder(BorderFactory.createTitledBorder(null, "Names of Variables", TitledBorder.DEFAULT_JUSTIFICATION, TitledBorder.DEFAULT_POSITION, new Font("Dialog", Font.BOLD, 12), new Color(51, 51, 51)));
			VarNamesPanel.setLayout(new BoxLayout(getVarNamesPanel(), BoxLayout.Y_AXIS));
			VarNamesPanel.add(showChoice(), BorderLayout.NORTH);
			VarNamesPanel.add(Box.createHorizontalGlue());
		}
		return VarNamesPanel;
	}

	private JButton showChoice() {
		if (showBtn == null) {
			showBtn = new JButton("Show Choice");
			showBtn.setMaximumSize(new Dimension(100, 50));
			showBtn.addActionListener(new ActionListener() {
				public void actionPerformed(ActionEvent e) {
					polygon.getRelValues();	
				}
			});
		}
		return showBtn;
	}	    
}

Java: 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Shape;
import java.util.ArrayList;

import javax.swing.JComponent;

public class PaintingClass extends JComponent
{
    private ArrayList<Shape> lines = new ArrayList<Shape>();
    
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D)g;
        
        if(lines.size() != 0 ){
        	g2d.setColor(Color.red);
        	for (Shape line : lines ) {
        		g2d.draw(line);
        	}
        }
    }

    public void setAllLines(ArrayList<Shape> lines) {
    	this.lines = lines;
    }
}

Das kann man ausführe und es reagiert genauso wenig, wie das gesamte Programm auf repaint()
 
Hm, da weiß man gar nicht wo man anfangen soll 😉

Erstmal zu deinem Fehler:
Zu erzeugst zwei unterschiedliche Instanzen von Polygon, davon wird aber nur eine bei dir angezeigt. Die Änderungen machst du aber der die nicht angezeigt wird.

Und noch nen paar Hinweise:
Java: 
public class ParallelCoordClass extends JFrame {
Brauchst du nicht, es reicht wenn du in der Klasse nen JFrame erzeugst.

Properties und Polygon: Benenn nie Klasse so wie Klassen aus der Java API. Das stiftet nur verwirrung.

Java: 
private final PaintingClass paintingComponent = new PaintingClass();
Davon erzeugst du auch zwei unterschiedliche Instanzen. Brauchst du nicht.

Java: 
private Choice choice;
Hier mischst du AWT und Swing Komponenten, sollte man nicht machen.

Ob Properties und Polygon JPanel erweitern müssen ist auch fraglich.
 
Zu erzeugst zwei unterschiedliche Instanzen von Polygon, davon wird aber nur eine bei dir angezeigt. Die Änderungen machst du aber in der, die nicht angezeigt wird.
Zum Vergrößern anklicken....

Und wie kriege ich das gelöst? Ich kann ja nicht einfach eine löschen und static "darf" ich ja nicht.

Danke für die anderen Hinweise.
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

performance g2d.drawImage()
Antworten: 17
Methode draw(Graphics g) aufrufen
Antworten: 6
"Dicke" einer Linie - Line2D.Double
Antworten: 12
ToolTip über Line2D bzw. Rectangle2D
Antworten: 5
Line2D
Antworten: 34

Zurück
Oben