Swing Problem mit getTableCellRendererComponent()

[kodela]

Hallo zusammen,

wer kann mir helfen?

Ich habe als Teil eines Projektes eine JTable-Tabelle mit sieben Spalten. Jeder Datensatz für diese Tabelle besteht also aus sieben Feldern. Das erste Feld ist vom Typ Boolean, das zweite ein Integer, die restlichen sind Strings.

Alle Daten der Tabelle sollen mit einem Font fester Zeichenbreite (Courier New) und die Integer-Daten, Werte zwischen 1 und 9999, vierstellig formatiert mit vorangestellten Nullen dargestellt werden.

Bis auf die Darstellung der Spalte 2 für die Integer-Daten funktioniert alles einwandfrei. Diese jedoch werden getTableCellRendererComponent() in meinem Renderer überhaupt nicht übergeben. Übergeben werden nur die Daten der Spalten drei bis sieben, also die Daten vom Typ String.

Versuchshalber habe ich daher in der Klasse TabelleDaten für alle Daten den Typ Object verwendet. Obwohl eigentlich weder Boolean noch Integer Objecte sind, funktionierte das grundsätzlich. Die Daten mussten beim Auslesen allerdings gecastet werden. Aber auch dies brachte nicht den gewünschten Erfolg.

Hier einmal der Renderer:

public class Renderer extends DefaultTableCellRenderer {

    private JTable sdkListe;
    private Color colorSelected = new Color(51, 153, 255);
    private Color colorNormal = new Color(255, 255, 255);

    public Renderer(JTable lst, ListModel mod) {
        sdkListe = lst;
        setFont(new Font("Courier New", Font.PLAIN, 12));
        sdkListe.setRowHeight(sdkListe.getRowHeight() + 3);                 
        sdkListe.getColumnModel().getColumn(0).setPreferredWidth(mod.getSpaltenBreite(0));
        sdkListe.getColumnModel().getColumn(1).setPreferredWidth(mod.getSpaltenBreite(1));
        sdkListe.getColumnModel().getColumn(2).setPreferredWidth(mod.getSpaltenBreite(2));
        sdkListe.getColumnModel().getColumn(3).setPreferredWidth(mod.getSpaltenBreite(3));
        sdkListe.getColumnModel().getColumn(4).setPreferredWidth(mod.getSpaltenBreite(4));
        sdkListe.getColumnModel().getColumn(5).setPreferredWidth(mod.getSpaltenBreite(5));
        sdkListe.getColumnModel().getColumn(6).setPreferredWidth(mod.getSpaltenBreite(6));
        setOpaque(true);
    }

    @Override
    public Component getTableCellRendererComponent(JTable table, Object value,
            boolean isSelected, boolean hasFocus, int row, int column) {

        setForeground(Color.BLACK);

        if (hasFocus || isSelected) {
            setBackground(colorSelected);
        }
        else {
            setBackground(colorNormal);
        }
        if (column == 1) {
            if ((Integer)value < 10) {
                setText("000" + value.toString());
            }
            else if ((Integer)value < 100) {
                setText("00" + value.toString());
            }
            else if ((Integer)value < 1000) {
                setText("0" + value.toString());
            }
            else {
                setText(value.toString());
            }
        }
        else {
            setText(value.toString());
        }
        return this;
    }
}

In Zeile 25 wird der Font festgelegt und in den Zeilen 33 bis 46 sollten die Integer-Werte formatiert werden.

Das kann aber alles nicht funktionieren, wenn der Aufruf von getTableCellRendererComponent() für die Spalte 1 nicht erfolgt.

Wo liegt mein Denkfehler.

Mit freundlichem Gruß,

Konrad

 

[Michael...]

Die Zuweisung des Fonts sollte nur einmalig im Konstruktor des Renderers erfolgen. Es macht ja keinen Sinn den Font bei jedem zeichnen einer Zelle neu zu erzeugen und neu zu zuweisen.

Falls der Renderer überhaupt auf die zweite Spalte angewendet wird, werden die vorangestellten 0en durch den Aufruf von setText(value.toString()); in Zeile 47 sowieso wieder überschrieben --> Ein else vor Zeile 47 setzen.

[JAVA=33] if (column == 1) {
if ((Integer)value < 10) {
setText("000" + value.toString());
}
else if ((Integer)value < 100) {
setText("00" + value.toString());
}
else if ((Integer)value < 1000) {
setText("0" + value.toString());
}
else {
setText(value.toString());
}
}
setText(value.toString());[/code]

 

[kodela]

Hallo Michael,

herzlichen Dank für Deine Hinweise, diese beiden Fehler hätten mir eigentlich nicht passieren dürfen. Ich habe den Code korrigiert. Das Problem ist nun zwar teilweise behoben, die Zahlen in Spalte 2 werden nun im richtigen Font angezeigt, aber eben nicht in dem Format, wie ich es gerne hätte.

Das fehlende "else" war auf keinem Fall dafür schuldig, dass es nicht zu einer Formatierung kam, denn ich habe es beim Debuggen festgestellt, dass der erste Aufruf von getTableCellRendererComponent() für die Spalte drei erfolgt.

Konrad

 

[Michael...]

ich habe es beim Debuggen festgestellt, dass der erste Aufruf von getTableCellRendererComponent() für die Spalte drei erfolgt.

Wenn dem so ist, weiss ich nicht warum die Spalte zwei den selben Font verwenden sollte. Denn dann scheint es so zu sein, dass der Renderer für die Spalte zwei nicht angewendet wird.
Interessant wäre es jetzt, wie der Renderer der Tabelle bzw. der Spalte zwei zugewiesen wird und eventuell auch das TableModel ausschaut.

 

[kodela]

Hallo Michael,

tut mir Leid, ich habe mir eingebildet, es sei der selbe Font, beim genauen Hinsehen habe ich jedoch festgestellt, dass es nicht der selbe ist.

Dass der Renderer für Spalte eins und zwei nicht verwendet wird, steht für mich außer Zweifel, denn wenn getTableCellRendererComponent() erstmals aufgerufen wird, hat column den Wert 2 und row den Wert 0. Es folgen für row 0 die Spalten bis 6. Dann geht das Spiel weiter, für jede Zeile von Spalte 2 (der dritten Spalte) bis zur Spalte 6.

Hier der Code für die Zuweisung der Renderers:

        sdkListe = new JTable(listeDaten);
        sdkListe.setDefaultEditor(Object.class, new ListEditor());
        sdkListe.setDefaultRenderer(Object.class, 
                new Renderer(sdkListe, listeDaten));

Und hier auszugsweise das TabeleModel:

public class ListModel extends DefaultTableModel {

    private SpalteDaten selekt = new SpalteDaten("", 35);
    private SpalteDaten num = new SpalteDaten("Nr", 45);
    private SpalteDaten aufgabe = new SpalteDaten("Aufgabe", 295);
    private SpalteDaten level = new SpalteDaten("Level", 65);
    private SpalteDaten vorgaben = new SpalteDaten("VW", 32);
    private SpalteDaten loesung = new SpalteDaten("Lösung", 76);
    private SpalteDaten bemerkung = new SpalteDaten("Bemerkung", 262);
    private SpalteDaten spalte[] = {selekt, num, aufgabe, level, vorgaben, loesung, bemerkung};
    private ArrayList<Object> liste;
    private boolean geaendert;
    private String userDir = System.getProperty("user.dir");
    private String listDatei = "sdkliste.lst";


    @Override
    public Class <?> getColumnClass(int i) {
        return getValueAt(0, i).getClass();
    }

    /**
     * Konstruktor
     */
    @SuppressWarnings({"unchecked", "CollectionWithoutInitialCapacity"})
    public ListModel() {
        liste = new ArrayList<Object>();
        initDaten();    
        geaendert = false;
    }

    private void initDaten(){
        File lf = new File(userDir, listDatei);
        if (lf.canRead() && lf.length() > 0) {
            datenLaden(userDir, listDatei);          // Daten werden aus Datei geladen
        }
        else {
            setDefaultData();                
        }
    }

    ...
    ...

    @Override
    public int getRowCount() {
        return liste == null ? 0 : liste.size();
    }

    @Override
    public int getColumnCount() {
        return spalte.length;
    }

    @Override
    public String getColumnName(int column) {
        return spalte[column].getSpaltenKopf();     // str;
    }

    @Override
    public boolean isCellEditable(int nRow, int nCol) {
        return nCol > 0 && nCol < 6 ? false : true;
    }

    @Override
    public Object getValueAt(int nRow, int nCol) {
        TabelleDaten row = (TabelleDaten) liste.get(nRow);
        switch (nCol) {
            case 0:
                return row.isPrintListe();
            case 1:
                return row.getLfdNr();
            case 2:
                return row.getAufgabe();
            case 3:
                return row.getLevel();
            case 4:
                return row.getVorgaben();
            case 5:
                return row.getLoesung();
            case 6:
                return row.getBemerkung();
        }
        return "";
    }

    ...
    ...
}

Jetzt noch, ebenfalls auszugsweise, die Klasse TabelleDaten:

class TabelleDaten {

    private Object printListe;
    private Object nummer;
    private Object aufgabe;
    private Object vorgaben;
    private Object level;
    private Object loesung;
    private Object bemerkung;

    TabelleDaten(boolean pl, int nr, String afg, String lev,
            String vor, String loe, String bem) {
        printListe = pl;
        nummer = nr;
        aufgabe = afg;
        level = lev;
        vorgaben = vor;
        loesung = loe;
        bemerkung = bem;
    }

    public boolean isPrintListe() {
        return (Boolean)printListe;
    }

    public void setPrintListe(boolean pl) {
        printListe = pl;
    }

    public int getNummer() {
        return (Integer)nummer;
    }

    public String getAufgabe() {
        return (String)aufgabe;
    }

    public void setAufgabe(String aufgabe) {
        this.aufgabe = aufgabe;
    }

    ...
    ...
}

Der Vollständigkeit halber noch die Klasse SpalteDaten:

class SpalteDaten {

    private String spaltenKopf;
    private int spaltenBreite;

    SpalteDaten(String title, int width) {
        spaltenKopf = title;
        spaltenBreite = width;
    }

    public String getSpaltenKopf() {
        return spaltenKopf;
    }

    public void setSpaltenKopf(String spaltenKopf) {
        this.spaltenKopf = spaltenKopf;
    }

    public int getSpaltenBreite() {
        return spaltenBreite;
    }

    public void setSpaltenBreite(int spaltenBreite) {
        this.spaltenBreite = spaltenBreite;
    }
}

Wie bereits erwähnt, hatte ich hier ursprünglich für die Daten nicht den Typ Object. Zuerst waren es in folgender Reihenfolge:

boolean, String, String, String, String, String, String

Damit ließ sich auch die Spalte zwei formatieren. Allerdings betraf dies nur den Font. Die Formatierung der Aufgaben-Nummer erfolgte direkt bei der Stringbildung.

Dann wollte ich aber Den Wert für die Aufgabennummer als Integer und damit kamen die Probleme.

Ich hoffe, die Codeschnipsel reichen für eine Beurteilung der Frage, weshalb der Renderer für die ersten beiden Spalten (wichtig wäre nur die zweite) nicht aufgerufen wird.

Konrad

 

[Michael...]

Im Falle des Renderes wird zwischen Integer und Object unterschieden.
Damit der Renderer auch für die zweite Spalte verwendet wird hast Du folgende Möglichkeiten:
a) Du setzt den Renderer als DefaultRenderer auch für Integer.class
b) Du setzt den Renderer direkt für die zweite Spalte
c) Du entfernst die Methode

public Class <?> getColumnClass(int i) {

aus Deinem TableModel

 

[kodela]

Hallo Michael,

zuerst einmal Danke für die Mühe, die Du Dir mit meinem Problem machst.

Kannst Du mir auch noch sagen, wie ich den Renderer als DefaultRenderer auch für Integer.class setzen kann. Ich areite erst seit Anfang dieses Jahres mit Java und blicke da noch nicht voll durch.

Den Renderer nur für die zweite Spalte einzusetzen wäre natürlich auch eine Möglichkeit, aber dann geht mir doch der Einfluss auf die anderen Spalten verloren.

Die dritte Möglichkeit, also das Entfernen der Methode public Class <?> getColumnClass(int i), habe ich schon ausprobiert und die Spalte 2 sah genau so aus, wie ich es mir vorstellte, aber dafür waren in der ersten Spalte die Selektionskästchen für den jeweiligen Datensatz verschwunden. Man sah nur drei Punkte und wenn man die Spalte verbreiterte, kam "false" zu Tage. So will ich das natürlich nicht. Der Anwender soll die Möglichkeit haben, mehrere Datensätze für den Ausdruck zu selektieren.

Wenn es Dich übrigens interessiert, wie mein Projekt aussieht, kannst Du es von meiner Homepage downloden. Hier die Adresse: Konrad Demmel's Homepage. Da ist die Tabelle noch in Ordnung, aber die Daten der Spalte zwei sind eben keine Integers.

Konrad

 

[Beni]

JTable.setDefaultRenderer setzt den default-renderer.

table.setDefaultRenderer( Integer.class, renderer );

Btw. es wäre noch schön wenn du verschiedene Renderer für verschiedene Datentypen verwendest, dann musst du nicht allen Code in einen Renderer verwursteln (den du kein zweites mal einsetzten kannst).

 

[kodela]

Hallo Beni, hallo Michael,

herzlichen Dank für Eure Hilfe. Ich habe dadurch nun doch ein etwas besseres Verständnis über den Einsatz eines Renderers bekommen.

Nachdem ich den Renderer nur für die Integer-Class und damit ausschließlich für die Spalte 2 definiert und die Einstellungen für den Font herausgenommen habe, funktioniert nun alles so wie ich es mir gedacht habe.

Mit freundlichem Gruß,

Konrad

 

[kodela]

Hallo,

eine Frage hätte ich noch. Wer kann mir sagen, warum in einem Renderer für den Typ Object die Methode getTableCellRendererComponent() nur für Spalten mit Daten vom Typ String aufgerufen wird. Liegt das daran, dass Boolean und Integer selbst keine Klassen und damit auch keine Objecte sind?

Konrad

 

[Michael...]

Das liegt daran, dass JTable bereits einen DefaultRenderer für alle Objekte vom Typ Number (Integer ist eine Subklasse davon) definiert hat.
Wenn für eine konkrete Klasse ein DefaultRenderer definiert ist, wird dieser benutzt. Wenn nicht, wird geprüft, ob für deren Superklasse ein Renderer definiert ist usw. bis man letztendlich bei Object.class landet.

Theoretisch könnte man statt:

table.setDefaultRenderer(Integer.class, myRenderer);

auch folgendes schreiben:

table.setDefaultRenderer(Number.class, null);

Dann würde aber für alle Klassen die von Number erben, der Renderer für Object verwendet werden.

PS.: Ist nur Theorie, hab's noch nie ausprobiert.

 

[kodela]

Hallo Michael,

Deine Argumentation leuchtet mir schon ein. Trotzdem stellt sich mir die Frage, warum ein Renderer, der als DefaultRenderer für den Typ Object gesetzt wird, nur Strings aber keine sonstigen Typen behandelt.

Wenn Integers und Booleans wie Strings als Objekte gesehen würden, dann müsste doch auch für sie ein solcher Renderer benutzt werden. Du schreibst:

Wenn für eine konkrete Klasse ein DefaultRenderer definiert ist, wird dieser benutzt.

Ich habe aber den DefaultRenderer nicht für die konkrete Klasse "String" sondern für die Klasse "Object" gesetzt. "Object" ist doch, so weit ich es verstanden habe, die Basisklasse der Java-Klassenhierarchie, damit gewissermaßen die Oberklasse aller Java-Klassen und selbst keine konkrete Klasse.

Wenn das aber so ist und ein für "Object" gesetzter DefaultRenderer ignoriert "Booleans" und "Numbers" (auch wieder die Oberklasse für "Integer", Double" etc.), dann muss man daraus doch schließen, dass Java für den Bereich der Renderer davon ausgeht, dass Wrapper-Objekte, also abstrakte Objekte für die fundamentalen Typen von Java (z.B. int, char, double, float, boolean) nicht als Objekte angesehen werden. Anders kann ich mir das nicht erklären.

Konrad

 

[Michael...]

Wenn das aber so ist und ein für "Object" gesetzter DefaultRenderer ignoriert "Booleans" und "Numbers" (auch wieder die Oberklasse für "Integer", Double" etc.), dann muss man daraus doch schließen, dass Java für den Bereich der Renderer davon ausgeht, dass Wrapper-Objekte, also abstrakte Objekte für die fundamentalen Typen von Java (z.B. int, char, double, float, boolean) nicht als Objekte angesehen werden.

Nein, auch der Renderer "sieht" Objekte vom Typ Integer, Double, Number, Boolean... als Object(s) an - sie erben ja alle von Object.
JTable besitzt einen gewissen Standardsatz an DefaultRendereren für unterschiedliche Objekte.
Wenn man von der JTable den Renderer für ein Objekt einer bestimmten Klasse anfordert, arbeitet die JTable sich sukksessive durch die Klassenhierarchie, bis sie einen passenden Renderer gefunden hat.
Bsp. Integer:
Für Integer ist standardmäßig kein DefaultRenderer definiert, also ermittelt JTable die Superklasse von Integer --> Number und prüft ob für diese Klasse ein Renderer definiert ist. Und tatsächlich ;-) für Number ist ein Renderer (Text rechtsbündig) definiert, also wird dieser angewendet.
Würde man jetzt aktiv den DefaultRenderer für die Klasse Number löschen, würde die JTable im obigen Fall die Superklasse von Number ermitteln --> Object und wird dann auch für Integer, Double, Float... den Renderer für Objekte vom Typ Object anwenden.

 

[kodela]

Hallo Michael,

ok, alles klar. Danke für Dein Bemühen.

Konrad