Eigene Smart Elements

Entwickeln einer Swing-Komponente

Unsere neue Komponente wird speziell für das TAPMinimalElement erstellt, daher taufen wir sie verheißungsvoll JMinimalComponent.

Wir entscheiden uns dafür, die Komponente in das Plug-In-Paket von TAP mitaufzunehmen. Dies ist nicht zwingend erforderlich, meist aber sinnvoll:

package TAPplugins;

Wir werden unsere Klassendefinition von JComponent ableiten. Zum Zeichnen in die Komponente verwenden wir ein Graphics-Objekt, zum Setzen der Farbe Color-Objekte. Diese Klassen müssen daher importiert werden:

import javax.swing.JComponent;
import java.awt.Graphics; import java.awt.Color;

Und schon geht's los:

public class JMinimalComponent extends JComponent {

Unsere Komponente soll später zwei Informationen ausgeben,

1. einen Infotext und das letze Mausereignis
2. die Anzahl der Mausklicks in die Komponente

Beide Informationen können von der Komponente in Strings gespeichert werden. Dazu deklarieren wir folgende Eigenschaften:

    private String infoString = "";  private String clickCounter = "";

Diese Eigenschaften können über zwei Zugriffsmethoden gesetzt werden:

    public void setInfoString(String infoString) {
        this.infoString = infoString;
    }

    public void setClickCounter(String clickCounter) {
        this.clickCounter = clickCounter;
    }

Die Ausgabe des Infotexts soll dabei optional fett sein und mit einem x-Offset positioniert werden. Hierzu legen wir diese Datenfelder an:

    private float offset = 0;
    private boolean bold = false;
    private Font normalFont = new Font("Times New Roman", Font.PLAIN, 12) ,
                   boldFont = new Font("Times New Roman", Font.BOLD, 18) ;

Diese Datenfelder können ebenfalls über set-Methoden geändert werden:

    public void setBold(boolean bold) {
        this.bold = bold;
    }

    public void setOffset( float offset) {
        this.offset = offset;
    }

Jetzt implementieren wir die eigentliche Arbeit unserer Komponente. Wir überschreiben die paintComponent(Graphics g) - Methode der Klasse JComponent. Diese Methode ist für das Zeichnen der Komponente verantwortlich. Indem wir die Methode überschreiben, bestimmen wir, wie die Komponente gezeichnet wir! Das Graphics-Objekt g ist dabei der Grafikkontext, in den wir zeichnen können.
Als erstes Setzen wir die Farbe des Grafkkontextes auf pink:

    g.setColor(Color.pink);

In dieser Farbe malen wir nun ein Oval, dass den Ausmaßen der Komponente entspricht. Die Maße können wir mit den Methoden getWidth() und getHeight() erfragen. Sie werden von der Mutterklasse JComponent implementiert und stehen daher auch in JMinimalComponent zur Verfügung:

    g.drawOval(0,0,this.getWidth()-1,this.getHeight()-1);

Der Infostring (der Informationen über das letzte Mausereignisse enthalten sollte) wird in schwarz und an der oberen Kande der Komponente gemäß der gesetzen Eigenschaften ausgegeben:

    g.setColor(Color.black);
    g.setFont( bold ? boldFont : normalFont);
    int xpos = (int) Math.round(this.getWidth() * (offset / 100.0f));
    g.drawString(infoString,xpos,15);

Der ClickCounter (der die Anzahl der Mausklicks enthält) wird ungefähr in der Mitte der Komponente ausgegeben:

    g.setColor(Color.red);
    g.drawString(clickCounter,this.getWidth()/2,this.getHeight()/2);

Tja, und damit haben wir uns auch schon eine neue Komponente gebastelt. Es fehlen nur noch die schließenden Klammern für die paintComponent(..)-Methode und die Klasse selbst:

    }
}

Die Komponente wurde auf unser Element maßgeschneidert und kann für eine optimale grafische Repräsentation des Elementes sorgen. Die in den Eigenschaften des TAPElementes gespeicherten Werten werden über set-Methoden gesetzt. Dies gilt nicht nur für die internen Eigenschaften, sondern auch für die Position und Größe des Elements. Eine Methode zum Setzen von Position und Größe mußten wir jedoch nicht neu schreiben, da JMinimalComponent die Methode public void setBounds(int x, int y, int width, int height) erbt, die bereits genau dies leistet. Sie stammt aus der Klasse Component, der Mutterklasse von JComponent.

Im nächsten Schritt können werden wir ein neues Element entwickeln, das diese Komponente benutzt.