Swing JTable cell-ausrichtung für zahlen mit alternierenden zeilenfarben

[javice]

Hallo allerseits,

1) I wollte, dass jede zweite zeile meiner JTable mit einer anderen farbe eingefärbt ist. Dafür habe ich auch eine lösung im www gefunden. Aber sie bewirkt, dass spalten mit zahlen ungewünschterweise linksbündig angezeigt werden. Ohne diese änderung werden spalten mit zahlen rechtsbündig dargestellt (so sollte es auch sein).

Hab keine lösung gefunden, kann hier jemand weiterhelfen?

Den kompletten lauffähigen code hab ich angehängt.



2) Es gibt noch ein thema, das schreibe ich in einen extra beitrag.

package xxx;
 
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JLabel;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableModel;
import java.awt.*; 
import java.awt.event.*; 
import java.sql.Types;
 
import javax.swing.event.*; 
 
 
 
 
import javax.swing.RowSorter;
//import javax.swing.table.DefaultTableModel;
//import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;
 
 
 
 
public class strippedDown {
 
    class simpleData extends AbstractTableModel {  
        int             maxCols;
        int             maxRows;
         
        String[] columns = { "Item", "Quantity", "Price" };
     
        Object[][] cache = { { "Potatoes", 1, 10.98 }, { "Magazine", 2, 7.99 },
            { "Can of soup", 10, 0.89 }, { "DVD movie", 11, 39.99 } };
     
         
        //---1----+----2----+----3----+----4----+----5----+----6----+----7----+----8
        public simpleData(
        ) {
            this.maxCols        = 3;
            this.maxRows        = 4;
        }
     
         
        //---1----+----2----+----3----+----4----+----5----+----6----+----7----+----8   
        @Override public String getColumnName(
            int col
        ) {
            String  tmpStr;
     
            tmpStr  = columns[col];
            return( tmpStr );
        } // Ende getColumnName
     
         
        //---1----+----2----+----3----+----4----+----5----+----6----+----7----+----8   
        @Override public int getRowCount()      { return(this.maxRows); }
        @Override public int getColumnCount()   { return(this.maxCols); }
     
         
        //---1----+----2----+----3----+----4----+----5----+----6----+----7----+----8   
        @Override public Class getColumnClass(
            int col
        ) {
            Class   x;
             
            switch( col ) {
                case 0: x = Object.class;break;
                case 1: x = Number.class;break;
                case 2: x = Number.class;break;
                default:System.exit(-99);
                x = Object.class;
                 
            }
            return(x);
        } // Ende getColumnClass
         
         
        //---1----+----2----+----3----+----4----+----5----+----6----+----7----+----8   
        @Override public Object getValueAt(
            int row,
            int col
        ) {
            Object  tmp;
             
            tmp = this.cache[row][col];
            return(tmp);
        }
    }
     
     
    //---1----+----2----+----3----+----4----+----5----+----6----+----7----+----8   
    private class myRenderer implements TableCellRenderer {
        public final DefaultTableCellRenderer   dr  = new DefaultTableCellRenderer();
         
        //----+----2----+----3----+----4----+----5----+----6----+----7----+----8   
        public Component getTableCellRendererComponent(
            JTable  table,
            Object  value,
            boolean isSelected,
            boolean hasFocus,
            int     row,
            int     column
        ) {
            Component   renderer    = dr.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
 
            Color   fg;
            Color   bg;
 
            if( isSelected ) {             
                fg  = Color.YELLOW;
                bg  = Color.GREEN;
            } else {
                if( row % 2  == 0 ){
                    fg  = Color.BLUE;
                    bg  = Color.WHITE;
                } else {
                    fg  = Color.WHITE;
                    bg  = Color.BLUE;
                     
                }
            }
            renderer.setForeground(fg);
            renderer.setBackground(bg);
            return( renderer );
        }
    }
     
     
    //---1----+----2----+----3----+----4----+----5----+----6----+----7----+----8   
    public strippedDown(
    ) {
        JFrame  f;
        JTable  tbl;
        simpleData data;
         
        data    = new simpleData();
         
        f       = new JFrame();
        tbl     = new JTable( data );
         
         
         
        tbl.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
         
        tbl.setPreferredScrollableViewportSize(new Dimension(800, 500));
 
        //code for numerical sorting
//      tbl.setAutoCreateRowSorter(true);   
        RowSorter<simpleData> sorter = new TableRowSorter<simpleData>(data);
        tbl.setRowSorter(sorter);
 
        //now, this here creates the alternating colors in every second row
        tbl.setDefaultRenderer(Object.class, new myRenderer());
        tbl.setDefaultRenderer(Number.class, new myRenderer());
         
        //when using these 2 lines of code instead of the 2 lines above, the problem of
                 //wrong justified numbers occurs as well
                //tbl.setDefaultRenderer(Object.class, new DefaultTableCellRenderer());
        //tbl.setDefaultRenderer(Number.class, new DefaultTableCellRenderer());
         
         
        f.getContentPane().add( new JScrollPane( tbl ) );
        f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        f.pack();
        f.setVisible( true );
    } // Ende simpleJTableGUI
     
     
    //---1----+----2----+----3----+----4----+----5----+----6----+----7----+----8   
    public static void main(String[] args) {
            new strippedDown();
    }
     
}

 

[javice]

2) Hier kommt der zweite teil: Wenn man sortieren zuläßt, dann werden auch spalten mit zahlen alphabetisch sortiert (bsp: 1, 10, 2, 3, 31, 4). Dafür habe ich auch eine lösung im www gefunden, kriegs aber mit meinem code nicht hin. Sieht jemand den fehler (stelle ist im code im vorigen beitrag markiert)?

Ich häng hier mal noch den code von der lösung an, die ich im www gefunden habe (und die ich bei mir nicht eingebaut bekomme):

package xxx;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.RowSorter;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;

public class TableRowSorterWithHeader extends JFrame {
public TableRowSorterWithHeader() {
setDefaultCloseOperation(EXIT_ON_CLOSE);

String[] columns = { "Item", "Quantity", "Price" };

Object[][] rows = { { "Potatoes", 1, 10.98 }, { "Magazine", 2, 7.99 },
{ "Can of soup", 10, 0.89 }, { "DVD movie", 11, 39.99 } };

TableModel model = new DefaultTableModel(rows, columns){
public Class getColumnClass(int column) {
if (column >= 0 && column <= getColumnCount())
return getValueAt(0, column).getClass();
else
return Object.class;
}
};
JTable table = new JTable(model);
RowSorter<TableModel> sorter = new TableRowSorter<TableModel>(model);
table.setRowSorter(sorter);
getContentPane().add(new JScrollPane(table));

setSize(200, 150);
setVisible(true);
}

public static void main(String[] args) {
new TableRowSorterWithHeader();
}
}

 

[KrokoDiehl]

Zu 1): Es gibt ein paar Look&Feels die die Zeilen bereits alternierend einfärben (Nimbus z.B.), vielleicht ist das eine Alternative.
Ansonsten musst du bei der bestehenden Lösung im Renderer die Ausrichtung selbst setzen, z.B.:

if (value instanceof Number) {
    ((JLabel) renderer).setHorizontalAlignment(JLabel.TRAILING);
}
else {
    ((JLabel) renderer).setHorizontalAlignment(JLabel.LEADING);
}

Zu 2): Du musst deinem eigenen RowSorter noch einen Comparator für deine Zahlenspalten geben: DefaultRowSorter (Java Platform SE 7 )