Hallo Leute,
ich habe ein Zeichenprogramm geschrieben, in dem ich Dreiecke, Kreise und Rechtecke zeichnen lassen kann.
Jetzt möchte ich aber, das ich mit einem Button, der über der eigentlichen Zeichenfläche ist, z.B. einen neuen Kreis hinzufüge. Hier liegt auch mein Problem:
Wie schaffe ich es, das ich beliebig viele Kreise auf meiner Zeichenfläche erscheinen lassen kann?
Hier der Code der Zeichenfläche:
Hier ist die Klasse Kreis (Die Klassen Dreieck und Rechteck sind ebenso aufgebaut):
Vielen Dank schon mal im Vorraus 🙂
Grüße Dechasa
ich habe ein Zeichenprogramm geschrieben, in dem ich Dreiecke, Kreise und Rechtecke zeichnen lassen kann.
Jetzt möchte ich aber, das ich mit einem Button, der über der eigentlichen Zeichenfläche ist, z.B. einen neuen Kreis hinzufüge. Hier liegt auch mein Problem:
Wie schaffe ich es, das ich beliebig viele Kreise auf meiner Zeichenfläche erscheinen lassen kann?
Hier der Code der Zeichenfläche:
Java:
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.swing.*;
import java.util.*;
public class Zeichenfläche implements ActionListener{
private static Zeichenfläche zeichenflaeche;
private JFrame fenster;
private JButton kreis,dreieck,rechteck;
private MalPanel malPanel;
private BufferedImage hintergrundbild;
private Graphics2D gDC;
private java.util.List<Grafiksymbol> alleSymbole;
public static void main(String[] args0){
Zeichenfläche z = new Zeichenfläche();
}
private Zeichenfläche()
{
kreis = new JButton("Neuer Kreis");
kreis.setBounds(0,0,150,50);
kreis.addActionListener(this);
rechteck = new JButton("Neues Rechteck");
rechteck.setBounds(150,0,150,50);
rechteck.addActionListener(this);
dreieck = new JButton("Neues Dreieck");
dreieck.setBounds(300,0,150,50);
dreieck.addActionListener(this);
GraphicsConfiguration gfxConf;
fenster = new JFrame("Grafikdokument");
fenster.setLocation(100,100);
fenster.setLayout(null);
fenster.setSize(800,700);
fenster.setResizable(true);
fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//JPanel contentPane = new JPanel();
//contentPane.setBounds(0, 60, 400, 300);
malPanel = new MalPanel();
malPanel.setBounds(0, 60, 450, 600);
malPanel.addMouseListener(this);
fenster.add(malPanel);
gfxConf = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
hintergrundbild = gfxConf.createCompatibleImage(malPanel.getWidth(), malPanel.getHeight());
gDC = hintergrundbild.createGraphics();
loeschen();
alleSymbole = new ArrayList<Grafiksymbol>();
fenster.add(kreis);
fenster.add(dreieck);
fenster.add(rechteck);
fenster.setVisible(true);
fenster.toFront();
}
@Override
public void actionPerformed(ActionEvent e) {
if(e.getSource() == this.kreis){
MehrKreise();
}
if(e.getSource() == this.dreieck){
MehrDreiecke();
}
if(e.getSource() == this.rechteck){
MehrRechtecke();
}
}
/**
* Fabrikmethode. Liefert eine Referenz auf das einzige Objekt der Klasse
* ZEICHENFLAECHE zurück. Wenn es noch nicht existiert, dann wird es erzeugt.
*/
public static Zeichenfläche ObjektGeben()
{
if (zeichenflaeche == null)
zeichenflaeche = new Zeichenfläche();
return zeichenflaeche;
}
/**
* Jede Figur muss sich beim Grafikfenster anmelden,
* damit ihr Grafiksymbol in die Liste der zu zeichnenden
* Symbole aufgenommen wird.
*/
public int anmelden(SymbolArt was)
{
alleSymbole.add(new Grafiksymbol(was));
return alleSymbole.size();
}
/**
* Grafiksymbol vor der Zeichnung anpassen
*
* Wenn sich an einer Figur etwas ändert, dann muss die Figur
* diese Änderung seinem Grafiksysmbol mitteilen. Das Grafiksymbol
* veranlasst dann, wenn erforderlich, ein neues Zeichnen.
* Ein sinngerechterer Name für diese Methode wäre ÄnderungMitteilen().
*/
public void zeichnen(int kennung, int aktX, int aktY, int aktBreite, int aktHoehe, String aktFarbe, boolean aktSichtbar)
{
if (kennung>=1 && kennung<=alleSymbole.size())
{
Grafiksymbol symbol = alleSymbole.get(kennung-1);
symbol.x = Math.max(aktX,0);
symbol.y = Math.max(aktY,0);
symbol.w = Math.max(aktBreite,0);
symbol.h = Math.max(aktHoehe,0);
symbol.farbe = aktFarbe;
symbol.sichtbar = aktSichtbar;
alleZeichnen();
}
}
/*
* Zeichnet alle Grafiksymbole auf das Hintergrundbild
*/
private void alleZeichnen() {
loeschen();
for (Grafiksymbol symbol : alleSymbole)
if (symbol.sichtbar)
symbol.draw();
malPanel.repaint();
}
/*
* Das gesamte Hintergrundbild löschen
*/
private void loeschen()
{
Color aktuell = gDC.getColor();
gDC.setColor(Color.WHITE);
gDC.fillRect(0,0,hintergrundbild.getWidth(), hintergrundbild.getHeight());
gDC.setColor(aktuell);
}
/*
* Die Zeichenfarbe für das Hintergrundbild setzen
*
* @param farbName
* Name der Zeichenfarbe
*/
public void zeichenfarbeSetzen(String farbname) {
if (farbname.equals("rot")) {
gDC.setColor(Color.red);
} else if (farbname.equals("gruen")) {
gDC.setColor(Color.green);
} else if (farbname.equals("blau")) {
gDC.setColor(Color.blue);
} else if (farbname.equals("gelb")) {
gDC.setColor(Color.yellow);
} else if (farbname.equals("cyan")) {
gDC.setColor(Color.cyan);
} else if (farbname.equals("magenta")) {
gDC.setColor(Color.magenta);
} else if (farbname.equals("schwarz")) {
gDC.setColor(Color.black);
} else if (farbname.equals("weiss")) {
gDC.setColor(Color.white);
} else if (farbname.equals("hellgelb")) {
gDC.setColor(new Color(255,255,128));
} else if (farbname.equals("hellgruen")) {
gDC.setColor(new Color(128,255,128));
} else if (farbname.equals("orange")) {
gDC.setColor(new Color(255,128,0));
} else if (farbname.equals("braun")) {
gDC.setColor(new Color(128,64,0));
} else if (farbname.equals("blauhell")) {
gDC.setColor(new Color(147,135,252));
} else if (farbname.equals("hellgrau")) {
gDC.setColor(new Color(164,164,164));
} else if (farbname.equals("grau")) {
gDC.setColor(new Color(52,41,49));
} else if (farbname.equals("dunkelgruen")) {
gDC.setColor(new Color(0,64,0));
} else if (farbname.equals("sterngelb")) {
gDC.setColor(new Color(255,255,196));
} else if (farbname.equals("dunkel1")) {
gDC.setColor(new Color(217,221,255));
} else if (farbname.equals("dunkel2")) {
gDC.setColor(new Color(135,130,234));
} else if (farbname.equals("dunkel3")) {
gDC.setColor(new Color(82,74,225));
} else if (farbname.equals("dunkel4")) {
gDC.setColor(new Color(28,31,186));
} else if (farbname.equals("dunkel5")) {
gDC.setColor(new Color(19,15,91));
} else {
gDC.setColor(Color.black);
}
}
/**
* Aufzähltyp für die möglichen Grundfigurarten in der Darstellung
*/
public static enum SymbolArt {artKreis, artDreieck, artViereck, artSechseck; }
/*
* Interne Klasse MalPanel für die GUI-Komponente, die im Fenster
* angezeigt wird. Diese Klasse ist eine Unterklasse von JPanel.
* Beim paint-Event wird das ganze Hintergrundbild auf das Panel
* gezeichnet.
*/
private class MalPanel extends JPanel
{
public void paint(Graphics g)
{
g.drawImage(hintergrundbild, 0, 0, null);
}
}
/*
* Interne Klasse Grafiksymbol für die Grafikdarstellung der Figuren, die auf der
* Malfläche dargestellt werden.
* Zeichnet die Grafiksymbole auf das Hintergrundbild
*/
private class Grafiksymbol {
int x, y, w, h;
SymbolArt sArt;
String farbe;
boolean sichtbar;
// Konstruktor
Grafiksymbol(SymbolArt art)
{
x=0; y=0; w=0; h=0;
sArt = art;
farbe = "weiss";
sichtbar = false;
}
// zeichnet das Grafiksymbol in das Hintergrundbild
public void draw() {
zeichenfarbeSetzen(farbe);
if (sArt == SymbolArt.artKreis) {
gDC.fillOval(x, y, w, h);
} else if (sArt == SymbolArt.artDreieck) {
int[] punkteX = { x, x + (w / 2), x - (w / 2) };
int[] punkteY = { y, y + h, y + h };
gDC.fillPolygon(punkteX, punkteY, 3);
} else if (sArt == SymbolArt.artViereck) {
gDC.fillRect(x, y, w, h);
} else if (sArt == SymbolArt.artSechseck) {
System.out.println("ja");
int[] punkteX = { x + (int) Math.round(0.2113*w), x + (int) Math.round(0.7887*w),
x + w, x + (int) Math.round(0.7887*w),
x + (int) Math.round(0.2113*w), x };
int[] punkteY = { y, y, y + (h / 2), y + h, y + h, y + (h / 2) };
System.out.println(punkteX.toString());
System.out.println(punkteY.toString());
gDC.fillPolygon(punkteX, punkteY, 6);
}
}
}
private void MehrKreise(){
}
private void MehrRechtecke(){
}
private void MehrDreiecke(){
}
}Hier ist die Klasse Kreis (Die Klassen Dreieck und Rechteck sind ebenso aufgebaut):
Java:
public class Kreis {
public int mittelpunktX;
public int mittelpunktY;
public int radius;
public String fuellfarbe;
public boolean sichtbar;
public int kennung;
/**
* Erzeugt einen neuen Kreis mit einer Standardposition und einer
* Standardfüllfarbe. Das zugehörige Symbol wird sofort angezeigt.
*/
public Kreis() {
mittelpunktX = 30;
mittelpunktY = 60;
radius = 20;
fuellfarbe = "schwarz";
sichtbar = true;
kennung = Zeichenfläche.ObjektGeben().anmelden(Zeichenfläche.SymbolArt.artKreis);
Zeichnen();
}
/**
* Den Mittelpunkt dieses Kreises auf die neuen Werte
* setzen.
*/
public void MittelpunktSetzen(int neuesX, int neuesY) {
mittelpunktX = neuesX;
mittelpunktY = neuesY;
Zeichnen();
}
/**
* Den Radius dieses Kreises auf den neuen Wert setzen.
*/
public void RadiusSetzen(int neuerRadius) {
radius = neuerRadius;
Zeichnen();
}
/**
* Die Füllfarbe dieses Kreises auf 'neueFarbe' setzen.
* Erlaubte Parameterwerte sind:
* "rot", "gruen", "blau", "gelb", "cyan", "magenta", "schwarz", "weiss"
* "hellgelb", "hellgruen", "orange", "braun"
*/
public void FarbeSetzen(String neueFarbe) {
fuellfarbe = neueFarbe;
Zeichnen();
}
/**
* Die Sichtbarkeit dieses Kreises ein- oder ausschalten.
* Erlaubte Parameterwerte: true, false
*/
public void SichtbarSetzen(boolean neueSichtbarkeit) {
sichtbar = neueSichtbarkeit;
Zeichnen();
}
/**
* Zeichne für diesen Kreis ein entsprechendes Grafiksymbol
* in dem Grafikfenster.
* Nach jeder Änderung muss der Kreis diese Änderung seinem
* Grafiksymbol mitteilen.
*/
public void Zeichnen() {
Zeichenfläche.ObjektGeben().zeichnen(kennung, mittelpunktX-radius,
mittelpunktY-radius, 2*radius, 2*radius, fuellfarbe, sichtbar);
}
}Vielen Dank schon mal im Vorraus 🙂
Grüße Dechasa
