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.
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:
JTable:
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: