import java.awt.*;
import java.awt.geom.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.swing.*;
import javax.swing.event.*;
import java.util.*;
/**
* Die Klasse stellt ein Fenster mit einer Malfläche zur Verfügung,
* auf der Objekte der Klassen Rechteck, Kreis und Dreieck sowie Turtle dargestellt
* werden können.
* Die Zeichenfläche wird beim ersten Anlegen eines Zeichenobjekts automatisch
* nach dem Muster Singleton angelegt.
*
* @author Albert Wiedemann
* @version 1.0
*/
class Zeichenfenster
{
/** Interface für die Aktionsausführung. */
interface AktionsEmpfaenger
{
/** Methode wird vom Taktgeber aufgerufen. */
void Ausführen();
void Taste (char taste);
void SonderTaste (int taste);
void Geklickt (int x, int y, int anzahl);
}
/** Aufzählung der erzeugbaren Objektarten. */
static enum SymbolArt {
kreis, dreieck, rechteck, turtle, figur, text;
};
/** Einziges Objekt der Zeichenfläche. */
private static Zeichenfenster zeichenfläche = null;
/** Fenster für die Zeichenfläche. */
private JFrame fenster;
/** Die eigentliche Darstellungskomponente. */
private JComponent malfläche;
/** Stop-Knopf für den Taktgeber. */
private JButton stop;
/** Start-Knopf für den Taktgeber. */
private JButton start;
/** Einsteller für die Taktrate*/
private JSlider slider;
/** Feld aller zu zeichnenden Objekte. */
private ArrayList<GrafikSymbol> alleSymbole;
/** Feld aller zu zeichnenden Objekte. */
private ArrayList<AktionsEmpfaenger> aktionsEmpfänger;
/** Timerobjekt für die zentrale Zeitverwaltung */
private javax.swing.Timer timer;
/**
* Legt das Fenster und die Malfläche an
*/
private Zeichenfenster ()
{
alleSymbole = new ArrayList<GrafikSymbol>();
aktionsEmpfänger = new ArrayList<AktionsEmpfaenger>();
fenster = new JFrame("Zeichenfenster");
fenster.setLocation(50, 50);
fenster.setSize(800, 600);
fenster.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE); //Close-Button kann nicht versteckt oder abgestellt werden.
malfläche = new JComponent()
{
public void paint (Graphics g)
{
g.setColor(new Color (230, 230, 230));
g.fillRect(0, 0, getWidth() - 1, getHeight() - 1);
synchronized (malfläche)
{
for (GrafikSymbol s: alleSymbole)
{
if (s.sichtbar)
{
s.Zeichnen(g);
}
}
}
}
};
malfläche.setOpaque(true);
malfläche.addMouseListener(new MouseAdapter ()
{
/**
* Gibt den Ort eines Mouseclicks an die eigentliche Aktionsmethode weiter.
* @param e das zugrestellte Ereignis
*/
public void mousePressed(MouseEvent e)
{
malfläche.requestFocus();
ArrayList<AktionsEmpfaenger> empfänger = new ArrayList<AktionsEmpfaenger>(aktionsEmpfänger);
for (AktionsEmpfaenger em: empfänger)
{
em.Geklickt(e.getX(), e.getY(), e.getClickCount());
}
}
}
);
malfläche.addKeyListener(new KeyAdapter ()
{
/**
* Gibt die Taste an die eigentliche Aktionsmethode weiter.
* @param e das zugestellte Ereignis
*/
public void keyPressed(KeyEvent e)
{
ArrayList<AktionsEmpfaenger> empfänger = new ArrayList<AktionsEmpfaenger>(aktionsEmpfänger);
if ((int) e.getKeyChar() == KeyEvent.CHAR_UNDEFINED)
{
switch (e.getKeyCode())
{
case KeyEvent.VK_ENTER:
for (AktionsEmpfaenger em: empfänger)
{
em.Taste((char) KeyEvent.VK_ENTER);
}
break;
default:
for (AktionsEmpfaenger em: empfänger)
{
em.SonderTaste(e.getKeyCode());
}
}
}
else
{
for (AktionsEmpfaenger em: empfänger)
{
em.Taste(e.getKeyChar());
}
}
}
}
);
malfläche.addComponentListener(new ComponentAdapter()
{
/**
* Setzt die Hintegrundbilder aller Turtle auf die neue Größe.
*/
public void componentResized(ComponentEvent e)
{
for (GrafikSymbol s: alleSymbole)
{
if (s instanceof TurtleIntern)
{
((TurtleIntern) s).NeueGrößeSetzen();
}
}
}
}
);
fenster.add(malfläche, BorderLayout.CENTER);
JPanel panel = new JPanel();
panel.setMinimumSize(new Dimension(200, 60));
panel.setSize(200,60);
panel.setVisible(true);
panel.setLayout(new GridLayout(1, 2));
JPanel panel2 = new JPanel();
panel2.setMinimumSize(new Dimension(100, 60));
panel2.setSize(100,60);
panel2.setVisible(true);
panel2.setLayout(new GridLayout(1, 1));
stop = new JButton();
start = new JButton();
start.setLocation(10, 10);
start.setSize(80, 30);
start.setText("Start");
start.setVisible(true);
start.addActionListener(new ActionListener ()
{
public void actionPerformed (ActionEvent evt)
{
TaktgeberStartenIntern();
malfläche.requestFocus();
}
}
);
panel2.add(start);
stop.setLocation(100, 10);
stop.setSize(80, 30);
stop.setText("Stop");
stop.setVisible(true);
stop.setEnabled(false);
stop.addActionListener(new ActionListener ()
{
public void actionPerformed (ActionEvent evt)
{
TaktgeberStoppenIntern();
malfläche.requestFocus();
}
}
);
panel2.add(stop);
panel.add(panel2);
slider = new JSlider(0, 1000, 100);
slider.setLocation(190, 10);
slider.setSize(160, 40);
slider.setMinimumSize(new Dimension(160, 40));
slider.setPreferredSize(new Dimension(160, 40));
slider.setMajorTickSpacing(100);
slider.setPaintTicks(true);
slider.setPaintLabels(true);
slider.setValue(1000);
slider.addChangeListener(new ChangeListener()
{
public void stateChanged(ChangeEvent e)
{
timer.setDelay(slider.getValue());
malfläche.requestFocus();
}
}
);
panel.add(slider);
fenster.add(panel, BorderLayout.SOUTH);
fenster.setVisible(true);
malfläche.requestFocus();
timer = new javax.swing.Timer (1000, new ActionListener ()
{
/**
* Vom Timer aufgerufen.
* Erzeugt den nächsten Taktimpuls
* @param evt der Timerevent
*/
public void actionPerformed (ActionEvent evt)
{
ArrayList<AktionsEmpfaenger> empfänger = new ArrayList<AktionsEmpfaenger>(aktionsEmpfänger);
for (AktionsEmpfaenger e: empfänger)
{
e.Ausführen();
}
}
}
);
}
/**
* Meldet die aktuelle Breite der Malfläche.
* @returns Breite der Malfläche
*/
static int MalflächenBreiteGeben()
{
if (zeichenfläche == null)
{
zeichenfläche = new Zeichenfenster();
}
return zeichenfläche.malfläche.getWidth();
}
/**
* Meldet die aktuelle Höhe der Malfläche.
* @returns Höhe der Malfläche
*/
static int MalflächenHöheGeben()
{
if (zeichenfläche == null)
{
zeichenfläche = new Zeichenfenster();
}
return zeichenfläche.malfläche.getHeight();
}
/**
* Trägt einen neuen Aktionsempfänger ein.
* @param neu der neue Aktionsempfänger
*/
static void AktionsEmpfängerEintragen(AktionsEmpfaenger neu)
{
if (zeichenfläche == null)
{
zeichenfläche = new Zeichenfenster();
}
zeichenfläche.aktionsEmpfänger.add(neu);
}
/**
* Löscht einen Aktionsempfänger aus der Liste.
* @param alt der zu löschende Aktionsempfänger
*/
static void AktionsEmpfängerEntfernen(AktionsEmpfaenger alt)
{
if (zeichenfläche == null)
{
zeichenfläche = new Zeichenfenster();
}
zeichenfläche.aktionsEmpfänger.remove(alt);
}
/**
* Erzeugt ein neues darzustelledes Symbol.
* Die möglichen Symbole sind im Aufzählungstyp SymbolArt beschrieben.
* @param art Art des zu erzeugenden Symbols.
* @return Referenz auf das Delegate-Objekt.
*/
static GrafikSymbol SymbolErzeugen (SymbolArt art)
{
if (zeichenfläche == null)
{
zeichenfläche = new Zeichenfenster();
}
return zeichenfläche.SymbolAnlegen(art);
}
/**
* Startet den Taktgeber.
*/
static void TaktgeberStarten ()
{
if (zeichenfläche == null)
{
zeichenfläche = new Zeichenfenster();
}
zeichenfläche.TaktgeberStartenIntern();
}
/**
* Stoppt den Taktgeber.
*/
static void TaktgeberStoppen ()
{
if (zeichenfläche == null)
{
zeichenfläche = new Zeichenfenster();
}
zeichenfläche.TaktgeberStoppenIntern();
}
/**
* Ablaufgeschwindigkeit des Zeitgebers einstellen.
*
* @param dauer: Angabe in Millisekunden
*/
static void TaktdauerSetzen (int dauer)
{
if (zeichenfläche == null)
{
zeichenfläche = new Zeichenfenster();
}
zeichenfläche.slider.setValue(dauer < 0 ? 0 : (dauer > 1000 ? 1000: dauer));
}
/**
* Erzeugt das neue Symbol tatsächlich.
* @param art Art des zu erzeugenden Symbols.
* @return Referenz auf das Delegate-Objekt.
*/
private GrafikSymbol SymbolAnlegen (SymbolArt art)
{
GrafikSymbol neu = null;
switch (art)
{
case rechteck:
neu = new RechteckIntern();
break;
case kreis:
neu = new EllipseIntern();
break;
case dreieck:
neu = new DreieckIntern();
break;
case turtle:
neu = new TurtleIntern();
break;
case figur:
neu = new FigurIntern();
break;
case text:
neu = new TextIntern();
break;
}
synchronized (zeichenfläche.malfläche)
{
zeichenfläche.alleSymbole.add(neu);
}
malfläche.repaint();
return neu;
}
/**
* Startet den Taktgeber.
*/
private void TaktgeberStartenIntern()
{
start.setEnabled(false);
stop.setEnabled(true);
timer.start();
}
/**
* Stoppt den Taktgeber.
*/
private void TaktgeberStoppenIntern()
{
start.setEnabled(true);
stop.setEnabled(false);
timer.stop();
}
/**
* Oberklasse für alle verfügbaren Grafiksymbole.
* Alle Grafiksymbole werden über ihr umgebendes Rechteck beschrieben.
*/
abstract class GrafikSymbol
{
/** x-Position der linken oberen Ecke. */
protected int x;
/** y-Position der linken oberen Ecke. */
protected int y;
/** Breite des umgebenden Rechtecks. */
protected int b;
/** Höhe des umgebenden Rechtecks. */
protected int h;
/** Farbe des Symbols. */
protected Color c;
/** Sichtbarkeit des Symbols. */
protected boolean sichtbar;
/** Drehwinkel (mathematisch positiver Drehsinn) des Symbols. */
protected int winkel;
/** Die Form des Grafiksymbols. */
protected Area form;
/** Farbe Hellgelb. */
protected final Color hellgelb = new Color(255,255,128);
/** Farbe Hellgrün. */
protected final Color hellgrün = new Color(128,255,128);
/** Farbe Orange. */
protected final Color orange = new Color(255,128,0);
/** Farbe Braun. */
protected final Color braun = new Color(128,64,0);
/**
* Der Konstruktor erzeugt ein rotes Symbol in der linken oberen Ecke des Fensters.
*/
GrafikSymbol()
{
x = 10;
y = 10;
b = 100;
h = 100;
c = Color.RED;
sichtbar = true;
winkel = 0;
FormErzeugen();
}
/**
* Normiert den Winkel auf Werte im Bereich [0; 360[
* @param winkel der Eingabewinkel
* @return der normierte Winkel
*/
int WinkelNormieren(int winkel)
{
while (winkel < 0)
{
winkel += 360;
}
return winkel % 360;
}
/**
* Setzt die Position (der linken oberen Ecke) des Objekts.
* @param x x-Position der linken oberen Ecke
* @param y y-Position der linken oberen Ecke
*/
void PositionSetzen (int x, int y)
{
this.x = x;
this.y = y;
FormErzeugen();
zeichenfläche.malfläche.repaint();
}
/**
* Setzt die Größe des Objekts.
* @param breite (neue) Breite des Objekts
* @param höhe (neue) Höhe des Objekts
*/
void GrößeSetzen (int breite, int höhe)
{
b = breite;
h = höhe;
FormErzeugen();
zeichenfläche.malfläche.repaint();
}
/**
* Bestimmt die RGB-Farbe für den gegeben String.
* @param farbe die Farbe als String
* @return die Farbe als RGB-Farbe
*/
Color FarbeCodieren (String farbe)
{
farbe = farbe.toLowerCase();
switch (farbe)
{
case "weiß":
case "weiss":
return Color.WHITE;
case "rot":
return Color.RED;
case "grün":
case "gruen":
return Color.GREEN;
case "blau":
return Color.BLUE;
case "gelb":
return Color.YELLOW;
case "magenta":
return Color.MAGENTA;
case "cyan":
return Color.CYAN;
case "hellgelb":
return hellgelb;
case "hellgrün":
case "hellgruen":
return hellgrün;
case "orange":
return orange;
case "braun":
return braun;
case "grau":
return Color.GRAY;
case "schwarz":
return Color.BLACK;
default:
return Color.BLACK;
}
}
/**
* Setzt die Farbe des Objekts.
* @param farbe (neue) Farbe des Objekts
*/
void FarbeSetzen (String farbe)
{
FarbeSetzen(FarbeCodieren(farbe));
}
/**
* Setzt die Farbe des Objekts.
* @param c (neue) Farbe des Objekts
*/
void FarbeSetzen (Color c)
{
this.c = c;
zeichenfläche.malfläche.repaint();
}
/**
* Setzt die Sichtbarkeit des Objekts.
* @param sichtbar (neue) Sichtbarkeit des Objekts
*/
void SichtbarkeitSetzen (boolean sichtbar)
{
this.sichtbar = sichtbar;
zeichenfläche.malfläche.repaint();
}
/**
* Setzt den Drehwinkel des Objekts.
* @param winkel der (neue) Drehwinkel des Objekts
*/
void WinkelSetzen (int winkel)
{
this.winkel = WinkelNormieren(winkel);
FormErzeugen();
zeichenfläche.malfläche.repaint();
}
/**
* Entfernt das Objekt aus dem Zeichenfenster.
*/
void Entfernen ()
{
synchronized (zeichenfläche.malfläche)
{
zeichenfläche.alleSymbole.remove(this);
zeichenfläche.malfläche.repaint();
}
}
/**
* Bringt das Objekt eine Ebene nach vorn.
*/
void NachVornBringen ()
{
synchronized (zeichenfläche.malfläche)
{
int index = zeichenfläche.alleSymbole.indexOf(this);
if (index < zeichenfläche.alleSymbole.size() - 1)
{
zeichenfläche.alleSymbole.set(index, zeichenfläche.alleSymbole.get(index + 1));
zeichenfläche.alleSymbole.set(index + 1, this);
zeichenfläche.malfläche.repaint();
}
}
}
/**
* Bringt das Objekt in die vorderste Ebene.
*/
void GanzNachVornBringen ()
{
synchronized (zeichenfläche.malfläche)
{
int index = zeichenfläche.alleSymbole.indexOf(this);
if (index < zeichenfläche.alleSymbole.size() - 1)
{
zeichenfläche.alleSymbole.remove(index);
zeichenfläche.alleSymbole.add(this);
zeichenfläche.malfläche.repaint();
}
}
}
/**
* Bringt das Objekt eine Ebene nach hinten.
*/
void NachHintenBringen ()
{
synchronized (zeichenfläche.malfläche)
{
int index = zeichenfläche.alleSymbole.indexOf(this);
if (index > 0)
{
zeichenfläche.alleSymbole.set(index, zeichenfläche.alleSymbole.get(index - 1));
zeichenfläche.alleSymbole.set(index - 1, this);
zeichenfläche.malfläche.repaint();
}
}
}
/**
* Bringt das Objekt in die hinterste Ebene.
*/
void GanzNachHintenBringen ()
{
synchronized (zeichenfläche.malfläche)
{
int index = zeichenfläche.alleSymbole.indexOf(this);
if (index > 0)
{
zeichenfläche.alleSymbole.remove(index);
zeichenfläche.alleSymbole.add(0, this);
zeichenfläche.malfläche.repaint();
}
}
}
/**
* Testet, ob der angegebene Punkt innerhalb der Figur ist.
* @param x x-Koordinate des zu testenden Punktes
* @param y y-Koordinate des zu testenden Punktes
* @return wahr, wenn der Punkt innerhalb der Figur ist
*/
boolean IstInnerhalb (int x, int y)
{
return form.contains(x, y);
}
/**
* Testet, ob die beiden Figuren überlappen.
* @param wen die andere Form
* @return wahr, wenn die beiden Formen überlappen.
*/
boolean Schneidet (Area wen)
{
Area area = new Area(form);
area.intersect (wen);
return !area.isEmpty();
}
/**
* Zeichnet das Objekt
* @param g das Grafikobjekt zum Zeichnen
*/
void Zeichnen(Graphics g)
{
g.setColor(c);
((Graphics2D) g).fill(form);
}
/**
* Berechnet den Drehwinkel gemäß den Konventionen des Graphik-Frameworks.
* Für Java: Winkel in Radians, positive Drehrichtng im Uhrzeiger.
* @param winkel: Der Winkel in Grad, mathematischer Drehsinn
* @return Winkel für Graphik-Framework
*/
double DrehwinkelGeben (int winkel)
{
return - Math.PI * winkel / 180.0;
}
/**
* Erstellt die Form des Objekts.
*/
abstract void FormErzeugen();
}
/**
* Objekte dieser Klasse verwalten ein Rechteck.
*/
private class RechteckIntern extends GrafikSymbol
{
/**
* Erstellt die Form des Rechtecks.
*/
@Override void FormErzeugen()
{
AffineTransform a = new AffineTransform();
a.rotate(DrehwinkelGeben (winkel), this.x + b / 2, this.y + h / 2);
form = new Area(new Path2D.Double (new Rectangle2D.Double(this.x, this.y, b, h), a));
}
}
/**
* Objekte dieser Klasse verwalten eine Ellipse.
*/
private class EllipseIntern extends GrafikSymbol
{
/**
* Erstellt die Form der Ellipse.
*/
@Override void FormErzeugen()
{
AffineTransform a = new AffineTransform();
a.rotate(DrehwinkelGeben (winkel), this.x + b / 2, this.y + h / 2);
form = new Area(new Path2D.Double (new Ellipse2D.Double(this.x, this.y, b, h), a));
}
}
/**
* Objekte dieser Klasse verwalten ein Dreieck.
*/
private class DreieckIntern extends GrafikSymbol
{
/**
* Erstellt die Form des Dreiecks.
*/
@Override void FormErzeugen()
{
Polygon rand = new Polygon (new int [] {x + b / 2, x + b, x, x + b / 2},
new int [] {y, y + h, y + h, y}, 4);
AffineTransform a = new AffineTransform();
a.rotate(DrehwinkelGeben (winkel), this.x + b / 2, this.y + h / 2);
form = new Area(new Path2D.Double (rand, a));
}
}
/**
* Objekte dieser Klasse verwalten einen Text.
*/
class TextIntern extends GrafikSymbol
{
/** Der aktuelle Text. */
private String text;
/** Die aktuelle Textgröße. */
float size;
/**
* Belegt text und size mit Defaultwerten.
*/
TextIntern ()
{
super();
text = "Text";
size = 12;
c = Color.black;
}
/**
* Erstellt die Form des Textes.
* Dummy, legt ein leeres Area an.
*/
@Override void FormErzeugen()
{
form = new Area();
}
/**
* Testet, ob der angegebene Punkt innerhalb der Figur ist.
* @param x x-Koordinate des zu testenden Punktes
* @param y y-Koordinate des zu testenden Punktes
* @return falsch
*/
@Override boolean IstInnerhalb (int x, int y)
{
return false;
}
/**
* Setzt den aktuellen Text.
* @param t der neue Text
*/
void TextSetzen (String t)
{
text = t;
zeichenfläche.malfläche.repaint();
}
/**
* Setzt die Größe des Textes.
*/
void TextGrößeSetzen (int größe)
{
size = größe;
zeichenfläche.malfläche.repaint();
}
/**
* Vergrößert den Text.
*/
void TextVergrößern()
{
if (size <= 10)
{
size += 1;
}
else if (size <= 40)
{
size += 2;
}
else
{
size += 4;
}
zeichenfläche.malfläche.repaint();
}
/**
* Verkleinert den Text.
*/
void TextVerkleinern()
{
if (size <= 10)
{
size -= 1;
}
else if (size <= 40)
{
size -= 2;
}
else
{
size -= 4;
}
if (size < 1)
{
size = 1;
}
zeichenfläche.malfläche.repaint();
}
/**
* Zeichnet das Objekt als Dreieck in der gegebenen Farbe.
* @param g das Grafikobjekt zum Zeichnen
*/
@Override void Zeichnen(Graphics g)
{
g.setColor(c);
Font f = g.getFont();
Font f2 = f.deriveFont(size);
g.setFont(f2);
if (winkel == 0)
{
g.drawString(text, x, y);
}
else
{
Graphics2D g2 = (Graphics2D) g;
AffineTransform alt = g2.getTransform();
//g2.rotate(DrehwinkelGeben (winkel), x + b / 2, y + h / 2);
//g2.rotate(DrehwinkelGeben (winkel), x + text.length() * size / 4, y + size / 2);
Rectangle2D bounds = f2.getStringBounds(text, g2.getFontRenderContext());
g2.rotate(DrehwinkelGeben (winkel), x + bounds.getWidth() / 2, y - bounds.getHeight() / 2);
g.drawString(text, x, y);
g2.setTransform(alt);
}
g.setFont(f);
}
}
/**
* Oberklasse für alle Elemente einer Figur (Figur, Turtle).
*/
private abstract class FigurenElement
{
double xe;
double ye;
double breite;
double höhe;
Color c;
/**
* Zeichnet das Figurenelement.
* @param g das Grafikobjekt
* @param größe die aktuelle Größe der Figur
* @param x die x-Koordinate des Aufhängepunkts der Figur
* @param y die y-Koordinate des Aufhängepunkts der Figur
*/
abstract void ElementZeichnen(Graphics2D g, double größe, int x, int y);
/**
* Fügt den Pfadteil deiser Komponente zum umgebenden Pfad hinzu.
* @param p der Gesamtpfad
* @param größe die aktuelle Größe der Figur
* @param x die x-Koordinate des Aufhängepunkts der Figur
* @param y die y-Koordinate des Aufhängepunkts der Figur
*/
abstract void ElementZuForm (Path2D.Double p, double größe, int x, int y);
}
/**
* Ein rechteckiges Figurenelement.
*/
private class FigurenElementRechteck extends FigurenElement
{
/**
* Der Konstruktor speichert die Rahmendaten.
* @param x x-Koordinate der linken oberen Ecke des Rechtecks relativ zum Aufhängepunkt.
* @param y y-Koordinate der linken oberen Ecke des Rechtecks relativ zum Aufhängepunkt.
* @param breite Breite des Rechtecks
* @param höhe Höhe des Rechtecks
* @param c Farbe des Rechtecks
*/
FigurenElementRechteck (double x, double y, double breite, double höhe, Color c)
{
this.xe = x;
this.ye = y;
this.breite = breite;
this.höhe = höhe;
this.c = c;
}
/**
* Zeichnet das Figurenelement.
* @param g das Grafikobjekt
* @param größe die aktuelle Größe der Figur
* @param x die x-Koordinate des Aufhängepunkts der Figur
* @param y die y-Koordinate des Aufhängepunkts der Figur
*/
@Override void ElementZeichnen(Graphics2D g, double größe, int x, int y)
{
g.setColor(c);
g.fill(new Rectangle2D.Double (x+größe*xe/100.0, y+größe*ye/100.0, größe*breite/100.0, größe*höhe/100.0));
}
/**
* Fügt den Pfadteil dieser Komponente zum umgebenden Pfad hinzu.
* @param p der Gesamtpfad
* @param größe die aktuelle Größe der Figur
* @param x die x-Koordinate des Aufhängepunkts der Figur
* @param y die y-Koordinate des Aufhängepunkts der Figur
*/
@Override void ElementZuForm (Path2D.Double p, double größe, int x, int y)
{
p.append(new Rectangle2D.Double (x+größe*xe/100.0, y+größe*ye/100.0, größe*breite/100.0, größe*höhe/100.0), false);
}
}
/**
* Ein elliptisches Figurenelement.
*/
private class FigurenElementEllipse extends FigurenElement
{
/**
* Der Konstruktor speichert die Rahmendaten.
* @param x x-Koordinate der linken oberen Ecke des umgebenden Rechtecks relativ zum Aufhängepunkt.
* @param y y-Koordinate der linken oberen Ecke des umgebenden Rechtecks relativ zum Aufhängepunkt.
* @param breite Breite der Ellipse
* @param höhe Höhe der Ellipse
* @param c Farbe der Ellipse
*/
FigurenElementEllipse (double x, double y, double breite, double höhe, Color c)
{
this.xe = x;
this.ye = y;
this.breite = breite;
this.höhe = höhe;
this.c = c;
}
/**
* Zeichnet das Figurenelement.
* @param g das Grafikobjekt
* @param größe die aktuelle Größe der Figur
* @param x die x-Koordinate des Aufhängepunkts der Figur
* @param y die y-Koordinate des Aufhängepunkts der Figur
*/
@Override void ElementZeichnen(Graphics2D g, double größe, int x, int y)
{
g.setColor(c);
g.fill(new Ellipse2D.Double (x+größe*xe/100.0, y+größe*ye/100.0, größe*breite/100.0, größe*höhe/100.0));
}
/**
* Fügt den Pfadteil dieser Komponente zum umgebenden Pfad hinzu.
* @param p der Gesamtpfad
* @param größe die aktuelle Größe der Figur
* @param x die x-Koordinate des Aufhängepunkts der Figur
* @param y die y-Koordinate des Aufhängepunkts der Figur
*/
@Override void ElementZuForm (Path2D.Double p, double größe, int x, int y)
{
p.append(new Ellipse2D.Double (x+größe*xe/100.0, y+größe*ye/100.0, größe*breite/100.0, größe*höhe/100.0), false);
}
}
/**
* Ein Figurenelement begrenzt durch das angegebene Polygon.
*/
private class FigurenElementPolygon extends FigurenElement
{
/** Das Polygonobjekt */
private Polygon poly;
/**
* Der Konstruktor speichert die Rahmendaten.
* @param x x-Koordinaten der Stützpunkte des Polygons relativ zum Aufhängepunkt.
* @param y y-Koordinaten der Stützpunkte des Polygons relativ zum Aufhängepunkt.
* @param c Farbe der Polygonfläche
*/
FigurenElementPolygon (int [] x, int[] y, Color c)
{
int anz = x.length <= y.length ? x.length : y.length;
poly = new Polygon (x, y, anz);
Rectangle2D bounds = poly.getBounds2D();
xe = bounds.getX();
ye = bounds.getY();
breite = bounds.getWidth();
höhe = bounds.getHeight();
this.c = c;
}
/**
* Zeichnet das Figurenelement.
* @param g das Grafikobjekt
* @param größe die aktuelle Größe der Figur
* @param x die x-Koordinate des Aufhängepunkts der Figur
* @param y die y-Koordinate des Aufhängepunkts der Figur
*/
@Override void ElementZeichnen(Graphics2D g, double größe, int x, int y)
{
g.setColor(c);
AffineTransform at = new AffineTransform(größe/100.0, 0, 0, größe/100.0, x, y);
g.fill(new Path2D.Double (poly, at));
}
/**
* Fügt den Pfadteil dieser Komponente zum umgebenden Pfad hinzu.
* @param p der Gesamtpfad
* @param größe die aktuelle Größe der Figur
* @param x die x-Koordinate des Aufhängepunkts der Figur
* @param y die y-Koordinate des Aufhängepunkts der Figur
*/
@Override void ElementZuForm (Path2D.Double p, double größe, int x, int y)
{
AffineTransform at = new AffineTransform(größe/100.0, 0, 0, größe/100.0, x, y);
Path2D.Double p2 = new Path2D.Double (poly, at);
p2.closePath();
p2.setWindingRule(Path2D.WIND_EVEN_ODD);
p.append(p2, false);
}
}
/**
* Das Objekt dieser Klasse zeichnet den Weg der Turtle.
*/
class TurtleIntern extends GrafikSymbol
{
private class LinienElement
{
/** x-Koordinate des Startpunktes. */
private double xStart;
/** y-Koordinate des Startpunktes. */
private double yStart;
/** x-Koordinate des Endpunktes. */
private double xEnde;
/** y-Koordinate des Endpunktes. */
private double yEnde;
/** Farbe des LinienElements. */
private Color c;
LinienElement (double xStart, double yStart, double xEnde, double yEnde, Color c)
{
this.xStart = xStart;
this.yStart = yStart;
this.xEnde = xEnde;
this.yEnde = yEnde;
this.c = c;
}
void Zeichnen (Graphics2D g)
{
g.setColor(c);
g.draw(new Line2D.Double (xStart, yStart, xEnde, yEnde));
}
}
/**
* Verwaltet das Hintergrundfenster für die Turtlezeichnung.
*/
private class HintergrundBild
{
/** Das aktuelle Hintergrundbild. */
private BufferedImage bild;
/** Das zugehörige Zeichenobjekt. */
private Graphics2D g;
/**
* Der Konstruktor legt das Bild in der Größe der Zeichenfläche an.
*/
HintergrundBild()
{
bild = new BufferedImage(Zeichenfenster.MalflächenBreiteGeben(), Zeichenfenster.MalflächenBreiteGeben(), BufferedImage.TYPE_INT_ARGB);
g = bild.createGraphics();
g.setColor(new Color (0, 0, 0, 0));
g.fillRect(0, 0, bild.getWidth(), bild.getHeight());
}
/**
* Zeichent die angegebe Linie in das Bild.
* @param linie das zu zeichnende Linienelement.
*/
void LinieZeichnen(LinienElement linie)
{
linie.Zeichnen(g);
}
/**
* Zeichnet das Bild in das angegebene Zeichenobjekt.
* @param wohin Zeichenobjekt
*/
void BildZeichnen (Graphics2D wohin)
{
wohin.drawImage(bild, null, 0, 0);
}
}
/** Genaue x-Koordinate der Turtle. */
double xD;
/** Genaue y-Koordinate der Turtle. */
double yD;
/** Startkoordinate der Turtle. */
private int homeX;
/** Startkoordinate der Turtle. */
private int homeY;
/** Startwinkel der Turtle. */
private int homeWinkel;
/** Stiftposition. */
boolean stiftUnten;
/** Die Sichtbarkeit des Turtle-Symbols. */
private boolean symbolSichtbar;
/** Linienelemente. */
private ArrayList<LinienElement> linien;
/** Standardfigur für Turtle. */
private LinkedList<FigurenElement> standardFigur;
/** Das Hintergrundbild für die Linien. */
private HintergrundBild hintergrund;
/**
* Legt die Turtle mit Startpunkt (100|200) in Richtung 0˚ an.
*/
TurtleIntern ()
{
super ();
x = 100;
y = 200;
xD = x;
yD = y;
h = 40;
b = 40;
homeX=x;
homeY=y;
homeWinkel=winkel;
c = Color.black;
stiftUnten = true;
symbolSichtbar = true;
linien = new ArrayList<LinienElement>();
hintergrund = new HintergrundBild();
standardFigur = new LinkedList<FigurenElement>();
StandardfigurErzeugen();
FormErzeugen();
}
/**
* Baut die Standardfigur aus den Elementen auf.
*/
private void StandardfigurErzeugen()
{
//Kopf
standardFigur.add(new FigurenElementEllipse(50, -12.5, 25, 25, Color.GREEN));
//Beine
standardFigur.add(new FigurenElementEllipse(22.5, -32.5, 12.5, 17.5, Color.GREEN));
standardFigur.add(new FigurenElementEllipse(40.0, -32.5, 12.5, 17.5, Color.GREEN));
standardFigur.add(new FigurenElementEllipse(22.5, 15.0, 12.5, 17.5, Color.GREEN));
standardFigur.add(new FigurenElementEllipse(40.0, 15.0, 12.5, 17.5, Color.GREEN));
//Augen
standardFigur.add(new FigurenElementRechteck(67.5, -10.0, 5.0, 7.5, c));
standardFigur.add(new FigurenElementRechteck(67.5, 2.5, 5.0, 7.5, c));
//Schwanz
standardFigur.add(new FigurenElementEllipse(0, -3.75, 25, 7.5, c));
//Rumpf
standardFigur.add(new FigurenElementEllipse(7.5, -23.75, 57.5, 47.5, braun));
}
/**
* Passt das Hintergrundbild an eine neue Größe der Zeichenfläche an.
*/
void NeueGrößeSetzen()
{
hintergrund = new HintergrundBild();
for (LinienElement l: linien)
{
hintergrund.LinieZeichnen(l);
}
}
/**
* Erstellt die Form der Turtle.
*/
@Override void FormErzeugen()
{
Area area = new Area();
AffineTransform a = new AffineTransform();
a.rotate(DrehwinkelGeben (winkel), this.x, this.y);
double größe = h > b ? b : h;
if (standardFigur != null)
{
synchronized (standardFigur)
{
for (FigurenElement e: standardFigur)
{
Path2D.Double p = new Path2D.Double();
e.ElementZuForm(p, größe, x, y);
area.add( new Area(new Path2D.Double (p, a)));
}
}
}
form = area;
}
/**
* Setzt die Position (der linken oberen Ecke) des Objekts.
* @param x x-Position der linken oberen Ecke
* @param y y-Position der linken oberen Ecke
*/
@Override void PositionSetzen (int x, int y)
{
super.PositionSetzen (x, y);
xD = x;
yD = y;
}
/**
* Setzt die Turtle wieder an ihre Ausgangsposition.
*/
void ZumStartpunktGehen()
{
x = homeX;
y = homeY;
xD = x;
yD = y;
winkel = homeWinkel;
FormErzeugen();
zeichenfläche.malfläche.repaint();
}
/**
* Bewegt die Turtle nach vorne.
* @param länge Anzahl der Längeneinheiten
*/
void Gehen(double länge)
{
double neuX = xD + Math.cos(DrehwinkelGeben (winkel)) * länge;
double neuY = yD + Math.sin(DrehwinkelGeben (winkel)) * länge;
if (stiftUnten)
{
synchronized (this)
{
LinienElement l = new LinienElement(xD, yD, neuX, neuY, c);
linien.add (l);
hintergrund.LinieZeichnen (l);
}
}
xD = neuX;
yD = neuY;
x =(int) Math.round(xD);
y =(int) Math.round(yD);
FormErzeugen();
zeichenfläche.malfläche.repaint();
}
/**
* Dreht die Turtle
* @param grad Drehwinkel im Gradmass
*/
void Drehen(int grad)
{
winkel = WinkelNormieren(winkel + grad);
FormErzeugen();
zeichenfläche.malfläche.repaint();
}
/**
* Versetzt Zeichenfläche und Turtle in den Ausgangszustand
*/
void Löschen()
{
linien.clear();
hintergrund = new HintergrundBild();
ZumStartpunktGehen();
}
/**
* Turtle wechselt in den Modus "nicht zeichnen"
*/
void StiftHeben()
{
stiftUnten = false;
}
/**
* Turtle wechselt in den Modus "zeichnen"
*/
void StiftSenken()
{
stiftUnten = true;
}
/**
* Schaltet die Sichtbarkeit des Turtlesymbols ein oder aus.
* Erlaubte Parameterwerte: true, false
* @param sichtbar (neue) Sichtbarkeit des Turtlesymbols
*/
void SichtbarkeitFürSymbolSetzen (boolean sichtbar)
{
symbolSichtbar = sichtbar;
zeichenfläche.malfläche.repaint();
}
/**
* Testet, ob der angegebene Punkt innerhalb der Figur ist.
* @param x x-Koordinate des zu testenden Punktes
* @param y y-Koordinate des zu testenden Punktes
* @return wahr, wenn der Punkt innerhalb der Figur ist
*/
/**
* Testet, ob die Turtle eine (sichtbare) Figur berührt.
* @return true, wenn die Turtlekoordinaten innerhalb einer Grafikfigur sind
*/
boolean Berührt ()
{
for (GrafikSymbol g: zeichenfläche.alleSymbole)
{
if ((g != this) && g.IstInnerhalb(x, y) && g.sichtbar && (!(g instanceof TurtleIntern) || ((TurtleIntern) g).symbolSichtbar))
{
return true;
}
}
return false;
}
/**
* Testet, ob die Turtle eine (sichtbare) Figur in der angegebenen Farbe berührt.
* Bei Überlappungen
* @param farbe die Farbe, die die berührte Figur haben muss.
* @return true, wenn die Turtlekoordinaten innerhalb einer Grafikfigur in der angegebenen Farbe sind
*/
boolean Berührt (String farbe)
{
Color c2 = FarbeCodieren(farbe);
boolean ok = false;
for (GrafikSymbol g: zeichenfläche.alleSymbole)
{
if ((g != this) && g.IstInnerhalb(x, y) && g.sichtbar)
{
if (g instanceof TurtleIntern)
{
TurtleIntern t = (TurtleIntern) g;
if (t.symbolSichtbar)
{
for (FigurenElement e: t.standardFigur)
{
Path2D.Double p = new Path2D.Double();
double größe = t.h > t.b ? t.b : t.h;
e.ElementZuForm(p, größe, t.x, t.y);
AffineTransform a = new AffineTransform();
a.rotate(DrehwinkelGeben (t.winkel), t.x, t.y);
p = new Path2D.Double (p, a);
if (p.contains(x, y))
{
ok = c2.equals(e.c);
}
}
}
}
else if (g instanceof FigurIntern)
{
FigurIntern t = (FigurIntern) g;
LinkedList<FigurenElement> figur = ((t.eigeneFigur == null) || (t.eigeneFigur.size() == 0)) ? t.standardFigur : t.eigeneFigur;
for (FigurenElement e: figur)
{
Path2D.Double p = new Path2D.Double();
double größe = t.h > t.b ? t.b : t.h;
e.ElementZuForm(p, größe, t.x, t.y);
AffineTransform a = new AffineTransform();
a.rotate(DrehwinkelGeben (t.winkel), t.x, t.y);
p = new Path2D.Double (p, a);
if (p.contains(x, y))
{
ok = c2.equals(e.c);
}
}
}
else
{
ok = ok || c2.equals(g.c);
}
}
}
return ok;
}
/**
* Testet, ob die Turtle die (sichtbare, ) angegebene Figur berührt.
* @param object das Objekt, das getestet werden soll.
* @return true, wenn die Turtlekoordinaten innerhalb einer Grafikfigur in der angegebenen Farbe sind
*/
boolean Berührt (Object object)
{
GrafikSymbol s = null;
if (object instanceof Rechteck)
{
s = ((Rechteck) object).symbol;
}
else if (object instanceof Dreieck)
{
s = ((Dreieck) object).symbol;
}
else if (object instanceof Kreis)
{
s = ((Kreis) object).symbol;
}
else if (object instanceof Turtle)
{
s = ((Turtle) object).symbol;
}
else if (object instanceof Figur)
{
s = ((Figur) object).symbol;
}
return (s != null) && (s != this) && s.IstInnerhalb(x, y) && s.sichtbar && (!(s instanceof TurtleIntern) || ((TurtleIntern) s).symbolSichtbar);
}
/**
* Zeichnet das Objekt als Dreieck in der gegebenen Farbe.
* @param g das Grafikobjekt zum Zeichnen
*/
@Override void Zeichnen(Graphics g)
{
Graphics2D g2 = (Graphics2D) g;
synchronized (this)
{
hintergrund.BildZeichnen(g2);
}
if (symbolSichtbar)
{
g.setColor(Color.black);
double größe = h > b ? b : h;
AffineTransform alt = g2.getTransform();
g2.rotate(DrehwinkelGeben (winkel), x, y);
if (standardFigur != null)
{
synchronized (standardFigur)
{
for (FigurenElement e: standardFigur)
{
e.ElementZeichnen(g2, größe, x, y);
}
}
}
g2.setTransform(alt);
}
}
}
/**
* Das Objekt dieser Klasse ist ein in der Gestalt definierbarer Akteur.
*/
class FigurIntern extends GrafikSymbol
{
/** Genaue x-Koordinate der Figur. */
double xD;
/** Genaue y-Koordinate der Figur. */
double yD;
/** Startkoordinate der Figur. */
private int homeX;
/** Startkoordinate der Figur. */
private int homeY;
/** Startwinkel der Figur. */
private int homeWinkel;
/** Eigene Figur für Figur. */
private LinkedList<FigurenElement> eigeneFigur;
/** Standardfigur für Figur. */
private LinkedList<FigurenElement> standardFigur;
/**
* Legt die Figur mit Startpunkt (100|200) in Richtung 0˚ an.
*/
FigurIntern ()
{
super ();
x = 100;
y = 200;
xD = x;
yD = y;
h = 40;
b = 40;
homeX=x;
homeY=y;
homeWinkel=winkel;
c = Color.black;
eigeneFigur = new LinkedList<FigurenElement>();
standardFigur = new LinkedList<FigurenElement>();
StandardfigurErzeugen();
FormErzeugen();
}
/**
* Baut die Standardfigur aus den Elementen auf.
*/
private void StandardfigurErzeugen()
{
int[] x = new int [] {-50, 50, -50};
int[] y = new int [] {-50, 0, 50};
standardFigur.add (new FigurenElementPolygon (x, y, Color.yellow));
standardFigur.add(new FigurenElementEllipse(-10, -10, 20, 20, Color.blue));
}
/**
* Erstellt die Form der Figur.
*/
@Override void FormErzeugen()
{
Area area = new Area();
AffineTransform a = new AffineTransform();
a.rotate(DrehwinkelGeben (winkel), this.x, this.y);
double größe = h > b ? b : h;
if (standardFigur != null)
{
LinkedList<FigurenElement> figur = ((eigeneFigur == null) || (eigeneFigur.size() == 0)) ? standardFigur : eigeneFigur;
synchronized (figur)
{
for (FigurenElement e: figur)
{
Path2D.Double p = new Path2D.Double();
e.ElementZuForm(p, größe, x, y);
area.add(new Area(new Path2D.Double (p, a)));
}
}
}
form = area;
}
/**
* Setzt die Position (der Mitte) des Objekts.
* @param x x-Position der Mitte
* @param y y-Position der Mitte
*/
@Override void PositionSetzen (int x, int y)
{
super.PositionSetzen (x, y);
xD = x;
yD = y;
}
/**
* Setzt die Figur wieder an ihre Ausgangsposition.
*/
void ZumStartpunktGehen()
{
x = homeX;
y = homeY;
xD = x;
yD = y;
winkel = homeWinkel;
FormErzeugen();
zeichenfläche.malfläche.repaint();
}
/**
* Bewegt die Figur nach vorne.
* @param länge Anzahl der Längeneinheiten
*/
void Gehen(double länge)
{
double neuX = xD + Math.cos(DrehwinkelGeben (winkel)) * länge;
double neuY = yD + Math.sin(DrehwinkelGeben (winkel)) * länge;
xD = neuX;
yD = neuY;
x =(int) Math.round(xD);
y =(int) Math.round(yD);
FormErzeugen();
zeichenfläche.malfläche.repaint();
}
/**
* Dreht die Figur
* @param grad Drehwinkel im Gradmass
*/
void Drehen(int grad)
{
winkel = WinkelNormieren(winkel + grad);
FormErzeugen();
zeichenfläche.malfläche.repaint();
}
/**
* Testet, ob die Figur eine (sichtbare) Grafik-Figur berührt.
* @return true, wenn die Figurkoordinaten innerhalb einer Grafikfigur sind
*/
boolean Berührt ()
{
for (GrafikSymbol g: zeichenfläche.alleSymbole)
{
if ((g != this) && g.Schneidet(form) && g.sichtbar && (!(g instanceof TurtleIntern) || ((TurtleIntern) g).symbolSichtbar))
{
return true;
}
}
return false;
}
/**
* Testet, ob die Figur eine (sichtbare) Grafik-Figur in der angegebenen Farbe berührt.
* Bei Überlappungen
* @param farbe die Farbe, die die berührte Figur haben muss.
* @return true, wenn die Figurkoordinaten innerhalb einer Grafikfigur in der angegebenen Farbe sind
*/
boolean Berührt (String farbe)
{
Color c2 = FarbeCodieren(farbe);
boolean ok = false;
for (GrafikSymbol g: zeichenfläche.alleSymbole)
{
if ((g != this) && g.Schneidet(form) && g.sichtbar)
{
if (g instanceof TurtleIntern)
{
TurtleIntern t = (TurtleIntern) g;
if (t.symbolSichtbar)
{
Area[] areas = new Area [t.standardFigur.size()];
Color[] colors = new Color [t.standardFigur.size()];
AffineTransform a = new AffineTransform();
a.rotate(DrehwinkelGeben (t.winkel), t.x, t.y);
int pos = 0;
for (FigurenElement e: t.standardFigur)
{
Path2D.Double p = new Path2D.Double();
double größe = t.h > t.b ? t.b : t.h;
e.ElementZuForm(p, größe, t.x, t.y);
p = new Path2D.Double (p, a);
areas [pos] = new Area(p);
colors[pos] = e.c;
for (int i = pos - 1; i >= 0;i--)
{
areas[i].subtract(areas[pos]);
}
pos += 1;
}
for (int i = 0; i < areas.length; i++)
{
if (Schneidet(areas[i]) && (c2.equals(colors[i])))
{
ok = true;
}
}
}
}
else if (g instanceof FigurIntern)
{
FigurIntern t = (FigurIntern) g;
LinkedList<FigurenElement> figur = ((t.eigeneFigur == null) || (t.eigeneFigur.size() == 0)) ? t.standardFigur : t.eigeneFigur;
Area[] areas = new Area [figur.size()];
Color[] colors = new Color [figur.size()];
AffineTransform a = new AffineTransform();
a.rotate(DrehwinkelGeben (t.winkel), t.x, t.y);
int pos = 0;
for (FigurenElement e: figur)
{
Path2D.Double p = new Path2D.Double();
double größe = t.h > t.b ? t.b : t.h;
e.ElementZuForm(p, größe, t.x, t.y);
p = new Path2D.Double (p, a);
areas [pos] = new Area(p);
colors[pos] = e.c;
for (int i = pos - 1; i >= 0;i--)
{
areas[i].subtract(areas[pos]);
}
pos += 1;
}
for (int i = 0; i < areas.length; i++)
{
if (Schneidet(areas[i]) && (c2.equals(colors[i])))
{
ok = true;
}
}
}
else
{
ok = ok || c2.equals(g.c);
}
}
}
return ok;
}
/**
* Testet, ob die Figur die (sichtbare, ) angegebene Grafik-Figur berührt.
* @param object das Objekt, das getestet werden soll.
* @return true, wenn die Turtlekoordinaten innerhalb einer Grafikfigur in der angegebenen Farbe sind
*/
boolean Berührt (Object object)
{
GrafikSymbol s = null;
if (object instanceof Rechteck)
{
s = ((Rechteck) object).symbol;
}
else if (object instanceof Dreieck)
{
s = ((Dreieck) object).symbol;
}
else if (object instanceof Kreis)
{
s = ((Kreis) object).symbol;
}
else if (object instanceof Turtle)
{
s = ((Turtle) object).symbol;
}
else if (object instanceof Figur)
{
s = ((Figur) object).symbol;
}
return (s != null) && (s != this) && s.Schneidet(form) && s.sichtbar && (!(s instanceof TurtleIntern) || ((TurtleIntern) s).symbolSichtbar);
}
/**
* Erzeugt ein neues, rechteckiges Element einer eigenen Darstellung der Figur.
* Alle Werte beziehen sich auf eine Figur der Größe 100 und den Koordinaten (0|0) in der Mitte des Quadrats
* @param x x-Wert der linken oberen Ecke des Rechtecks
* @param y y-Wert der linken oberen Ecke des Rechtecks
* @param breite Breite des Rechtecks
* @param höhe Höhe des Rechtecks
* @param farbe (Füll)Farbe des Rechtecks
*/
void FigurteilFestlegenRechteck (int x, int y, int breite, int höhe, String farbe)
{
synchronized (eigeneFigur)
{
eigeneFigur.add(new FigurenElementRechteck(x, y, breite, höhe, FarbeCodieren(farbe)));
}
FormErzeugen();
zeichenfläche.malfläche.repaint();
}
/**
* Erzeugt ein neues, elliptisches Element einer eigenen Darstellung der Figur.
* Alle Werte beziehen sich auf eine Figur der Größe 100 und den Koordinaten (0|0) in der Mitte des Quadrats
* @param x x-Wert der linken oberen Ecke des umgebenden Rechtecks der Ellipse
* @param y y-Wert der linken oberen Ecke des umgebenden Rechtecks der Ellipse
* @param breite Breite des umgebenden Rechtecks der Ellipse
* @param höhe Höhe des umgebenden Rechtecks der Ellipse
* @param farbe (Füll)Farbe der Ellipse
*/
void FigurteilFestlegenEllipse (int x, int y, int breite, int höhe, String farbe)
{
synchronized (eigeneFigur)
{
eigeneFigur.add(new FigurenElementEllipse(x, y, breite, höhe, FarbeCodieren(farbe)));
}
FormErzeugen();
zeichenfläche.malfläche.repaint();
}
/**
* Erzeugt ein neues, dreieckiges Element einer eigenen Darstellung der Figur.
* Alle Werte beziehen sich auf eine Figur der Größe 100 und den Koordinaten (0|0) in der Mitte des Quadrats
* @param x1 x-Wert des ersten Punkts des Dreiecks
* @param y1 y-Wert des ersten Punkts des Dreiecks
* @param x2 x-Wert des zweiten Punkts des Dreiecks
* @param y2 y-Wert des zweiten Punkts des Dreiecks
* @param x3 x-Wert des dritten Punkts des Dreiecks
* @param y3 y-Wert des dritten Punkts des Dreiecks
* @param farbe (Füll)Farbe der Ellipse
*/
void FigurteilFestlegenDreieck (int x1, int y1, int x2, int y2, int x3, int y3, String farbe)
{
synchronized (eigeneFigur)
{
int[] x = new int [] {x1, x2, x3};
int[] y = new int [] {y1, y2, y3};
eigeneFigur.add(new FigurenElementPolygon(x, y, FarbeCodieren(farbe)));
}
FormErzeugen();
zeichenfläche.malfläche.repaint();
}
/**
* Löscht die Vereinbarung für die eigene Darstellung Figur.
* Die Figur wird wieder durch die Originalfigur dargestellt.
*/
void EigeneFigurLöschen()
{
eigeneFigur.clear();
FormErzeugen();
zeichenfläche.malfläche.repaint();
}
/**
* Zeichnet das Objekt als Dreieck in der gegebenen Farbe.
* @param g das Grafikobjekt zum Zeichnen
*/
@Override void Zeichnen(Graphics g)
{
Graphics2D g2 = (Graphics2D) g;
// Outline
g.setColor(Color.black);
Stroke stAlt = g2.getStroke();
g2.setStroke(new BasicStroke(3.0f));
g2.draw(form);
g2.setStroke(stAlt);
// Füllung
double größe = h > b ? b : h;
AffineTransform alt = g2.getTransform();
g2.rotate(DrehwinkelGeben (winkel), x, y);
if (standardFigur != null)
{
LinkedList<FigurenElement> figur = ((eigeneFigur == null) || (eigeneFigur.size() == 0)) ? standardFigur : eigeneFigur;
synchronized (figur)
{
for (FigurenElement e: figur)
{
e.ElementZeichnen(g2, größe, x, y);
}
}
}
g2.setTransform(alt);
}
}
}
Write, Run & Share Java code online using OneCompiler's Java online compiler for free. It's one of the robust, feature-rich online compilers for Java language, running the Java LTS version 17. Getting started with the OneCompiler's Java editor is easy and fast. The editor shows sample boilerplate code when you choose language as Java and start coding.
OneCompiler's Java online editor supports stdin and users can give inputs to the programs using the STDIN textbox under the I/O tab. Using Scanner class in Java program, you can read the inputs. Following is a sample program that shows reading STDIN ( A string in this case ).
import java.util.Scanner;
class Input {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter your name: ");
String inp = input.next();
System.out.println("Hello, " + inp);
}
}
OneCompiler supports Gradle for dependency management. Users can add dependencies in the build.gradle file and use them in their programs. When you add the dependencies for the first time, the first run might be a little slow as we download the dependencies, but the subsequent runs will be faster. Following sample Gradle configuration shows how to add dependencies
apply plugin:'application'
mainClassName = 'HelloWorld'
run { standardInput = System.in }
sourceSets { main { java { srcDir './' } } }
repositories {
jcenter()
}
dependencies {
// add dependencies here as below
implementation group: 'org.apache.commons', name: 'commons-lang3', version: '3.9'
}
Java is a very popular general-purpose programming language, it is class-based and object-oriented. Java was developed by James Gosling at Sun Microsystems ( later acquired by Oracle) the initial release of Java was in 1995. Java 17 is the latest long-term supported version (LTS). As of today, Java is the world's number one server programming language with a 12 million developer community, 5 million students studying worldwide and it's #1 choice for the cloud development.
short x = 999; // -32768 to 32767
int x = 99999; // -2147483648 to 2147483647
long x = 99999999999L; // -9223372036854775808 to 9223372036854775807
float x = 1.2;
double x = 99.99d;
byte x = 99; // -128 to 127
char x = 'A';
boolean x = true;
When ever you want to perform a set of operations based on a condition If-Else is used.
if(conditional-expression) {
// code
} else {
// code
}
Example:
int i = 10;
if(i % 2 == 0) {
System.out.println("i is even number");
} else {
System.out.println("i is odd number");
}
Switch is an alternative to If-Else-If ladder and to select one among many blocks of code.
switch(<conditional-expression>) {
case value1:
// code
break; // optional
case value2:
// code
break; // optional
...
default:
//code to be executed when all the above cases are not matched;
}
For loop is used to iterate a set of statements based on a condition. Usually for loop is preferred when number of iterations is known in advance.
for(Initialization; Condition; Increment/decrement){
//code
}
While is also used to iterate a set of statements based on a condition. Usually while is preferred when number of iterations are not known in advance.
while(<condition>){
// code
}
Do-while is also used to iterate a set of statements based on a condition. It is mostly used when you need to execute the statements atleast once.
do {
// code
} while (<condition>);
Class is the blueprint of an object, which is also referred as user-defined data type with variables and functions. Object is a basic unit in OOP, and is an instance of the class.
class keyword is required to create a class.
class Mobile {
public: // access specifier which specifies that accessibility of class members
string name; // string variable (attribute)
int price; // int variable (attribute)
};
Mobile m1 = new Mobile();
public class Greeting {
static void hello() {
System.out.println("Hello.. Happy learning!");
}
public static void main(String[] args) {
hello();
}
}
Collection is a group of objects which can be represented as a single unit. Collections are introduced to bring a unified common interface to all the objects.
Collection Framework was introduced since JDK 1.2 which is used to represent and manage Collections and it contains:
This framework also defines map interfaces and several classes in addition to Collections.
| Collection | Description |
|---|---|
| Set | Set is a collection of elements which can not contain duplicate values. Set is implemented in HashSets, LinkedHashSets, TreeSet etc |
| List | List is a ordered collection of elements which can have duplicates. Lists are classified into ArrayList, LinkedList, Vectors |
| Queue | FIFO approach, while instantiating Queue interface you can either choose LinkedList or PriorityQueue. |
| Deque | Deque(Double Ended Queue) is used to add or remove elements from both the ends of the Queue(both head and tail) |
| Map | Map contains key-values pairs which don't have any duplicates. Map is implemented in HashMap, TreeMap etc. |