Java 类javax.swing.table.TableCellRenderer 实例源码

public TableCellRenderer getCellRenderer(int row, int column) {
  TableColumn tableColumn = getColumnModel().getColumn(column);
  TableCellRenderer renderer = tableColumn.getCellRenderer();
  if (renderer == null) {
    Class<?> c = getColumnClass(column);
    if( c.equals(Object.class) )
    {
      Object o = getValueAt(row,column);
      if( o != null )
        c = getValueAt(row,column).getClass();
    }
    renderer = getDefaultRenderer(c);
  }
  return renderer;
}

public TableCellRenderer getCellRenderer(int row, int column) {

        int modelRow = getRowSorter().convertRowIndexToModel(row);
        Double profitPercentage = (Double) getModel().getValueAt(modelRow, 12);
        String name = (String) getModel().getValueAt(modelRow, 0);
        name = name + " " + portfolio.getTicker(name);
        if (profitPercentage != null) {
            if (profitPercentage < -10.0) {
                return new CellRenderer(java.awt.Color.RED, (column != 0), name);

            } else if (profitPercentage < 10.0) {
                return new CellRenderer(java.awt.Color.YELLOW, (column != 0), name);
            }
        }
        // return super.getCellRenderer(row, column);
        return new CellRenderer(java.awt.Color.GREEN, (column != 0), (column == 0)?name:null);

    }

/** Overridden to hide the selection when not focused, and paint across the
 * selected row if focused. */
public Component prepareRenderer(TableCellRenderer renderer, int row, int col) {
    Object value = getValueAt(row, col);

    Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner();

    boolean isSelected = isSelected(row, focusOwner);

    Component result = renderer.getTableCellRendererComponent(this, value, isSelected, false, row, col);

    if( PropUtils.isNimbus ) {
        //HACK to get rid of alternate row background colors
        if( !isSelected ) {
            Color bkColor = getBackground();
            if( null != bkColor ) 
                result.setBackground( new Color( bkColor.getRGB() ) );
        }
    }

    return result;
}

@Override
public Component prepareRenderer(TableCellRenderer renderer, int row, int column) {
    boolean selected = false;
    for(int i: getSelectedRows()) {
        if(row == i) {
            selected = true;
            break;
        }
    }
    Component c = super.prepareRenderer(renderer, row, column);
    if(selected) {
        c.setBackground(getSelectionBackground());
    } else {
        c.setBackground(backgroundColorForRow(row));
    }
    return c;
}

@Override
public Component prepareRenderer(TableCellRenderer renderer, int row, int column) {
    Component c = super.prepareRenderer(renderer, row, column);
    if (getModel().hasUpdates(
            convertRowIndexToModel(row),
            convertColumnIndexToModel(column))) {

        Color color = isCellSelected(row, column) ? selectedForeground : unselectedForeground;

        if (c instanceof JCheckBox) {
            checkboxReplacement.removeAll();
            checkboxReplacement.setBorder(new LineBorder(color, borderThickness));
            checkboxReplacement.add(c);
            return checkboxReplacement;
        } else {
            c.setForeground(color);
            return c;
        }
    }
    return c;
}

/**
 * Configure the cell editor.
 * This method allows to override the configuration of cell editor when cell editing is initiated.
 * 
 * @param editor The editor component
 * @param row Editor's row
 * @param column Editor's column
 */
protected void configureTreeCellEditor( Component editor, int row, int column ) {
    if( !(editor instanceof JComponent) ) {
        return;
    }
    TreeCellEditorBorder b = new TreeCellEditorBorder();
    TreePath path = getLayoutCache().getPathForRow(convertRowIndexToModel(row));
    Object o = getValueAt(row, column);
    RenderDataProvider rdp = getRenderDataProvider();
    TableCellRenderer tcr = getDefaultRenderer(Object.class);
    if (rdp instanceof CheckRenderDataProvider && tcr instanceof DefaultOutlineCellRenderer) {
        CheckRenderDataProvider crender = (CheckRenderDataProvider) rdp;
        DefaultOutlineCellRenderer ocr = (DefaultOutlineCellRenderer) tcr;
        Object value = getValueAt(row, column);
        if (value != null && crender.isCheckable(value) && crender.isCheckEnabled(value)) {
            b.checkWidth = ocr.getTheCheckBoxWidth();
            b.checkBox = ocr.setUpCheckBox(crender, value, ocr.createCheckBox());
        }
    }
    b.icon = rdp.getIcon(o);
    b.nestingDepth = Math.max( 0, path.getPathCount() - (isRootVisible() ? 1 : 2) );
    b.isLeaf = getOutlineModel().isLeaf(o);
    b.isExpanded = getLayoutCache().isExpanded(path);

    ((JComponent)editor).setBorder(b);
}

public TableColumn addColumn(Object columnIdentifier, int width,
                             TableCellRenderer renderer,
                             TableCellEditor editor, List columnData) {
    checkDefaultTableModel();

    // Set up the model side first
    DefaultTableModel m = (DefaultTableModel)getModel();
    m.addColumn(columnIdentifier, columnData.toArray());

    // The column will have been added to the end, so the index of the
    // column in the model is the last element.
    TableColumn newColumn = new TableColumn(
            m.getColumnCount()-1, width, renderer, editor);
    super.addColumn(newColumn);
    return newColumn;
}

/**
 * Get the table header renderer for the particular column.
 * If the column is {@link ETableColumn}, check createDefaultHeaderRenderer()
 * method. If it's not overridden, use the current header renderer.
 * If it is overridden, set the current header renderer to the base
 * column's renderer. If the overridden renderer delegates to the original,
 * it will get this header renderer ({@link #headerRendererUI}).
 * @param tc The column
 * @return the renderer
 */
private TableCellRenderer getColumnHeaderRenderer(TableColumn tc) {
    if (tc instanceof ETableColumn) {
        ETableColumn eColumn = (ETableColumn) tc;
        TableCellRenderer columnHeaderRenderer;
        if (!defaultColumnHeaderRenderers.containsKey(eColumn)) {
            TableCellRenderer tcr = eColumn.createDefaultHeaderRenderer();
            if (tcr instanceof ETableColumn.ETableColumnHeaderRendererDelegate) {
                defaultColumnHeaderRenderers.put(eColumn, null);
                columnHeaderRenderer = null;
            } else {
                eColumn.setTableHeaderRendererDelegate(headerRendererUI);
                columnHeaderRenderer = tcr;
            }
        } else {
            columnHeaderRenderer = defaultColumnHeaderRenderers.get(eColumn);
        }
        if (columnHeaderRenderer != null) {
            return columnHeaderRenderer;
        } else {
            return headerRendererUI;
        }
    } else {
        return headerRendererUI;
    }
}

@Override
public Component prepareRenderer( TableCellRenderer renderer, int row, int column ) {
    SwitcherTableItem item = (SwitcherTableItem) getModel().getValueAt(row, column);

    boolean selected = row == getSelectedRow() &&
            column == getSelectedColumn() && item != null;        

    Component renComponent = super.prepareRenderer( renderer, row, column );
    if( selected && isClosable( (Item) item) ) {
        if( renComponent instanceof JLabel ) {
            String text = ((JLabel)renComponent).getText();
            if( text.endsWith(" ←") ) { //NOI18N
                text = text.substring(0, text.length()-2);
                ((JLabel)renComponent).setText(text);
            }
        }
        JPanel res = new JPanel( new BorderLayout(0, 0) );
        res.add( renComponent, BorderLayout.CENTER );
        res.add( btnClose, BorderLayout.EAST );
        res.setBackground( renComponent.getBackground() );
        return res;
    }
    return renComponent;
}

public TableCellRenderer getCellRenderer(int row, int column) {
    Object d = this.getModel().getValueAt(row, column);
    /*
     * if (d != null) return new JNCalendarCellRenderer( new
     * CalendarDate(new Integer(d.toString()).intValue(), _date.getMonth(),
     * _date.getYear()));
     */
    if (d != null)
        renderer.setDate(
            new CalendarDate(
                new Integer(d.toString()).intValue(),
                _date.getMonth(),
                _date.getYear()));
    else
        renderer.setDate(null);
    return renderer;
}

/**
 * Initializes preferred (and eventually maximum) width of a table column
 * based on the size of its header and the estimated longest value.
 *
 * @param table Table to adjust the column width for.
 * @param index Index of the column.
 * @param longValue Estimated long value for the column.
 * @param padding Number of pixes for padding.
 */
public static void initColumnWidth(JTable table, int index, Object longValue, int padding) {
    TableColumn column = table.getColumnModel().getColumn(index);

    // get preferred size of the header
    TableCellRenderer headerRenderer = column.getHeaderRenderer();
    if (headerRenderer == null) {
        headerRenderer = table.getTableHeader().getDefaultRenderer();
    }
    Component comp = headerRenderer.getTableCellRendererComponent(
            table, column.getHeaderValue(), false, false, 0, 0);
    int width = comp.getPreferredSize().width;

    // get preferred size of the long value (remeber max of the pref. size for header and long value)
    comp = table.getDefaultRenderer(table.getModel().getColumnClass(index)).getTableCellRendererComponent(
            table, longValue, false, false, 0, index);
    width = Math.max(width, comp.getPreferredSize().width) + 2 * padding;

    // set preferred width of the column
    column.setPreferredWidth(width);
    // if the column contains boolean values, the preferred width
    // should also be its max width
    if (longValue instanceof Boolean) {
        column.setMaxWidth(width);
    }
}

@Override
public Component getTableCellRendererComponent(JTable table,
                                               Object value, boolean isSelected, boolean hasFocus, int row,
                                               int column) {
    Component component = super.getTableCellRendererComponent(table,
            value, isSelected, hasFocus, row, column);
    if (value != null) {
        if (component instanceof JLabel)
            ((JLabel) component)
                    .setText(DateAttributePlugin.DATE_INSTANCE
                            .format(value));
        else {
            TableCellRenderer renderer = table
                    .getDefaultRenderer(Date.class);
            return renderer.getTableCellRendererComponent(table, value,
                    isSelected, hasFocus, row, column);
        }
    }
    return component;
}

/**Returns combobox-styled cellrenderer if a multiple choice cell is to be rendered.
 * @return cell renderer*/
@Override
public TableCellRenderer getCellRenderer(int row, int column) {
    //if this is type column, I must render it as a combo box instead of a jtextfield
    if (column == 1) {
        if (isLdEnabled()) {
            return LD_enabled_StationTypeCell;
        } else {
            return LD_disabled_StationTypeCell;
        }
    } else if (column == getColumnCount() - 1) {
        return deleteButtonCellRenderer;
    } else {
        return new DefaultTableCellRenderer();
    }
}

@Override
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
    Outline outline = (Outline) table;
    Node n = getNodeAt(outline, row);
    if (n instanceof TreeModelNode) {
        TreeModelNode tmn = (TreeModelNode) n;
        TableRendererModel trm = tmn.getModel();
        try {
            if (trm.canRenderCell(tmn.getObject(), columnID)) {
                TableCellRenderer renderer = trm.getCellRenderer(tmn.getObject(), columnID);
                if (renderer != null) {
                    return renderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
                }
            }
        } catch (UnknownTypeException ex) {
        }
    }
    // No specific renderer
    return defaultRenderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
}

public TableColumn addColumn(Object columnIdentifier, int width,
                             TableCellRenderer renderer,
                             TableCellEditor editor, List columnData) {
    checkDefaultTableModel();

    // Set up the model side first
    DefaultTableModel m = (DefaultTableModel)getModel();
    m.addColumn(columnIdentifier, columnData.toArray());

    // The column will have been added to the end, so the index of the
    // column in the model is the last element.
    TableColumn newColumn = new TableColumn(
            m.getColumnCount()-1, width, renderer, editor);
    super.addColumn(newColumn);
    return newColumn;
}

/**Returns combobox-styled cellrenderer if a multiple choice cell is to be rendered.
 * @return cell renderer*/
@Override
public TableCellRenderer getCellRenderer(int row, int column) {
    //if this is type column, I must render it as a combo box instead of a jtextfield
    if (column == 1) {
        if (LD_enabled_system) {
            return LD_enabled_StationTypeCell;
        } else {
            return LD_disabled_StationTypeCell;
        }
    } else if (column == getColumnCount() - 1) {
        return deleteButtonCellRenderer;
    } else {
        return new DefaultTableCellRenderer();
    }
}

@Override
public TableCellRenderer getCellRenderer(int row, int column) {
    if (column == 1) {
        return comboEditor.getRenderer();
    } else if (column == 5) {
        /*if distribution column contains null value, no editor must be displayed,
        as this class is a closed one (e.g. described by population)*/
        if (getValueAt(row, column - 1) != null) {
            return new ButtonCellEditor(editDistributionButton);
        } else {
            return getDefaultRenderer(String.class);
        }
    }
    //Addition of column that contains delete buttons
    if (column == 6) {
        return new ButtonCellEditor(deleteButton);
    } else {
        return getDefaultRenderer(getModel().getColumnClass(column));
    }
}

private static void packColumn(JTable table, int vColIndex, int margin) {
    DefaultTableColumnModel colModel = (DefaultTableColumnModel) table.
            getColumnModel();
    TableColumn col = colModel.getColumn(vColIndex);
    int width;            // Obtém a largura do cabeçalho da coluna
    TableCellRenderer renderer = col.getHeaderRenderer();
    if (renderer == null) {
        renderer = table.getTableHeader().getDefaultRenderer();
    }
    Component comp = renderer.getTableCellRendererComponent(
            table, col.getHeaderValue(), false, false, 0, 0);
    width = comp.getPreferredSize().width;            // Obtém a largura maxima da coluna de dados
    for (int r = 0; r < table.getRowCount(); r++) {
        renderer = table.getCellRenderer(r, vColIndex);
        comp = renderer.getTableCellRendererComponent(
                table, table.getValueAt(r, vColIndex), false, false, r,
                vColIndex);
        width = Math.max(width, comp.getPreferredSize().width);
    }
    width += 2 * margin;            // Configura a largura
    col.setPreferredWidth(width);
}

@Override
public TableCellRenderer getCellRenderer(int row, int column) {
    if (column == 0) {
        return new ColorCellEditor();
    } else if (column == 2) {
        return super.getCellRenderer(row, 1);
    } else if (column == 6) {
        /*if distribution column contains null value, no editor must be displayed,
        as this class is a closed one (e.g. described by population)*/
        if (getValueAt(row, column - 1) != null) {
            return new ButtonCellEditor(editDistributionButton);
        } else {
            return getDefaultRenderer(String.class);
        }
    }
    // Column for refercence source
    else if (column == 7) {
        return stations.getRenderer();
    } else if (column == 8) {
        return new ButtonCellEditor(deleteButton);
    } else {
        return getDefaultRenderer(getModel().getColumnClass(column));
    }
}

protected void createRenderers() {
    final TableCellRenderer boolRend = getDefaultRenderer(Boolean.class);
    setDefaultRenderer(Boolean.class, new DisabledCellRenderer() {
        private static final long serialVersionUID = 1L;

        @Override
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
            Component cbox = boolRend.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
            cbox.setEnabled(true);
            if (value == null) {
                Component disabled = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
                cbox.setBackground(disabled.getBackground());
                cbox.setEnabled(false);
            }
            return cbox;
        }
    });
}

@Override
public TableCellRenderer getCellRenderer(int row, int column) {
    if (column == 1) {
        return grayRenderer;
    } else if (column == 2) {
        return new BooleanCellRenderer();
    } else if (column == 3) {
        return grayRenderer;
    } else if (column == 4) {
        return new BooleanCellRenderer();
    } else if (column == 5) {
        return new ButtonCellEditor(editButton);
    } else if (column == 6) {
        return new DisabledButtonCellRenderer(deleteButton);
    } else {
        return super.getCellRenderer(row, column);
    }
}

@Override
public TableCellRenderer getCellRenderer(int row, int column) {
    if (column != 0) {
        return new ParamCellRenderer();
    }
    return super.getCellRenderer(row, column);
}

public Component prepareRenderer(
        TableCellRenderer renderer,
        int row,
        int column) {

    SwitcherTableItem item
            = (SwitcherTableItem) getSwitcherTableModel().getValueAt(row, column);

    boolean selected = row == getSelectedRow() &&
            column == getSelectedColumn() && item != null;

    DefaultTableCellRenderer ren = (DefaultTableCellRenderer)
    renderer.getTableCellRendererComponent(this, item,
            selected, selected, row, column);

    if (item == null) {
        // it's a filler space, we're done
        ren.setOpaque(false);
        ren.setIcon(null);
        return ren;
    }

    Icon icon = item.getIcon();
    if (icon == null ) {
        icon = nullIcon;
    }
    ren.setText(selected || item.isActive() ? stripHtml( item.getHtmlName() ) : item.getHtmlName());
    ren.setIcon(icon);
    ren.setBorder(rendererBorder);
    ren.setIconTextGap(42 - icon.getIconWidth());

    if (item.isActive()) {
        // don't use deriveFont() - see #49973 for details
        ren.setFont(new Font(getFont().getName(), Font.BOLD, getFont().getSize()));
    }

    ren.setOpaque(true);

    return ren;
}

/**
 * This method sets read write rows to be blue, and other rows to be their
 * default rendered colour.
 */
@Override
public TableCellRenderer getCellRenderer(int row, int column) {
    DefaultTableCellRenderer tcr =
        (DefaultTableCellRenderer) super.getCellRenderer(row,column);
    tcr.setToolTipText(getToolTip(row,column));
    if (defaultColor == null) {
        defaultColor = tcr.getForeground();
        editableColor = Color.blue;
        errorColor = Color.red;
        // this sometimes happens for some reason
        if (defaultColor == null) {
            return tcr;
        }
    }
    if (column != VALUE_COLUMN) {
        tcr.setForeground(defaultColor);
        return tcr;
    }
    if (isCellError(row,column)) {
        tcr.setForeground(errorColor);
    } else if (isCellEditable(row, column)) {
        tcr.setForeground(editableColor);
    } else {
        tcr.setForeground(defaultColor);
    }
    return tcr;
}

public void setTableHeader(JTableHeader tableHeader) {
    if (this.tableHeader != null) {
        this.tableHeader.removeMouseListener(mouseListener);
        TableCellRenderer defaultRenderer = this.tableHeader.getDefaultRenderer();
        if (defaultRenderer instanceof SortableHeaderRenderer) {
            this.tableHeader.setDefaultRenderer(((SortableHeaderRenderer) defaultRenderer).tableCellRenderer);
        }
    }
    this.tableHeader = tableHeader;
    if (this.tableHeader != null) {
        this.tableHeader.addMouseListener(mouseListener);
        this.tableHeader.setDefaultRenderer(
                new SortableHeaderRenderer(this.tableHeader.getDefaultRenderer()));
    }
}

/** Translate the tree column renderer */
@Override
public TableCellRenderer getCellRenderer(int row, int column) {
    TableCellRenderer result = super.getCellRenderer(row, column);
    if (isHScrollingEnabled) {
        int c = convertColumnIndexToModel(column);
        if (c == 0) {
            result = new TranslatedTableCellRenderer(this, result);
        }
    }
    return result;
}

/**
 * Calculate and return the height of the header.
 *
 * @return Header Height
 */
@SuppressWarnings("unchecked")
private int getHeaderHeight() {
    int height = 0;
    GroupableTableColumnModel columnModel = (GroupableTableColumnModel) header
            .getColumnModel();
    for (int column = 0; column < columnModel.getColumnCount(); column++) {
        TableColumn aColumn = columnModel.getColumn(column);
        TableCellRenderer renderer = aColumn.getHeaderRenderer();
        if (renderer == null) {
            renderer = header.getDefaultRenderer();
        }
        Component comp = renderer.getTableCellRendererComponent(header
                        .getTable(), aColumn.getHeaderValue(), false, false, -1,
                column);
        int cHeight = comp.getPreferredSize().height;
        Iterator iter = columnModel.getColumnGroups(aColumn);
        if (iter != null) {
            while (iter.hasNext()) {
                ColumnGroup cGroup = (ColumnGroup) iter.next();
                cHeight += cGroup.getSize(header.getTable()).height;
            }
        }
        height = Math.max(height, cHeight);
    }
    return height;
}

/** Returns a reference to the static renderer shared among all instances
 * of SheetTable */
@Override
public TableCellRenderer getCellRenderer(int row, int column) {
    if( 0 == column ) {
        TableCellRenderer res = getCustomRenderer( row );
        if( null != res )
            return res;
    }
    return getRenderer();
}

@Override
public synchronized Component prepareRenderer(TableCellRenderer renderer,
                                              int row, int column) {
    //In case we have a repaint thread that is in the process of
    //repainting an obsolete table, just ignore the call.
    //It can happen when MBean selection is switched at a very quick rate
    if(row >= getRowCount())
        return null;
    else
        return super.prepareRenderer(renderer, row, column);
}

public static void autoSizeTableColumns(JTable table) {

        TableModel  model        = table.getModel();
        TableColumn column       = null;
        Component   comp         = null;
        int         headerWidth  = 0;
        int         maxCellWidth = Integer.MIN_VALUE;
        int         cellWidth    = 0;
        TableCellRenderer headerRenderer =
            table.getTableHeader().getDefaultRenderer();

        for (int i = 0; i < table.getColumnCount(); i++) {
            column = table.getColumnModel().getColumn(i);
            comp = headerRenderer.getTableCellRendererComponent(table,
                    column.getHeaderValue(), false, false, 0, 0);
            headerWidth  = comp.getPreferredSize().width + 10;
            maxCellWidth = Integer.MIN_VALUE;

            for (int j = 0; j < Math.min(model.getRowCount(), 30); j++) {
                TableCellRenderer r = table.getCellRenderer(j, i);

                comp = r.getTableCellRendererComponent(table,
                                                       model.getValueAt(j, i),
                                                       false, false, j, i);
                cellWidth = comp.getPreferredSize().width;

                if (cellWidth >= maxCellWidth) {
                    maxCellWidth = cellWidth;
                }
            }

            column.setPreferredWidth(Math.max(headerWidth, maxCellWidth)
                                     + 10);
        }
    }

public static void autoSizeTableColumns(JTable table) {

        TableModel  model        = table.getModel();
        TableColumn column       = null;
        Component   comp         = null;
        int         headerWidth  = 0;
        int         maxCellWidth = Integer.MIN_VALUE;
        int         cellWidth    = 0;
        TableCellRenderer headerRenderer =
            table.getTableHeader().getDefaultRenderer();

        for (int i = 0; i < table.getColumnCount(); i++) {
            column = table.getColumnModel().getColumn(i);
            comp = headerRenderer.getTableCellRendererComponent(table,
                    column.getHeaderValue(), false, false, 0, 0);
            headerWidth  = comp.getPreferredSize().width + 10;
            maxCellWidth = Integer.MIN_VALUE;

            for (int j = 0; j < Math.min(model.getRowCount(), 30); j++) {
                TableCellRenderer r = table.getCellRenderer(j, i);

                comp = r.getTableCellRendererComponent(table,
                                                       model.getValueAt(j, i),
                                                       false, false, j, i);
                cellWidth = comp.getPreferredSize().width;

                if (cellWidth >= maxCellWidth) {
                    maxCellWidth = cellWidth;
                }
            }

            column.setPreferredWidth(Math.max(headerWidth, maxCellWidth)
                                     + 10);
        }
    }

/**
 * Maps {@code JTable.getCellRenderer(int, int)} through queue
 */
public TableCellRenderer getCellRenderer(final int i, final int i1) {
    return (runMapping(new MapAction<TableCellRenderer>("getCellRenderer") {
        @Override
        public TableCellRenderer map() {
            return ((JTable) getSource()).getCellRenderer(i, i1);
        }
    }));
}

@Override
public TableCellRenderer getCellRenderer(int row, int column) {
    if (column == 2) {
        return new ComboBoxCell(VarTypes);
    } else if (column == columnSizes.length - 1) {
        return new ButtonCellEditor(delVar);
    } else {
        return super.getCellRenderer(row, column);
    }
}

@Override
public TableCellRenderer getCellRenderer(int row, int column) {
    if (convertColumnIndexToModel(column) == Column.URL.ordinal()) {
        return this.urlRenderer;
    } else {
        return super.getCellRenderer(row, column);
    }
}

protected void reload() {
    CloseEvent event = new CloseEvent(this);
    CloseListener[] listeners = getCloseListeners();
    for (CloseListener listener : listeners) {
        listener.closed(event);
        removeCloseListener(listener);
    }

    loadCurrentQualifierAttributes();
    Engine engine = framework.getEngine();
    AccessRules rules = framework.getAccessRules();
    getters = new ValueGetter[attributes.size()];
    renderers = new TableCellRenderer[attributes.size()];
    values = new Object[attributes.size()];
    saveValues = new boolean[attributes.size()];
    Arrays.fill(saveValues, true);
    Arrays.fill(getters, new ValueGetter() {

        @Override
        public Object getValue(TableNode node, int index) {
            return node.getValueAt(index);
        }
    });
    for (int i = 0; i < attributes.size(); i++) {
        Attribute attr = attributes.get(i).attribute;
        AttributePlugin plugin = framework.findAttributePlugin(attr);
        if (plugin instanceof TabledAttributePlugin) {
            ValueGetter getter = ((TabledAttributePlugin) plugin)
                    .getValueGetter(attr, engine, framework, this);
            if (getter != null)
                getters[i] = getter;
        }
        renderers[i] = plugin.getTableCellRenderer(engine, rules, attr);
    }

    loadElement();
}

public void setTableHeader(JTableHeader tableHeader) {
    if (this.tableHeader != null) {
        this.tableHeader.removeMouseListener(mouseListener);
        TableCellRenderer defaultRenderer = this.tableHeader.getDefaultRenderer();
        if (defaultRenderer instanceof SortableHeaderRenderer) {
            this.tableHeader.setDefaultRenderer(((SortableHeaderRenderer) defaultRenderer).tableCellRenderer);
        }
    }
    this.tableHeader = tableHeader;
    if (this.tableHeader != null) {
        this.tableHeader.addMouseListener(mouseListener);
        this.tableHeader.setDefaultRenderer(
                new SortableHeaderRenderer(this.tableHeader.getDefaultRenderer()));
    }
}

private void init(JLabel label, String[] columns, TableSorter sorter) {
    tableModel = new PropertiesTableModel(columns);
    tableModel.addTableModelListener(this);
    if(sorter == null) {
        sorter = new TableSorter(tableModel);
    } 
    this.sorter = sorter;   
    table = new SortedTable(this.sorter);
    table.getAccessibleContext().setAccessibleName(org.openide.util.NbBundle.getMessage(PropertiesTable.class, "tableProperties.AccessibleContext.accessibleName"));
    table.getAccessibleContext().setAccessibleDescription(org.openide.util.NbBundle.getMessage(PropertiesTable.class, "tableProperties.AccessibleContext.accessibleDescription"));
    table.getTableHeader().setReorderingAllowed(false);
    TableCellRenderer cellRenderer = new PropertiesTableCellRenderer();
    table.setDefaultRenderer(String.class, cellRenderer);
    table.setRowHeight(Math.max(
            table.getRowHeight(),
            cellRenderer.getTableCellRendererComponent(table, "abc", true, true, 0, 0)//NOI18N
                        .getPreferredSize().height + 2));
    //table.setDefaultEditor(CommitOptions.class, new CommitOptionsCellEditor());
    table.getTableHeader().setReorderingAllowed(true);
    table.setRowHeight(table.getRowHeight());
    table.addAncestorListener(this);
    component = new JScrollPane(table, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
    component.setPreferredSize(new Dimension(340, 150));
    table.getAccessibleContext().setAccessibleDescription(NbBundle.getMessage(PropertiesTable.class, "ACSD_PropertiesTable")); // NOI18N        
    label.setLabelFor(table);
    setColumns(columns);
}

public static void autoSizeTableColumns(JTable table) {

        TableModel  model        = table.getModel();
        TableColumn column       = null;
        Component   comp         = null;
        int         headerWidth  = 0;
        int         maxCellWidth = Integer.MIN_VALUE;
        int         cellWidth    = 0;
        TableCellRenderer headerRenderer =
            table.getTableHeader().getDefaultRenderer();

        for (int i = 0; i < table.getColumnCount(); i++) {
            column = table.getColumnModel().getColumn(i);
            comp = headerRenderer.getTableCellRendererComponent(table,
                    column.getHeaderValue(), false, false, 0, 0);
            headerWidth  = comp.getPreferredSize().width + 10;
            maxCellWidth = Integer.MIN_VALUE;

            for (int j = 0; j < Math.min(model.getRowCount(), 30); j++) {
                TableCellRenderer r = table.getCellRenderer(j, i);

                comp = r.getTableCellRendererComponent(table,
                                                       model.getValueAt(j, i),
                                                       false, false, j, i);
                cellWidth = comp.getPreferredSize().width;

                if (cellWidth >= maxCellWidth) {
                    maxCellWidth = cellWidth;
                }
            }

            column.setPreferredWidth(Math.max(headerWidth, maxCellWidth)
                                     + 10);
        }
    }

public CollapsibleErrorTable(AbstractErrorWarningTableModel errorWarningTableModel) {
    this.errorWarningTableModel = errorWarningTableModel;
    errorTable = new JTable(errorWarningTableModel) {

        private static final long serialVersionUID = 1L;

        @Override
        public Component prepareRenderer(TableCellRenderer renderer, int row, int column) {
            // add tooltip for last column
            JComponent component = (JComponent) super.prepareRenderer(renderer, row, column);
            if (column == getColumnCount() - 1) {
                component.setToolTipText(getValueAt(row, column).toString());
            }
            return component;
        }

    };
    errorScrollPane = new JScrollPane(errorTable);
    errorWarningTableModel.addTableModelListener(new TableModelListener() {

        @Override
        public void tableChanged(TableModelEvent e) {
            update();
        }
    });
    setupGUI();
}

/**
 * Sets a custom sorting renderer, which delegates to the default L&F
 * renderer.
 */
private void setSortingRenderer() {
    if (sorter != null) {       //is null during construction
        TableCellRenderer defaultRenderer = getDefaultRenderer();
        if (!(defaultRenderer instanceof TableSorter.SortableHeaderRenderer)) {
            setDefaultRenderer(sorter.new SortableHeaderRenderer(defaultRenderer));
        }
    }
}