Byte-Welt Wiki - Benutzerbeiträge [de]

Java-Applet zu Java-Applikation umschreiben

2018-08-26T17:55:35Z

Marco13:

Java-Applets sind spätestens mit der Veröffentlichung von Java 7 Update 51 auf Webseiten im Internet praktisch bedeutungslos geworden. Zu viele Sicherheitslücken, die bis dahin aktiv ausgenutzt wurden, steckten im Java Plugin für Webbrowser.
Mit dem Release von Java 7 Update 51 wurden Applets sämtliche Rechte entzogen. Nur die Anpassung der Einstellungen in der Java Runtime, in der einbettenden Jar-Datei und in der einbettenden Ẃebseite versetzten Benutzer noch in die Lage, Java-Applets auszuführen.

Mit Veröffentlichung von Java 9 hat Oracle das Java Plugin als ''deprecated'' (veraltet) eingestuft. In einer späteren Java-Versionen wird das Java Plugin also aus dem JDK und der JRE entfernt werden.

Auch die Browser-Hersteller unterstützen bereits in ihren aktuellen Versionen ihrer Programme keine Java-Applets mehr. Zeit also, nützliche Java-Applets zu ausführbare Java-Anwendungen umzubauen.

In diesem Tutorial werden wir eine häufig gestellte Frage behandeln und ausführlich beantworten:

==Wie verwandelt man ein Java-Applet in eine Java-Anwendung?==

Ein Applet in eine Anwendung umzuschreiben kann sehr einfach sein: Es gibt viele Applets, die nur wenig Funktionalität haben, und zum Beispiel nur etwas auf den Bildschirm zeichnen. In diesen Fällen kann man das Applet manchmal unverändert in eine Anwendung einfügen. Wenn das Applet mehr Funktionalität enthält (also Bedienkomponenten wie z.B. Buttons, Animationen oder Maus-Interaktion) kann es notwendig sein, diese Funktionalitäten einzeln in eine Anwendung zu übertragen. Je nachdem, wie das Applet aufgebaut ist, kann es dabei empfehlenswert sein, die Funktionen durch modernere Gegenstücke zu ersetzen - zum Beispiel, wenn ein Applet, das mit AWT entwickelt wurde, in eine Swing-Anwendung umgeschrieben werden soll.

In Folgenden werden einige Beispiele für einfache Applets gezeigt, und wie man ihre Funktionen in eine Anwendung übertragen kann.

== In Arbeit! Dieser Artikel wird gerade noch bearbeitet ==

* Wie auf den Unterschied von <code>Applet</code> und <code>JApplet</code> eingehen? (Letztere sind recht selten...)
* Kurzer Hinweis auf die Applet Lifecycle Methods (init/start/stop/destroy) hier? Die werden unten an verschiedenen Punkten benötigt...

== Ein einfaches Applet mit minimalem Aufwand in eine Anwendung verwandeln ==

* Ein <code>Applet</code> ist eine <code>Component</code>. Zeigen, wie man die einfach in einem <code>Frame</code> darstellen kann

== Zeichenfunktionen ==

* Zeigen, wie man die <code>update</code>/<code>paint</code>-Methoden (inklusive händischem double-buffering) nach Swing überträgt

== Animationen ==

* Das Negativbeispiel von "sleep in paint" verdammen, und einen einfachen repaint-Thread zeigen

== Bedienkomponenten ==

* Ggf. schwierig zu trennen. Es gibt Applets, die da richtigen Mist machen. Applets enthalten machmal Buttons UND Zeichenfunktionalität...
* Händisches "button.setBounds" war OK, weil sich die Applet-Größe nie geändert hat. Kurzer Hinweis (KEINE Anleitung!) zu LayoutManagern
* Erwähnen, das Button/Slider/CheckBox leicht zu JButton/JSlider/JCheckBox gemacht werden können

==Siehe auch==
* [[Einbinden von Java-Applets in HTML-Dateien]]
* [[Java-Applets und Java WebStart-Anwendungen signieren]]
* [[Java Applets und Java Web Start-Anwendungen starten - ab Java 7 Update 51]]
* [[JAR-Datei]]

{{Fragen stellen}}

[[Kategorie:Java]]
[[Kategorie:Java Applets]]
[[Kategorie:Tutorials]]

Limit (SQL)

2017-01-03T13:27:39Z

Marco13: Fix entsprechend https://forum.byte-welt.net/byte-welt-projekte-projects/wiki/22974-wiki-beitrag-limit.html

Um Abfragen zu beschleunigen kann man eine maximale Anzahl an Ergebnissen festlegen, somit hört das [[DBMS]] nach X Werten auf nach weiteren zu suchen.

==MySQL==
Unter [[MySQL]] gibt es für diesen Fall die Anweisung ''LIMIT'', diese hat zwei Parameter, wobei der letzte optional ist.
<code=sql>SELECT * from testtable WHERE id = 1 LIMIT 1</code=sql>
Diese Abfrage wählt nur ein Element aus, auch wenn es mehrere Elemente mit der ID 1 geben würde, außerdem wird direkt nach der 1. Abfrage aufgehört nach weiteren zu suchen.

<code=sql>SELECT * FROM testtable WHERE id >1 ORDER BY id LIMIT 10,30</code=sql>
Diese Abfrage wählt 30 Elemente aus, jedoch werden diese nicht vom Anfang genommen, sondern erst ab dem 10. Element: Der erste Parameter von ''LIMIT'' beschreibt dabei den offset der Zeilen, und der zweite Parameter die maximale Anzahl der Zeilen. Dies bedeutet wenn die id von 1-100 eindeutig durchnummeriert ist, werden die Elemente 11-40 ausgegeben.

==PostgreSQL==
Unter [[PostgreSQL]] gibt es ähnlich wie bei [[MySQL]] die Anweisung ''LIMIT'', auch mit den beiden Parametern, jedoch wird der zweite Parameter mit dem [[Schlüsselwort]] ''OFFSET'' eingetragen.
<code=sql>SELECT * from testtable WHERE id = 1 LIMIT 1</code=sql>
Diese Abfrage wählt nur ein Element aus, auch wenn es mehrere Elemente mit der ID 1 geben würde, außerdem wird direkt nach der 1. Abfrage aufgehört nach weiteren zu suchen.

<code=sql>SELECT * FROM testtable WHERE id >1 ORDER BY id LIMIT 10 OFFSET 30</code=sql>
Diese Abfrage wählt 10 Elemente aus, jedoch werden diese nicht vom Anfang genommen, sondern erst ab dem 30.Element. Dies bedeutet wenn die id von 1-100 eindeutig durchnummeriert ist, werden die Elemente 30-40 ausgegeben.

==Oracle==
Unter [[Oracle]] gibt es für diese Art der Anweisungen eine weitere Spalte, diese heißt ''ROWNUM''. Sie enthält die Zeilennummer, so dass man mit dieser wie mit jeder anderen Spalte arbeiten kann.
<code=sql>SELECT * from testtable WHERE id = 1 AND rownum = 1</code=sql>
Diese Abfrage wählt nur ein Element aus, auch wenn es mehrere Elemente mit der ID 1 geben würde, außerdem wird direkt nach der 1. Abfrage aufgehört nach weiteren zu suchen.

Eine Abfrage auf ''rownum > 1'' ist nicht möglich, da die rownum erzeugt wird nachdem der Query Optimizer die WHERE Klausel ausgwertet hat. Siehe http://www.oracle.com/technology/oramag/oracle/06-sep/o56asktom.html

==MSSQL==
[[MSSQL]] besitzt die Anweisung ''TOP'' für die Begrenzung der Ergebnise. Unter SQL CE existiert die Funktion nicht, es gibt auch keine Alternative.
<code=sql>SELECT TOP 10 * FROM testtable WHERE id = 1</code=sql>

Einen Offset oder ähnliches wird von MSSQL nicht unterstützt oder angeboten.

==DB2==
[[DB2]] hat für die die Begrenzung der Ergebnisse die Anweisung ''FETCH FIRST X ROWS ONLY''.

<code=sql>SELECT * FROM testtable FETCH FIRST 10 ROWS ONLY;</code=sql>

[[Kategorie:SQL]]
[[Kategorie:MySQL]]
[[Kategorie:PostgreSQL]]
[[Kategorie:Oracle]]
[[Kategorie:MSSQL]]

Bilder skalieren

2013-08-17T20:21:05Z

Marco13:

=Bilder skalieren=

Einen ausführlichen Artikel zum Thema 'Bilder skalieren' gibt es unter [https://today.java.net/pub/a/today/2007/04/03/perils-of-image-getscaledinstance.html The Perils of getScaledInstance]. Die wichtigsten Punkte sind hier kurz zusammengefasst.

Bim Skalieren von Bildern gibt es im wesentlichen zwei mögliche Ziele: Man will das Bild entweder ''skaliert zeichnen'', oder man will eine ''skalierte Instanz'' eines Bildes erstellen. In beiden Fällen kann man noch unterschiedliche Schwerpunkte setzen. So kann im einen Fall die Performance (also die Zeichengeschwindigkeit) besonders wichtig sein, und im anderen Fall die Bildqualität.

== Bilder skaliert zeichnen ==

Wenn man ein Bild skaliert zeichnen will, kann man das am einfachsten direkt mit der geeigneten Methode <code>drawImage</code> aus der Klasse <code>Graphics</code>. Von dieser Methode gibt es verschiedene Varianten, und unter anderem eine, mit der man direkt sagen kann, wie groß das Bild gezeichnet werden soll:
<code=java>
public boolean drawImage(Image image, int x, int y, int width, int height, ImageObserver observer)
</code=java>
Um ein Bild in einer Größe von 400x300 Bildpunkten zu zeichnen, verwendet man also
<code=java>
graphics.drawImage(image, 0, 0, 400, 300, null);
</code=java>

== Skalierte Instanzen erstellen ==

Um eine skalierte Instanz eines Bildes zu erstellen, kann man einfach das vorhandene Bild in ein Bild der gewünschten Größe hineinzeichnen:
<code=java>
BufferedImage originalImage = ImageIO.read(new File("image.png"));
BufferedImage scaledImage = new BufferedImage(400, 300, BufferedImage.TYPE_INT_ARGB);
Graphics g = scaledImage.createGraphics();
g.drawImage(originalImage, 0, 0, 400, 300, null);
g.dispose();
</code=java>
Wie man sieht wird hierbei die gleiche Methode <code>drawImage</code> aus der Klasse <code>Graphics</code> verwendet, wie beim skalierten Zeichnen. Allerdings wird das Bild hier nicht auf den Bildschirm, sondern in ein anderes Bild hinein gezeichnet.

== RenderingHints: Qualität oder Geschwindigkeit? ==

Sowohl beim skalierten Zeichnen als auch beim erstellen skalierter Instanzen kann man durch das Setzen von ''Rendering Hints'' noch festlegen, ob eher in höherer Qualität oder eher in höherer Geschwindigkeit gezeichnet werden soll. Diese ''Rendering Hints'' setzt man in dem <code>Graphics2D</code>-Objekt, das man zum Zeichnen verwendet. Dabei ist egal, ob man direkt auf den Bildschirm oder in ein anderes Bild hinein zeichnet.

Zum Beispiel wird hier gesagt, dass ''bilineare Interpolation'' verwendet werden soll, was zwar etwas langsamer ist, aber für höhere Bildqualität sorgt:
<code=java>
Graphics2D g = (Graphics2D)graphics;
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g.drawImage(image, 0, 0, 400, 300, null);
</code=java>
Hätte man statt <code>VALUE_INTERPOLATION_BILINEAR</code> den Wert <code>VALUE_INTERPOLATION_NEAREST_NEIGHBOR</code> angegeben, wäre die Bildqualität geringer, aber das Zeichnen etwas schneller.

== Warum nicht getScaledInstance? ==

Oft werden mit der Methode [http://docs.oracle.com/javase/6/docs/api/java/awt/Image.html#getScaledInstance%28int,%20int,%20int%29 Image#getScaledInstance] skalierte Instanzen von Bildern erstellt und gezeichnet - im schlimmsten Fall sogar bei jedem Zeichenvorgang erneut. Diese Methode ist oft weder in bezug auf Bildqualität noch in Bezug auf die Performance die geeignetste Lösung. Die Methoden aus der Klasse <code>Graphics2D</code> und die <code>RenderingHints</code> bieten mehr Möglichkeiten, die für das jeweilige Ziel beste Skalierungs-Art zu wählen. Zusätzlich können die skalierten Instanzen, die manuell erstellt werden, Hardwarebeschleunigt sein, wodurch sie später schneller gezeichnet werden können.

== Das war nicht alles! ==

Es gibt noch viele Details, die man beim Skalieren von Bildern berücksichtigen kann. Im oben verlinkten Artikel wird genauer auf diese Details eingegangen und verschiedene mögliche Strategien beim Skalieren besprochen, und die Ergebnisse mit Benchmarks und Testbildern verglichen. Aber schon die Frage, ob man Bilder in einem bestimmten Anwendungsfall eher ''skaliert zeichnen'' sollte, oder ob es besser wäre, eine ''skalierte Instanz'' eines Bildes zu erstellen, kann schwierig zu beantworten sein. Dieser Artikel soll nur die grundsätzlichen Unterschiede und Vorgehensweisen beschreiben, und hilft hoffentlich, zu verhindern, dass jemand vor jedem Zeichnen eines Bildes eine skalierte Instanz mit <code>getScaledInstance</code> erstellt....

[[Kategorie:Tutorials (Java)]]|[[Kategorie:Java]]

Malen in Swing Teil 2: ein einfaches Malprogramm

2012-12-26T15:46:16Z

Marco13: ActionListener muss initialisiert werden, bevor er in 'addButton' verwendet wird

__TOC__
Der erste Teil dieses Tutorials erklärt den grundlegenden Malmechanismus: [[Malen in Swing Teil 1: der grundlegende Mechanismus]].

Das folgende weiterführende Beispielprogramm erlaubt das Malen von farbigen Linien verschiedener Stärke. Das Malen geschieht freihändig durch Ziehen mit der Maus.
Durch dieses Beispiel lernen wir:
* wie mehrfache repaint Anträge zusammengefasst werden
* wie wir den Bereich, der dargestellt wird, einschränken können
[[Datei:DrawOnImage.jpg]]
==Mehrfache repaint Anträge zusammenfassen==

Jede gemalte Linie setzt sich zusammen aus einer Folge von vielen Kreisen (Graphics#fillOval), die jeweils durch Interpolation zwischen zwei Mauspunkten festgelegt werden.
Dabei wird repaint(x,y,brushSize,brushSize) mehrfach in einer Schleife aufgerufen:

<code=java> @Override
public void mouseDragged(final MouseEvent e) {
double xDelta = e.getX() - lastPoint.getX();
double yDelta = e.getY() - lastPoint.getY();
double delta = Math.max(Math.abs(xDelta), Math.abs(yDelta));
double xIncrement = xDelta / delta;
double yIncrement = yDelta / delta;
double xStart = lastPoint.getX();
double yStart = lastPoint.getY();
for (int i = 0; i < delta; i++) {
Point interpolated = new Point((int) xStart, (int) yStart);
draw(interpolated);
xStart += xIncrement;
yStart += yIncrement;
}
draw(e.getPoint());
lastPoint = e.getPoint();
}

private void draw(final Point start) {
int brushSize = drawingPanel.getBrushSize();
int x = start.x - (brushSize / 2) + 1;
int y = start.y - (brushSize / 2) + 1;
drawingPanel.getG2d().fillOval(x, y,brushSize, brushSize);
drawingPanel.repaint(x, y,brushSize, brushSize); //<<---------------------
}
</code=java>

Erfolgen mehrfache repaint() Aufrufe auf einer Komponente bevor der erste Antrag verarbeitet wird, kann der Swing Repaintmanager die mehrfachen Anträge zu einem einzigen Aufruf zusammenfassen. Genauer gesagt: der RepaintManager wird eine Serie von Malanträgen dann zusammenfassen, wenn der "Anführer" der Serie schon mit invokeLater verschickt wurde, aber noch nicht auf dem EDT verarbeitet wurde (der Vorgang bleibt also "threadsafe"). Wenn mehrfache Anträge zusammengefasst werden, ist das resultierende Cliprechteck gleich der Vereinigung der Rechtecke, die in den zusammengefassten Anträgen enthalten sind.

'''BEMERKUNG:'''

Diese Zeile:
<code=java>drawingPanel.getG2d().fillOval(x, y,brushSize, brushSize);</code=java>
holt mit '''getG2d()''' nicht das Graphics Objekt der Komponente, sondern das Graphics Objekt des '''Bildes'''. In paintComponent wird dann mit "drawImage" das Bild auf das Graphics Objekt der Komponente übertragen, wie der folgende Abschnitt zeigt. Daher auch der Name des Hauptprogramms "DrawOnImage". Man spricht in diesem Fall auch von der "passiven Maltechnik".

==Den Bereich, der dargestellt wird, einschränken==
Während Swing versucht, den Prozess der Darstellung der Komponenten so leistungsfähig wie möglich zu machen, kann die paintComponent() Implementierung einer Komponente selbst eine bedeutende Auswirkung auf die gesamte Leistung haben. Wir können diesen Prozess beeinflussen, indem wir die Clipinformationen verwenden, um den Bereich, der dargestellt wird, einzuschränken.

Wenn deine Komponente einfach ist -- zum Beispiel, wenn es eine Drucktaste ist -- dann ist sie die Mühe nicht wert, die Darstellung zu bearbeiten, um nur den Teil zu malen, der das Cliprechteck überschneidet; es ist vorzuziehend, die gesamte Komponente zu malen und die Graphics passend einschränken zu lassen. Wenn du jedoch eine Komponente mit komplizierter Ausgabe erzeugt hast, wie eine Textkomponente, dann ist es notwendig, dass dein Code die Clipinformationen gebraucht, um den Umfang der Darstellung einzuschränken. Die Methode Graphics#getClipBounds gibt uns Zugriff auf das Cliprechteck:

<code=java> @Override
public void paintComponent(final Graphics g) {
super.paintComponent(g);
// initialises the image with the first paint
// or checks the image size with the current panelsize
if (image == null || image.getWidth(this) < getSize().width || image.getHeight(this) < getSize().height) {
resetImage();
}
Rectangle r = g.getClipBounds(); //<<----------------------
g.drawImage(image, r.x, r.y, r.width + r.x, r.height + r.y, r.x, r.y, r.width + r.x, r.height + r.y, null);
}
</code=java>
Der drawImage(..)-Aufruf, mit den angegebenen Parametern, zeichnet nur den Teil des Bildes neu, der sich mit dem Cliprechteck überschneidet. Man spricht in diesem Zusammenhang auch von der "intelligenten Maltechnik" (smart painting).

==Gesamter Quellcode==
<code=java>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class DrawOnImage {

final private DrawingPanel drawingPanel;
final private JPanel buttonPanel;
final private JButton clearButton, upSize, downSize;
private final ActionListener actionHandler;

public DrawOnImage() {
JFrame frame = new JFrame("DrawOnImage");
drawingPanel = new DrawingPanel();
actionHandler = new ActionListener() {

@Override
public void actionPerformed(final ActionEvent e) {
String s = e.getActionCommand();
if (s.equals("Paint")) {
JButton button = (JButton) e.getSource();
drawingPanel.setPaintColor(button.getBackground());
} else if (s.equals("Clear")) {
drawingPanel.clearPaint();
} else if (s.equals("+")) {
drawingPanel.increaseBrushSize();
} else {
drawingPanel.decreaseBrushSize();
}
}
};
buttonPanel = new JPanel();
buttonPanel.setLayout(new GridLayout(2, 0, 2, 2));
addButton(Color.BLACK);
addButton(Color.BLUE);
addButton(Color.GREEN);
upSize = addButton(null);
upSize.setText("+");
addButton(Color.RED);
addButton(Color.ORANGE);
clearButton = addButton(null);
clearButton.setText("Clear");
downSize = addButton(null);
downSize.setText("-");
frame.getContentPane().add(new JScrollPane(drawingPanel));
frame.getContentPane().add(buttonPanel, BorderLayout.SOUTH);
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}

private JButton addButton(final Color color) {
JButton button = new JButton();
button.setBackground(new Color(230, 240, 250));
button.setBorder(BorderFactory.createEtchedBorder());
if (color != null) {
button.setForeground(Color.WHITE);
button.setBackground(color);
}
button.setText("Paint");
buttonPanel.add(button);
button.addActionListener(actionHandler);
return (button);
}

public static void main(final String[] args) {
Runnable gui = new Runnable() {

@Override
public void run() {
DrawOnImage drawOnImage = new DrawOnImage();
}
};
//GUI must start on EventDispatchThread:
SwingUtilities.invokeLater(gui);
}
}

</code=java>
<code=java>
import java.awt.Point;
import java.awt.event.MouseEvent;
import javax.swing.event.MouseInputAdapter;

class MouseHandler extends MouseInputAdapter {

private final DrawingPanel drawingPanel;
private Point lastPoint;

MouseHandler(final DrawingPanel drawingPanel) {
this.drawingPanel = drawingPanel;
}

@Override
public void mousePressed(final MouseEvent e) {
lastPoint = e.getPoint();
draw(lastPoint);
}

@Override
public void mouseDragged(final MouseEvent e) {
double xDelta = e.getX() - lastPoint.getX();
double yDelta = e.getY() - lastPoint.getY();
double delta = Math.max(Math.abs(xDelta), Math.abs(yDelta));
double xIncrement = xDelta / delta;
double yIncrement = yDelta / delta;
double xStart = lastPoint.getX();
double yStart = lastPoint.getY();
for (int i = 0; i < delta; i++) {
Point interpolated = new Point((int) xStart, (int) yStart);
draw(interpolated);
xStart += xIncrement;
yStart += yIncrement;
}
draw(e.getPoint());
lastPoint = e.getPoint();
}

private void draw(final Point start) {
int brushSize = drawingPanel.getBrushSize();
int x = start.x - (brushSize / 2) + 1;
int y = start.y - (brushSize / 2) + 1;
drawingPanel.getG2d().fillOval(x, y, brushSize, brushSize);
drawingPanel.repaint(x, y, brushSize, brushSize);
}
}
</code=java>
<code=java>
import java.awt.*;
import javax.swing.*;

public class DrawingPanel extends JComponent {

private Image image;
private Graphics2D g2d;
private int brushSize = 5;

public DrawingPanel() {
super();
setPreferredSize(new Dimension(300, 300));
MouseHandler mh = new MouseHandler(this);
addMouseListener(mh);
addMouseMotionListener(mh);
}

@Override
public Dimension getPreferredSize() {
Dimension size = super.getPreferredSize();
if (image != null) {
size.width = image.getWidth(this);
size.height = image.getHeight(this);
}
return size;
}

public void setPaintColor(final Color color) {
g2d.setColor(color);
}

public void clearPaint() {
g2d.setBackground(Color.WHITE);
g2d.clearRect(0, 0, getWidth(), getHeight());
repaint();
g2d.setColor(Color.BLACK);
}

public void increaseBrushSize() {
brushSize += 2;
}

public void decreaseBrushSize() {
brushSize -= 2;
if (brushSize <= 0) {
brushSize = 1;
}
}

@Override
public void paintComponent(final Graphics g) {
super.paintComponent(g);
// initialises the image with the first paint
// or checks the image size with the current panelsize
if (image == null || image.getWidth(this) < getSize().width
|| image.getHeight(this) < getSize().height) {
resetImage();
}
Graphics2D g2 = (Graphics2D) g;
Rectangle r = g.getClipBounds();
g2.drawImage(image, r.x, r.y, r.width + r.x, r.height + r.y,
r.x, r.y, r.width + r.x, r.height + r.y, this);
}

private void resetImage() {
Image saveImage = image;
Graphics2D saveG2d = g2d;
image = createImage(getWidth(), getHeight());
g2d = (Graphics2D) image.getGraphics();
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g2d.setBackground(Color.WHITE);
g2d.clearRect(0, 0, getWidth(), getHeight());
g2d.setColor(Color.BLACK);
if (saveG2d != null) {
g2d.setColor(saveG2d.getColor());
g2d.drawImage(saveImage, 0, 0, this);
saveG2d.dispose();
}
}

public Graphics2D getG2d() {
return g2d;
}

public int getBrushSize() {
return brushSize;
}
}
</code=java>

[[Kategorie:Java]]
[[Kategorie:Tutorials (Java)]]
[[Kategorie:Swing]]