JTable - Header Aussehen bearbeiten

hesk

Erfahrenes Mitglied
Hallo!

Ich habe eine eigene JTable-Klasse geschrieben. Diese setzt in den Header noch eine JComboBox mit welcher man die Einträge filtern kann.

Ich verwende das lookAndFeel "Nimbus".

Mein Problem ist nun, dass nicht alle Columns solch eine ComboBox haben.
Jene, welche eine haben, sollen .setVerticalAlignment( SwingConstants.TOP ); bekommen.

Hierfür setzte ich einen neuen Renderer.

Java:
DefaultTableCellHeaderRenderer headerRendererTop = new DefaultTableCellHeaderRenderer();
        headerRendererTop.setVerticalAlignment( SwingConstants.TOP );

TableColumn column = getColumnModel().getColumn( i );
                column.setHeaderRenderer( headerRendererTop );

Leider unterscheidet sich das Aussehen dieser Headers von den anderen, wo ich nichts mache. Wie kann ich quasi das default-aussehen lassen, aber trotzdem die Schrift auf TOP anordnen.

Ich poste mal den kompletten Code. Vielleicht kann jemand es kurz probieren.

Den renderer setzte ich in der Klasse JTableFilterHeader in Zeile 125-140.

Danke!


Main-Klasse:

Java:
package swing;

/* (@)JTableHeaderComboBoxDemo.java */

/*
 * Copyright 2009 Sebastian Haufe Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
 * file except in compliance with the License. You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language governing permissions and limitations under the
 * License.
 */

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.WindowConstants;


/**
 * A table header with one combo box for each column.
 *
 * @author Sebastian Haufe
 */
public class JTableHeaderComboBoxDemo
{
    private JTableFilterHeader table;

    private void initGuid()
    {
        
        String[] columnNames = { "First Name",
                                "Last Name",
                                "Sport",
                                "# of Years",
                                "Vegetarian" };

        Object[][] data = {
                           { "Kathy", "Smith",
                            "Snowboarding", new Integer( 5 ), new Boolean( false ) },
                           { "John", "Doe",
                            "Rowing", new Integer( 3 ), new Boolean( true ) },
                           { "Sue", "Black",
                            "Knitting", new Integer( 2 ), new Boolean( false ) },
                           { "Jane", "White",
                            "Speed reading", new Integer( 20 ), new Boolean( true ) },
                           { "Joe", "Brown",
                            "Pool", new Integer( 10 ), new Boolean( false ) }
        };
        
        Boolean[] filterBoxes = { true, true, true, false, false };

        table = new JTableFilterHeader( data, columnNames, filterBoxes );
        
        /* show the test frame */
        final JFrame f = new JFrame( //
                                     "Test Frame: JTableHeaderComboBoxDemo" ); //$NON-NLS-1$
        
        f.setContentPane( new JScrollPane( table ) );
        f.pack();
        f.setLocationRelativeTo( null );
        f.setDefaultCloseOperation( WindowConstants.EXIT_ON_CLOSE );
        
        try
        {
            UIManager.setLookAndFeel( "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel" );
        }
        catch ( Exception e )
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
       
        SwingUtilities.updateComponentTreeUI( f );
        
        f.setVisible( true );
        
    }

    /**
     * Test main method.
     *
     * @param args
     *            ignored
     */
    public static void main( String[] args )
    {
        JTableHeaderComboBoxDemo test = new JTableHeaderComboBoxDemo();
        test.initGuid();
    }
}

JTable:

Java:
package swing;

import java.awt.Component;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager;
import java.awt.LayoutManager2;
import java.awt.Rectangle;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JTable;
import javax.swing.RowFilter;
import javax.swing.SwingConstants;
import javax.swing.event.TableColumnModelEvent;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;

import sun.swing.table.DefaultTableCellHeaderRenderer;

/**
 * JTable mit ComboBoxes im Header welche als Filter für die Tabelle dienen<br>
 * <br>
 * Erstellt: 2011-09-02
 * @author MaRk
 */
public class JTableFilterHeader extends JTable implements ItemListener
{
    private static final long serialVersionUID = -8474574634738370571L;
    private static final String ALL_STRING = "(Alle)";

    private TableRowSorter<TableModel> tableRowSorter;
    
    /**
     * Konstruktor
     */
    public JTableFilterHeader(int numRows, int numColumns, Boolean[] filterBoxes) 
    {
        super( new DefaultTableModel( numRows, numColumns) );
        
        init( filterBoxes );
    }
    
    /**
     * Konstruktor
     */
    public JTableFilterHeader(int numRows, int numColumns, Boolean filterBoxes) 
    {
        super( new DefaultTableModel( numRows, numColumns) );
        
        Boolean[] filterBoxesArray = new Boolean[ numColumns ];
        
        for( int i = 0; i < numColumns; i ++ )
        {
            filterBoxesArray[i] = filterBoxes;
        }
        
        init( filterBoxesArray );
    }
    
    /**
     * Konstruktor
     */
    public JTableFilterHeader()
    {
        super( new DefaultTableModel() );
        
        init( null );
    }
    
    /**
     * Konstruktor
     */
    public JTableFilterHeader( Object[][] rowData, Object[] columnNames, Boolean[] filterBoxes )
    {
        super( new DefaultTableModel( rowData, columnNames) );
        
        init( filterBoxes );
    }
    
    /**
     * Konstruktor
     */
    public JTableFilterHeader( Object[][] rowData, Object[] columnNames, Boolean filterBoxes )
    {
        super( new DefaultTableModel( rowData, columnNames) );
        
        Boolean[] filterBoxesArray = new Boolean[ columnNames.length ];
        
        for( int i = 0; i < columnNames.length; i ++ )
        {
            filterBoxesArray[i] = filterBoxes;
        }
        
        init( filterBoxesArray );
    }
    
    /**
     * Initialisiert die JTable
     */
    private void init( Boolean[] filterBoxes )
    {
        tableRowSorter = new TableRowSorter<TableModel>( getModel() );
        setRowSorter( tableRowSorter );

        setTableHeader( new JXTableHeader( getColumnModel() ) );

        final JTableHeader tableHeader = getTableHeader();
        tableHeader.setLayout( new TableHeaderSouthLayout() );
        
        DefaultTableCellHeaderRenderer headerRendererTop = new DefaultTableCellHeaderRenderer();
        headerRendererTop.setVerticalAlignment( SwingConstants.TOP );
        
        // Für jede Spalte wird eine ComboBox hinzugefügt
        for ( int i = 0; i < getModel().getColumnCount(); i++ )
        {
            if( filterBoxes != null && filterBoxes[i] == true )
            {
                tableHeader.add( createComboBox( i ), Integer.valueOf( i ) );
                
                TableColumn column = getColumnModel().getColumn( i );
                column.setHeaderRenderer( headerRendererTop );
            }
        }
    }

    /**
     * Erstellt eine ComboBox. Die Items für die ComboBox sind die Inhalte der jeweiligen Spalte (columnIndex)
     * 
     * @param columnIndex
     * @return
     */
    private JComboBox createComboBox( int columnIndex )
    {
        final JComboBox comboBox = new JComboBox();
        comboBox.addItem( ALL_STRING );

        List<String> addedItemList = new ArrayList<String>();
        
        for ( int i = 0; i < getRowCount(); i++ )
        {
            if( getValueAt( i, columnIndex ) != null )
            {
                String valueString = getValueAt( i, columnIndex ).toString();
                
                // Nur wenn das Item noch nicht in der Dropdown-Liste enthalten ist wird es geadded
                if( !addedItemList.contains( valueString ) )
                {
                    comboBox.addItem( getValueAt( i, columnIndex ) );
                    addedItemList.add( valueString );
                }
            }
        }

        comboBox.setCursor( Cursor.getDefaultCursor() );
        comboBox.addItemListener( this );
        comboBox.setName( Integer.toString( columnIndex ) );

        return comboBox;
    }

    /**
     * Aufruf bei jedem change einer ComboBox
     */
    @Override
    public void itemStateChanged( ItemEvent evt )
    {
        if ( evt.getStateChange() == ItemEvent.SELECTED )
        {
            if ( evt.getSource() instanceof JComboBox )
            {
                // Die Tabelle wird nach dem aktuell ausgewählten Einträge ( jeder ComboBox ) gefiltert.
                doFilter();

                // Nach jedem Filter vorgang müssen die ComboBoxes neu befüllt werden
                // Sie werden je nach Inhalt der Tabelle befüllt
                updateComboBoxes();
            }
        }
    }
    
    /**
     * Die ComboBoxes werden upgedated
     */
    private void updateComboBoxes()
    {
        List<String> addedItemList = new ArrayList<String>();
        
        for ( int componentIndex = 0; componentIndex < getTableHeader().getComponentCount(); componentIndex++ )
        {
            if ( getTableHeader().getComponent( componentIndex ) instanceof JComboBox )
            {
                JComboBox comboBox = ( (JComboBox) getTableHeader().getComponent( componentIndex ) );
                Object selectedObject = comboBox.getSelectedItem();
                int columnIndex = Integer.parseInt( comboBox.getName() );

                // Alle Items der ComboBox entfernen
                comboBox.removeAllItems();

                // ItemListener muss entfernt werden. Ansonsten würde eine Endlosschleife entstehen
                comboBox.removeItemListener( this );
                comboBox.addItem( ALL_STRING );

                // ComboBox wird mit den Values der Tabelle befüllt
                for ( int i = 0; i < getRowCount(); i++ )
                {
                    if( getValueAt( i, columnIndex ) != null )
                    {
                        String valueString = getValueAt( i, columnIndex ).toString();
                        
                        // Nur wenn das Item noch nicht in der Dropdown-Liste enthalten ist wird es geadded
                        if( !addedItemList.contains( valueString ) )
                        {
                            comboBox.addItem( getValueAt( i, columnIndex ) );
                            addedItemList.add( valueString );
                        }
                    }
                }

                // Das vorher ausgewählte Item muss wieder gesetzt werden
                comboBox.setSelectedItem( selectedObject );

                // Der ItemListener wird wieder aktiviert
                comboBox.addItemListener( this );
            }
            
            addedItemList.clear();
        }
    }

    /**
     * Die Tabelle wird anhand der ausgewählten Items (von jeder ComboBox) gefiltert
     */
    private void doFilter()
    {
        // Die Liste wird mit der Anzahl der Columns initialisiert
        // Nur in einer Column kann eine ComboBox sein
        List<RowFilter<Object, Object>> rowFilterList = new ArrayList<RowFilter<Object, Object>>( getColumnCount() );

        for ( int column = 0; column < getTableHeader().getComponentCount(); column++ )
        {
            if ( getTableHeader().getComponent( column ) instanceof JComboBox )
            {
                JComboBox cb = ( (JComboBox) getTableHeader().getComponent( column ) );
                String selectedText = cb.getSelectedItem().toString();
                int row = Integer.parseInt( cb.getName() );

                if ( selectedText.equals( ALL_STRING ) )
                {
                    selectedText = "";
                }

                // If current expression doesn't parse, don't update.
                try
                {
                    rowFilterList.add( RowFilter.regexFilter( selectedText, row ) );
                }
                catch ( java.util.regex.PatternSyntaxException e )
                {
                    e.printStackTrace();
                }
            }
        }

        tableRowSorter.setRowFilter( RowFilter.andFilter( rowFilterList ) );
    }
    
    /**
     * Befüllt einen ColumnHeader
     * @param headerValue
     */
    public void addColumn( String headerValue, Object[] columnData, boolean filterBox )
    {
        // Hier müssenw ir das autoCreate ausschalten und die Column händisch adden
        // Falls die Methode ((DefaultTableModel)getModel()).addColumn( headerValue, columnData );
        // verwendet werden würde, dann würden alle Änderungen der anderen Columns rückgängig gemacht werden
        // Durch addColumn würde die ganze Table auf ihren default-Wert zurückgesetzt werden.
        // zb. auch das VerticalAligment der einzelnen Headers
        setAutoCreateColumnsFromModel( false );
        
        DefaultTableModel model = (DefaultTableModel)getModel();
        TableColumn columnToAdd = new TableColumn(model.getColumnCount());

        columnToAdd.setHeaderValue( headerValue );
        addColumn( columnToAdd );
        model.addColumn(headerValue.toString(), columnData);
        
        // Soll eine ComboBox als Filter eingebaut werden?
        if( filterBox )
        {
            final JTableHeader tableHeader = getTableHeader();
            
            tableHeader.add( createComboBox( getModel().getColumnCount()-1 ), Integer.valueOf( getModel().getColumnCount()-1 ) );
            
            updateComboBoxes();
        }
    }
    
    /**
     * Eine Liste von Rows wird hinzugefügt
     * @param rowList
     */
    public void addRows( LinkedList<LinkedList<Object>> rowList )
    {
        for( LinkedList<Object> row : rowList )
        {
            addRow( row );
        }
        
        updateComboBoxes();
    }
    
    /**
     * Eine Liste von Rows wird hinzugefügt
     * @param rowList
     */
    public void addRows( Object[][] rowList )
    {
        for( Object[] row : rowList )
        {
            addRow( row );
        }
        
        updateComboBoxes();
    }
    
    /**
     * Eine Row wird befüllt
     * @param rowValue
     */
    public void addRow( LinkedList<Object> rowValue )
    {
        Object[] rowValueArray = new Object[ rowValue.size() ];
        
        for( int i = 0; i < rowValue.size(); i ++ )
        {
            rowValueArray[i] = rowValue.get( i );
        }
        
        addRow( rowValueArray );
        
        updateComboBoxes();
    }
    
    /**
     * Eine Row wird befüllt
     * @param rowValue
     */
    public void addRow( Object[] rowValue )
    {
        ((DefaultTableModel)getModel()).addRow( rowValue );
        
        updateComboBoxes();
    }

    /**
     * Layout for table header. Manages components on the table header, using the component index as index in the table
     * model! Calculates the preferred size with a width of zero and a height of the maximum preferred height of all
     * components. Lays out the components in their header rectangle, using an additional margin. 
     * 
     * Durch das hinzufügen der ComboBoxes muss die Höhe des Headers angepasst werden.
     */
    private final class TableHeaderSouthLayout implements LayoutManager2, Serializable
    {
        private static final long serialVersionUID = 8709582749968401459L;

        private Insets margin = new Insets( 1, 1, 1, 1 );

        private final Map<Component, Integer> components = new HashMap<Component, Integer>();

        /**
         * Get the cell margin.
         * 
         * @return the cell margin
         */
        @SuppressWarnings("unused")
        public Insets getMargin()
        {
            return margin;
        }

        /**
         * Set the cell margin.
         * 
         * @param m
         *            the margin
         * @throws IllegalArgumentException
         *             if {@code margin} is {@code null}
         */
        @SuppressWarnings("unused")
        public void setMargin( Insets m )
        {
            if ( m == null )
            {
                throw new IllegalArgumentException( "margin not allowed null" );
            }
            this.margin = new Insets( m.top, m.left, m.bottom, m.right );
        }

        @Override
        public void layoutContainer( Container parent )
        {
            final JTableHeader th = ( (JTableHeader) parent );
            final JTable table = th.getTable();
            final int componentCount = th.getComponentCount();

            for ( int i = 0; i < componentCount; i++ )
            {
                final Component comp = th.getComponent( i );
                final Integer columnIndexObj = components.get( comp );
                final int colIndex;
                final int viewIndex;

                if ( table == null
                     || columnIndexObj == null
                     || ( colIndex = columnIndexObj.intValue() ) < 0
                     || ( viewIndex = table.convertColumnIndexToView( colIndex ) ) < 0
                     || viewIndex >= table.getColumnCount() )
                {
                    comp.setBounds( 0, 0, 0, 0 );
                }
                else
                {
                    final Rectangle rect = th.getHeaderRect( viewIndex );
                    final TableColumn draggedColumn = th.getDraggedColumn();

                    if ( draggedColumn != null && draggedColumn.getModelIndex() == colIndex )
                    {
                        rect.x += th.getDraggedDistance();
                        th.setComponentZOrder( comp, 0 );
                    }

                    rect.x += margin.left;
                    rect.y += margin.top;
                    rect.width -= margin.left + margin.right;
                    rect.height -= margin.top + margin.bottom;
                    final Dimension size = comp.getPreferredSize();

                    if ( rect.height > size.height )
                    {
                        rect.y += rect.height - size.height;
                        rect.height = size.height;
                    }

                    comp.setBounds( rect );
                }
            }
        }

        @Override
        public Dimension preferredLayoutSize( Container parent )
        {
            final JTableHeader th = ( (JTableHeader) parent );
            final JTable table = th.getTable();
            final int componentCount = th.getComponentCount();
            int h = 0;

            for ( int i = 0; i < componentCount; i++ )
            {
                final Component comp = th.getComponent( i );
                final Integer columnIndexObj = components.get( comp );
                final int colIndex;
                final int viewIndex;

                if ( table != null
                     && columnIndexObj != null
                     && ( colIndex = columnIndexObj.intValue() ) >= 0
                     && ( viewIndex = table.convertColumnIndexToView( colIndex ) ) >= 0
                     && viewIndex < table.getColumnCount() )
                {
                    h = Math.max( h, comp.getPreferredSize().height );
                }
            }

            return new Dimension( 0, margin.top + margin.bottom + h );
        }

        @Override
        public Dimension minimumLayoutSize( Container parent )
        {
            return new Dimension();
        }

        @Override
        public Dimension maximumLayoutSize( Container target )
        {
            return new Dimension();
        }

        @Override
        public void removeLayoutComponent( Component comp )
        {
            components.remove( comp );
        }

        @Override
        public void addLayoutComponent( Component comp, Object constraints )
        {
            if ( constraints instanceof Integer )
            {
                components.put( comp, (Integer) constraints );
            }
        }

        @Override
        public void addLayoutComponent( String name, Component comp )
        {
        }

        @Override
        public float getLayoutAlignmentX( Container target )
        {
            return 0.5f;
        }

        @Override
        public float getLayoutAlignmentY( Container target )
        {
            return 0.5f;
        }

        @Override
        public void invalidateLayout( Container target )
        {
        }
    }

    /**
     * Extended table header, adding the preferred height of the layout to its preferred height and revalidates when the
     * dragged column is released. 
     * 
     * Durch das hinzufügen der ComboBoxes im Header muss die Headersize(durch {@link TableHeaderSouthLayout}) erhöht werden. 
     * JXTableHeader stellt sicher, dass die Höhe auch beim verschieben der Spalten gleich bleibt.
     */
    private class JXTableHeader extends JTableHeader
    {
        private static final long serialVersionUID = -4435249644348771055L;

        JXTableHeader( TableColumnModel cm )
        {
            super( cm );
        }

        @Override
        public Dimension getPreferredSize()
        {
            final Dimension size = super.getPreferredSize();
            final LayoutManager layout = getLayout();

            if ( layout != null )
            {
                size.height += layout.preferredLayoutSize( this ).height;
            }

            return size;
        }

        @Override
        public void columnMoved( TableColumnModelEvent e )
        {
            super.columnMoved( e );

            if ( getDraggedColumn() != null )
            {
                revalidate();
                repaint();
            }
        }

        @Override
        public void setDraggedColumn( TableColumn column )
        {
            super.setDraggedColumn( column );

            if ( column == null )
            {
                revalidate();
                repaint();
            }
        }
    }

}
 
Zuletzt bearbeitet:
Verwende bitte [code=java]CODE[/code] - Tags da diese durch Syntaxhighlightning die lesbarkeit verbessern.

ps : bitte kein re-Post ... es gibt einen EDIT Button
 
Habe das Beispiel vereinfacht.
Ich hätte gern das die 2 Spalte den selben Header hat wie die anderen(mouseover-effekt, aussehen, etc). Nur möchte ich halt pro Header einen anderen Aligment festlegen.

Java:
package swing;

import java.awt.Color;
import java.awt.Component;
import java.awt.Font;

import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.Icon;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.WindowConstants;
import javax.swing.border.Border;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellRenderer;

public class JTableHeaderTests
{
    class TestHeaderRenderer extends JPanel implements TableCellRenderer
    {
        private TableCellRenderer mWrappedRenderer;
        
        public TestHeaderRenderer(TableCellRenderer pWrappedRenderer) 
        {
            mWrappedRenderer = pWrappedRenderer;
            
            setBorder( headerBorder );
            setLayout( new BoxLayout( this, BoxLayout.Y_AXIS ) );
            setOpaque( true );
            setAlignmentX( horizontalAlignment );
            setAlignmentY( verticalAlignment );

            this.background = UIManager.getColor( "TableHeader.background" );
            this.foreground = UIManager.getColor( "TableHeader.foreground" );
        }

        // Implementation of TableCellRenderer interface
        public Component getTableCellRendererComponent( JTable table, Object value,
                                                        boolean isSelected, boolean hasFocus, int row, int column )
        {
            removeAll();
            invalidate();

            if ( value == null )
            {
                // Do nothing if no value
                return this;
            }

            // Set the foreground and background colors
            // from the table header if they are not set
            if ( table != null )
            {
                JTableHeader header = table.getTableHeader();
                if ( header != null )
                {
                    if ( foreground == null )
                    {
                        super.setForeground( header.getForeground() );
                    }

                    if ( background == null )
                    {
                        super.setBackground( header.getBackground() );
                    }
                }
            }

            Object[] values;
            int length;
            if ( value instanceof Object[] )
            {
                // Input is an array - use it
                values = (Object[]) value;
            }
            else
            {
                // Not an array - turn it into one
                values = new Object[ 1 ];
                values[0] = value;
            }
            length = values.length;

            // Configure each row of the header using
            // a separate JLabel. If a given row is
            // a JComponent, add it directly..
            for ( int i = 0; i < length; i++ )
            {
                Object thisRow = values[i];

                if ( thisRow instanceof JComponent )
                {
                    add( (JComponent) thisRow );
                }
                else
                {
                    JLabel l = new JLabel();
                    l.setAlignmentX( alignmentX );
                    l.setText( thisRow == null ? "" : thisRow.toString() );
                    add( l );
                }
            }

            return this;
        }

        protected int verticalAlignment = SwingConstants.TOP;

        protected int horizontalAlignment = SwingConstants.RIGHT;

        protected float alignmentX= (float) 0.5;

        // These attributes may be explicitly set
        // They are defaulted to the colors and attributes
        // of the table header
        protected Color foreground;

        protected Color background;

        // These attributes have fixed defaults
        protected Border headerBorder = UIManager.getBorder( "TableHeader.cellBorder" );

        protected Font font = UIManager.getFont( "TableHeader.font" );
    }
    
    private void initGuid()
    {
        
        String[] columnNames = { "First Name",
                                "Last Name",
                                "Sport",
                                "# of Years",
                                "Vegetarian" };

        Object[][] data = {
                           { "Kathy", "Smith",
                            "Snowboarding", new Integer( 5 ), new Boolean( false ) },
                           { "John", "Doe",
                            "Rowing", new Integer( 3 ), new Boolean( true ) },
                           { "Sue", "Black",
                            "Knitting", new Integer( 2 ), new Boolean( false ) },
                           { "Jane", "White",
                            "Speed reading", new Integer( 20 ), new Boolean( true ) },
                           { "Joe", "Brown",
                            "Pool", new Integer( 10 ), new Boolean( false ) }
        };
        
        JTable table = new JTable(data, columnNames);
        
        TestHeaderRenderer headerRenderer = new TestHeaderRenderer( table.getTableHeader().getDefaultRenderer() );
        
        headerRenderer.setBackground( UIManager.getColor( "TableHeader.background" ) );
        headerRenderer.setForeground( UIManager.getColor( "TableHeader.foreground" ) );
        
        table.getColumnModel().getColumn( 1 ).setHeaderRenderer( headerRenderer );
        
        
        final JFrame f = new JFrame( "Test Frame: JTableHeaderComboBoxDemo" );
        
        f.setContentPane( new JScrollPane( table ) );
        f.pack();
        f.setLocationRelativeTo( null );
        f.setDefaultCloseOperation( WindowConstants.EXIT_ON_CLOSE );
        
        try
        {
            UIManager.setLookAndFeel( "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel" );
        }
        catch ( Exception e )
        {
            e.printStackTrace();
        }
       
        SwingUtilities.updateComponentTreeUI( f );
        
        f.setVisible( true );
        
    }

    /**
     * Test main method.
     *
     * @param args
     *            ignored
     */
    public static void main( String[] args )
    {
        JTableHeaderTests test = new JTableHeaderTests();
        test.initGuid();
    }
}
 
Habe jetzt alle soweit geschafft.
Das letzte Problem:

Wenn ich das LookAndFeel vorher setzte, passt alles. Nur wenn ich es nachher setzte(oder zur Laufzeit verändere) dann verändern sich die Headers nicht.

Meinen eigenen TableCellRenderer muss man noch irgendwie sagen, dass er update soll.
Weiß jemand wie?

Hier der Code:

Java:
package swing;

import java.awt.Component;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager;
import java.awt.LayoutManager2;
import java.awt.Rectangle;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.RowFilter;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.WindowConstants;
import javax.swing.event.TableColumnModelEvent;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;

public class JTableHeaderTests implements ItemListener
{
    private static final String ALL_STRING = "(Alle)";
    
    private JTable table;
    private TableRowSorter<TableModel> tableRowSorter;
    
    /**
     * Aufruf bei jedem change einer ComboBox
     */
    @Override
    public void itemStateChanged( ItemEvent evt )
    {
        if ( evt.getStateChange() == ItemEvent.SELECTED )
        {
            if ( evt.getSource() instanceof JComboBox )
            {
                // Die Tabelle wird nach dem aktuell ausgewählten Einträge ( jeder ComboBox ) gefiltert.
                doFilter();

                // Nach jedem Filter vorgang müssen die ComboBoxes neu befüllt werden
                // Sie werden je nach Inhalt der Tabelle befüllt
                updateComboBoxes();
            }
        }
    }
    
    /**
     * Die ComboBoxes werden upgedated
     */
    private void updateComboBoxes()
    {
        List<String> addedItemList = new ArrayList<String>();

        for ( int componentIndex = 0; componentIndex < table.getTableHeader().getComponentCount(); componentIndex++ )
        {
            if ( table.getTableHeader().getComponent( componentIndex ) instanceof JComboBox )
            {
                JComboBox comboBox = ( (JComboBox) table.getTableHeader().getComponent( componentIndex ) );
                Object selectedObject = comboBox.getSelectedItem();
                int columnIndex = Integer.parseInt( comboBox.getName() );

                // Alle Items der ComboBox entfernen
                comboBox.removeAllItems();

                // ItemListener muss entfernt werden. Ansonsten würde eine Endlosschleife entstehen
                comboBox.removeItemListener( this );
                comboBox.addItem( ALL_STRING );

                // ComboBox wird mit den Values der Tabelle befüllt
                for ( int i = 0; i < table.getRowCount(); i++ )
                {
                    if ( table.getValueAt( i, columnIndex ) != null )
                    {
                        String valueString = table.getValueAt( i, columnIndex ).toString();

                        // Nur wenn das Item noch nicht in der Dropdown-Liste enthalten ist wird es geadded
                        if ( !addedItemList.contains( valueString ) )
                        {
                            comboBox.addItem( table.getValueAt( i, columnIndex ) );
                            addedItemList.add( valueString );
                        }
                    }
                }

                // Das vorher ausgewählte Item muss wieder gesetzt werden
                comboBox.setSelectedItem( selectedObject );

                // Der ItemListener wird wieder aktiviert
                comboBox.addItemListener( this );
            }

            addedItemList.clear();
        }
    }

    /**
     * Die Tabelle wird anhand der ausgewählten Items (von jeder ComboBox) gefiltert
     */
    private void doFilter()
    {
        // Die Liste wird mit der Anzahl der Columns initialisiert
        // Nur in einer Column kann eine ComboBox sein
        List<RowFilter<Object, Object>> rowFilterList = new ArrayList<RowFilter<Object, Object>>( table.getColumnCount() );

        for ( int column = 0; column < table.getTableHeader().getComponentCount(); column++ )
        {
            if ( table.getTableHeader().getComponent( column ) instanceof JComboBox )
            {
                JComboBox cb = ( (JComboBox) table.getTableHeader().getComponent( column ) );
                String selectedText = cb.getSelectedItem().toString();
                int row = Integer.parseInt( cb.getName() );

                if ( selectedText.equals( ALL_STRING ) )
                {
                    selectedText = "";
                }

                // If current expression doesn't parse, don't update.
                try
                {
                    rowFilterList.add( RowFilter.regexFilter( selectedText, row ) );
                }
                catch ( java.util.regex.PatternSyntaxException e )
                {
                    e.printStackTrace();
                }
            }
        }

        tableRowSorter.setRowFilter( RowFilter.andFilter( rowFilterList ) );
    }
    
    public class FilterHeaderRenderer implements TableCellRenderer
    {

        private TableCellRenderer mWrappedRenderer;
        private int horizontalAlignment;
        private int verticalAlignment;
        
        public FilterHeaderRenderer( TableCellRenderer pWrappedRenderer, int horizontalAlignment, int verticalAlignment )
        {
            mWrappedRenderer = pWrappedRenderer;
            this.horizontalAlignment = horizontalAlignment;
            this.verticalAlignment = verticalAlignment;
        }

        public Component getTableCellRendererComponent( JTable pTable, Object pValue, boolean pIsSelected,
                                                        boolean pHasFocus, int pRow, int pColumn )
        {

            // Use the wrapped renderer
            Component renderedComponent = mWrappedRenderer.getTableCellRendererComponent( pTable, pValue, pIsSelected, pHasFocus,
                                                                                          pRow, pColumn );

            // Set the alignment
            ( (JLabel) renderedComponent ).setHorizontalAlignment( horizontalAlignment );
            ( (JLabel) renderedComponent ).setVerticalAlignment( verticalAlignment );
            
            ( (JLabel) renderedComponent ).setAlignmentY( (float) 10.5 );

            return renderedComponent;
        }
    }
    
    private void initGuid()
    {
        
        String[] columnNames = { "First Name",
                                "Last Name",
                                "Sport",
                                "# of Years",
                                "Vegetarian" };

        Object[][] data = {
                           { "Kathy", "Smith",
                            "Snowboarding", new Integer( 5 ), new Boolean( false ) },
                           { "John", "Doe",
                            "Rowing", new Integer( 3 ), new Boolean( true ) },
                           { "Sue", "Black",
                            "Knitting", new Integer( 2 ), new Boolean( false ) },
                           { "Jane", "White",
                            "Speed reading", new Integer( 20 ), new Boolean( true ) },
                           { "Joe", "Brown",
                            "Pool", new Integer( 10 ), new Boolean( false ) }
        };
        
        table = new JTable(data, columnNames);
        table.setTableHeader( new JXTableHeader( table.getColumnModel() ) );

        tableRowSorter = new TableRowSorter<TableModel>( table.getModel() );
        table.setRowSorter( tableRowSorter );
        
        final JTableHeader tableHeader = table.getTableHeader();
        tableHeader.setLayout( new TableHeaderSouthLayout() );
        
        FilterHeaderRenderer headerRendererBox = new FilterHeaderRenderer(table.getTableHeader().getDefaultRenderer(), SwingConstants.CENTER, SwingConstants.TOP );
        FilterHeaderRenderer headerRendererNoBox = new FilterHeaderRenderer(table.getTableHeader().getDefaultRenderer(), SwingConstants.CENTER, SwingConstants.CENTER );
        
        for ( int i = 0; i < table.getModel().getColumnCount(); i++ )
        {
            if( i == 0 || i == 1 )
            {
                tableHeader.add( createComboBox( i, table ), Integer.valueOf( i ) );
                table.getColumnModel().getColumn( i ).setHeaderRenderer( headerRendererBox );    
            }
            else
            {
                table.getColumnModel().getColumn( i ).setHeaderRenderer( headerRendererNoBox );    
            }
        }
        
        final JFrame f = new JFrame( "Test Frame: JTableHeaderComboBoxDemo" );
        
        f.setContentPane( new JScrollPane( table ) );
        f.pack();
        f.setLocationRelativeTo( null );
        f.setDefaultCloseOperation( WindowConstants.EXIT_ON_CLOSE );
        
        try
        {
            UIManager.setLookAndFeel( "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel" );
            //UIManager.setLookAndFeel( UIManager.getSystemLookAndFeelClassName() );
        }
        catch ( Exception e )
        {
            e.printStackTrace();
        }
        
        SwingUtilities.updateComponentTreeUI( f );
        
        f.setVisible( true );
        
    }

    /**
     * Test main method.
     *
     * @param args
     *            ignored
     */
    public static void main( String[] args )
    {
//        try
//        {
//            UIManager.setLookAndFeel( "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel" );
//            //UIManager.setLookAndFeel( UIManager.getSystemLookAndFeelClassName() );
//        }
//        catch ( Exception e )
//        {
//            e.printStackTrace();
//        }
        
        JTableHeaderTests test = new JTableHeaderTests();
        test.initGuid();
    }
    
    /**
     * Erstellt eine ComboBox. Die Items für die ComboBox sind die Inhalte der jeweiligen Spalte (columnIndex)
     * 
     * @param columnIndex
     * @return
     */
    private JComboBox createComboBox( int columnIndex, JTable table )
    {
        final JComboBox comboBox = new JComboBox();
        comboBox.addItem( ALL_STRING );

        List<String> addedItemList = new ArrayList<String>();

        for ( int i = 0; i < table.getRowCount(); i++ )
        {
            if ( table.getValueAt( i, columnIndex ) != null )
            {
                String valueString = table.getValueAt( i, columnIndex ).toString();

                // Nur wenn das Item noch nicht in der Dropdown-Liste enthalten ist wird es geadded
                if ( !addedItemList.contains( valueString ) )
                {
                    comboBox.addItem( table.getValueAt( i, columnIndex ) );
                    addedItemList.add( valueString );
                }
            }
        }

        comboBox.setCursor( Cursor.getDefaultCursor() );
        comboBox.addItemListener( this );
        comboBox.setName( Integer.toString( columnIndex ) );

        return comboBox;
    }
    
    /**
     * Layout for table header. Manages components on the table header, using the component index as index in the table
     * model! Calculates the preferred size with a width of zero and a height of the maximum preferred height of all
     * components. Lays out the components in their header rectangle, using an additional margin. Durch das hinzufügen
     * der ComboBoxes muss die Höhe des Headers angepasst werden.
     */
    private final class TableHeaderSouthLayout implements LayoutManager2, Serializable
    {
        private static final long serialVersionUID = 8709582749968401459L;

        private Insets margin = new Insets( 1, 1, 1, 1 );

        private final Map<Component, Integer> components = new HashMap<Component, Integer>();

        /**
         * Get the cell margin.
         * 
         * @return the cell margin
         */
        @SuppressWarnings("unused")
        public Insets getMargin()
        {
            return margin;
        }

        /**
         * Set the cell margin.
         * 
         * @param m
         *            the margin
         * @throws IllegalArgumentException
         *             if {@code margin} is {@code null}
         */
        @SuppressWarnings("unused")
        public void setMargin( Insets m )
        {
            if ( m == null )
            {
                throw new IllegalArgumentException( "margin not allowed null" );
            }
            this.margin = new Insets( m.top, m.left, m.bottom, m.right );
        }

        @Override
        public void layoutContainer( Container parent )
        {
            final JTableHeader th = ( (JTableHeader) parent );
            final JTable table = th.getTable();
            final int componentCount = th.getComponentCount();

            for ( int i = 0; i < componentCount; i++ )
            {
                final Component comp = th.getComponent( i );
                final Integer columnIndexObj = components.get( comp );
                final int colIndex;
                final int viewIndex;

                if ( table == null
                     || columnIndexObj == null
                     || ( colIndex = columnIndexObj.intValue() ) < 0
                     || ( viewIndex = table.convertColumnIndexToView( colIndex ) ) < 0
                     || viewIndex >= table.getColumnCount() )
                {
                    comp.setBounds( 0, 0, 0, 0 );
                }
                else
                {
                    final Rectangle rect = th.getHeaderRect( viewIndex );
                    final TableColumn draggedColumn = th.getDraggedColumn();

                    if ( draggedColumn != null && draggedColumn.getModelIndex() == colIndex )
                    {
                        rect.x += th.getDraggedDistance();
                        th.setComponentZOrder( comp, 0 );
                    }

                    rect.x += margin.left;
                    rect.y += margin.top;
                    rect.width -= margin.left + margin.right;
                    rect.height -= margin.top + margin.bottom;
                    final Dimension size = comp.getPreferredSize();

                    if ( rect.height > size.height )
                    {
                        rect.y += rect.height - size.height;
                        rect.height = size.height;
                    }

                    comp.setBounds( rect );
                }
            }
        }

        @Override
        public Dimension preferredLayoutSize( Container parent )
        {
            final JTableHeader th = ( (JTableHeader) parent );
            final JTable table = th.getTable();
            final int componentCount = th.getComponentCount();
            int h = 0;

            for ( int i = 0; i < componentCount; i++ )
            {
                final Component comp = th.getComponent( i );
                final Integer columnIndexObj = components.get( comp );
                final int colIndex;
                final int viewIndex;

                if ( table != null
                     && columnIndexObj != null
                     && ( colIndex = columnIndexObj.intValue() ) >= 0
                     && ( viewIndex = table.convertColumnIndexToView( colIndex ) ) >= 0
                     && viewIndex < table.getColumnCount() )
                {
                    h = Math.max( h, comp.getPreferredSize().height );
                }
            }

            return new Dimension( 0, margin.top + margin.bottom + h );
        }

        @Override
        public Dimension minimumLayoutSize( Container parent )
        {
            return new Dimension();
        }

        @Override
        public Dimension maximumLayoutSize( Container target )
        {
            return new Dimension();
        }

        @Override
        public void removeLayoutComponent( Component comp )
        {
            components.remove( comp );
        }

        @Override
        public void addLayoutComponent( Component comp, Object constraints )
        {
            if ( constraints instanceof Integer )
            {
                components.put( comp, (Integer) constraints );
            }
        }

        @Override
        public void addLayoutComponent( String name, Component comp )
        {
        }

        @Override
        public float getLayoutAlignmentX( Container target )
        {
            return 0.5f;
        }

        @Override
        public float getLayoutAlignmentY( Container target )
        {
            return 0.5f;
        }

        @Override
        public void invalidateLayout( Container target )
        {
        }
    }

    /**
     * Extended table header, adding the preferred height of the layout to its preferred height and revalidates when the
     * dragged column is released. Durch das hinzufügen der ComboBoxes im Header muss die Headersize(durch
     * {@link TableHeaderSouthLayout}) erhöht werden. JXTableHeader stellt sicher, dass die Höhe auch beim verschieben
     * der Spalten gleich bleibt.
     */
    private class JXTableHeader extends JTableHeader
    {
        private static final long serialVersionUID = -4435249644348771055L;

        JXTableHeader( TableColumnModel cm )
        {
            super( cm );
        }

        @Override
        public Dimension getPreferredSize()
        {
            final Dimension size = super.getPreferredSize();
            final LayoutManager layout = getLayout();

            if ( layout != null )
            {
                size.height += layout.preferredLayoutSize( this ).height;
            }

            return size;
        }

        @Override
        public void columnMoved( TableColumnModelEvent e )
        {
            super.columnMoved( e );

            if ( getDraggedColumn() != null )
            {
                revalidate();
                repaint();
            }
        }

        @Override
        public void setDraggedColumn( TableColumn column )
        {
            super.setDraggedColumn( column );

            if ( column == null )
            {
                revalidate();
                repaint();
            }
        }
    }
}
 
Wenn ich den folgenden Renderer(mit updateUI) nehme, dann wird der Header richtig gewechselt bei L&F. Nur beim Nimbus-L&F gibt es kein mouseOver-Effekt.

Bitte um Hilfe:)

Java:
public class FilterHeaderRenderer extends JLabel implements TableCellRenderer
    {

        private TableCellRenderer mWrappedRenderer;
        private int horizontalAlignment;
        private int verticalAlignment;
        
        public FilterHeaderRenderer( TableCellRenderer pWrappedRenderer, int horizontalAlignment, int verticalAlignment )
        {
            mWrappedRenderer = pWrappedRenderer;
            this.horizontalAlignment = horizontalAlignment;
            this.verticalAlignment = verticalAlignment;
        }

        public Component getTableCellRendererComponent( JTable pTable, Object pValue, boolean pIsSelected,
                                                        boolean pHasFocus, int pRow, int pColumn )
        {

            // Use the wrapped renderer
            Component renderedComponent = mWrappedRenderer.getTableCellRendererComponent( pTable, pValue, pIsSelected, pHasFocus,
                                                                                          pRow, pColumn );

            // Set the alignment
            ( (JLabel) renderedComponent ).setHorizontalAlignment( horizontalAlignment );
            ( (JLabel) renderedComponent ).setVerticalAlignment( verticalAlignment );
            
            ( (JLabel) renderedComponent ).setAlignmentY( (float) 10.5 );

            return renderedComponent;
        }
        
        public void updateUI()
        {
            JTableHeader header = new JTableHeader();
            mWrappedRenderer = header.getDefaultRenderer();
        }
    }
 
Zurück