SynthTableUI.java

/*
 * Copyright (c) 2002, 2024, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation. Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

packagejavax.swing.plaf.synth;

importjava.awt.Color;
importjava.awt.Component;
importjava.awt.Dimension;
importjava.awt.Graphics;
importjava.awt.Point;
importjava.awt.Rectangle;
importjava.beans.PropertyChangeEvent;
importjava.beans.PropertyChangeListener;
importjava.text.DateFormat;
importjava.text.Format;
importjava.text.NumberFormat;
importjava.util.Date;

importjavax.swing.Icon;
importjavax.swing.ImageIcon;
importjavax.swing.JCheckBox;
importjavax.swing.JComponent;
importjavax.swing.JLabel;
importjavax.swing.JTable;
importjavax.swing.LookAndFeel;
importjavax.swing.border.Border;
importjavax.swing.plaf.ColorUIResource;
importjavax.swing.plaf.ComponentUI;
importjavax.swing.plaf.UIResource;
importjavax.swing.plaf.basic.BasicTableUI;
importjavax.swing.table.DefaultTableCellRenderer;
importjavax.swing.table.JTableHeader;
importjavax.swing.table.TableCellRenderer;
importjavax.swing.table.TableColumn;
importjavax.swing.table.TableColumnModel;

/**
 * Provides the Synth L&F UI delegate for
 * {@link javax.swing.JTable}.
 *
 * @author Philip Milne
 * @since 1.7
 */
publicclassSynthTableUIextendsBasicTableUI
implementsSynthUI, PropertyChangeListener {
//
// Instance Variables
//

privateSynthStylestyle;

privatebooleanuseTableColors;
privatebooleanuseUIBorder;
privateColoralternateColor; //the background color to use for cells for alternate cells

// TableCellRenderer installed on the JTable at the time we're installed,
// cached so that we can reinstall them at uninstallUI time.
privateTableCellRendererdateRenderer;
privateTableCellRenderernumberRenderer;
privateTableCellRendererdoubleRender;
privateTableCellRendererfloatRenderer;
privateTableCellRenderericonRenderer;
privateTableCellRendererimageIconRenderer;
privateTableCellRendererbooleanRenderer;
privateTableCellRendererobjectRenderer;

privatebooleanshowHorizLines;
privatebooleanshowVertLines;
//
// The installation/uninstall procedures and support
//

/**
 *
 * Constructs a {@code SynthTableUI}.
 */
publicSynthTableUI() {}

/**
 * Creates a new UI object for the given component.
 *
 * @param c component to create UI object for
 * @return the UI object
 */
publicstaticComponentUIcreateUI(JComponentc) {
returnnewSynthTableUI();
 }

/**
 * Initializes JTable properties, such as font, foreground, and background.
 * The font, foreground, and background properties are only set if their
 * current value is either null or a UIResource, other properties are set
 * if the current value is null.
 *
 * @see #installUI
 */
@Override
protectedvoidinstallDefaults() {
dateRenderer = installRendererIfPossible(Date.class, null);
numberRenderer = installRendererIfPossible(Number.class, null);
doubleRender = installRendererIfPossible(Double.class, null);
floatRenderer = installRendererIfPossible(Float.class, null);
iconRenderer = installRendererIfPossible(Icon.class, null);
imageIconRenderer = installRendererIfPossible(ImageIcon.class, null);
booleanRenderer = installRendererIfPossible(Boolean.class,
newSynthBooleanTableCellRenderer());
objectRenderer = installRendererIfPossible(Object.class,
newSynthTableCellRenderer());
updateStyle(table);
 }

privateTableCellRendererinstallRendererIfPossible(Class<?> objectClass,
TableCellRendererrenderer) {
TableCellRenderercurrentRenderer = table.getDefaultRenderer(
objectClass);
if (currentRendererinstanceofUIResource) {
table.setDefaultRenderer(objectClass, renderer);
 }
returncurrentRenderer;
 }

privatevoidupdateStyle(JTablec) {
SynthContextcontext = getContext(c, ENABLED);
SynthStyleoldStyle = style;
style = SynthLookAndFeel.updateStyle(context, this);
if (style != oldStyle) {
context.setComponentState(ENABLED | SELECTED);

Colorsbg = table.getSelectionBackground();
if (sbg == null || sbginstanceofUIResource) {
table.setSelectionBackground(style.getColor(
context, ColorType.TEXT_BACKGROUND));
 }

Colorsfg = table.getSelectionForeground();
if (sfg == null || sfginstanceofUIResource) {
table.setSelectionForeground(style.getColor(
context, ColorType.TEXT_FOREGROUND));
 }

context.setComponentState(ENABLED);

ColorgridColor = table.getGridColor();
if (gridColor == null || gridColorinstanceofUIResource) {
gridColor = (Color)style.get(context, "Table.gridColor");
if (gridColor == null) {
gridColor = style.getColor(context, ColorType.FOREGROUND);
 }
table.setGridColor(gridColor == null ? newColorUIResource(Color.GRAY) : gridColor);
 }

useTableColors = style.getBoolean(context,
"Table.rendererUseTableColors", true);
useUIBorder = style.getBoolean(context,
"Table.rendererUseUIBorder", true);

ObjectrowHeight = style.get(context, "Table.rowHeight");
if (rowHeight != null) {
LookAndFeel.installProperty(table, "rowHeight", rowHeight);
 }
showHorizLines = table.getShowHorizontalLines();
showVertLines = table.getShowVerticalLines();
booleanshowGrid = style.getBoolean(context, "Table.showGrid", true);
table.setShowGrid(showGrid);
Dimensiond = table.getIntercellSpacing();
// if (d == null || d instanceof UIResource) {
if (d != null) {
d = (Dimension)style.get(context, "Table.intercellSpacing");
 }
alternateColor = (Color)style.get(context, "Table.alternateRowColor");
if (d != null) {
table.setIntercellSpacing(d);
 }


if (oldStyle != null) {
uninstallKeyboardActions();
installKeyboardActions();
 }
 }
 }

/**
 * Attaches listeners to the JTable.
 */
@Override
protectedvoidinstallListeners() {
super.installListeners();
table.addPropertyChangeListener(this);
 }

/**
 * {@inheritDoc}
 */
@Override
protectedvoiduninstallDefaults() {
table.setDefaultRenderer(Date.class, dateRenderer);
table.setDefaultRenderer(Number.class, numberRenderer);
table.setDefaultRenderer(Double.class, doubleRender);
table.setDefaultRenderer(Float.class, floatRenderer);
table.setDefaultRenderer(Icon.class, iconRenderer);
table.setDefaultRenderer(ImageIcon.class, imageIconRenderer);
table.setDefaultRenderer(Boolean.class, booleanRenderer);
table.setDefaultRenderer(Object.class, objectRenderer);

if (table.getTransferHandler() instanceofUIResource) {
table.setTransferHandler(null);
 }
SynthContextcontext = getContext(table, ENABLED);
table.setShowHorizontalLines(showHorizLines);
table.setShowVerticalLines(showVertLines);
style.uninstallDefaults(context);
style = null;
 }

/**
 * {@inheritDoc}
 */
@Override
protectedvoiduninstallListeners() {
table.removePropertyChangeListener(this);
super.uninstallListeners();
 }

//
// SynthUI
//

/**
 * {@inheritDoc}
 */
@Override
publicSynthContextgetContext(JComponentc) {
returngetContext(c, SynthLookAndFeel.getComponentState(c));
 }

privateSynthContextgetContext(JComponentc, intstate) {
returnSynthContext.getContext(c, style, state);
 }

//
// Paint methods and support
//

/**
 * Notifies this UI delegate to repaint the specified component.
 * This method paints the component background, then calls
 * the {@link #paint(SynthContext,Graphics)} method.
 *
 * <p>In general, this method does not need to be overridden by subclasses.
 * All Look and Feel rendering code should reside in the {@code paint} method.
 *
 * @param g the {@code Graphics} object used for painting
 * @param c the component being painted
 * @see #paint(SynthContext,Graphics)
 */
@Override
publicvoidupdate(Graphicsg, JComponentc) {
SynthContextcontext = getContext(c);

SynthLookAndFeel.update(context, g);
context.getPainter().paintTableBackground(context,
g, 0, 0, c.getWidth(), c.getHeight());
paint(context, g);
 }

/**
 * {@inheritDoc}
 */
@Override
publicvoidpaintBorder(SynthContextcontext, Graphicsg, intx,
inty, intw, inth) {
context.getPainter().paintTableBorder(context, g, x, y, w, h);
 }

/**
 * Paints the specified component according to the Look and Feel.
 * <p>This method is not used by Synth Look and Feel.
 * Painting is handled by the {@link #paint(SynthContext,Graphics)} method.
 *
 * @param g the {@code Graphics} object used for painting
 * @param c the component being painted
 * @see #paint(SynthContext,Graphics)
 */
@Override
publicvoidpaint(Graphicsg, JComponentc) {
SynthContextcontext = getContext(c);

paint(context, g);
 }

/**
 * Paints the specified component.
 *
 * @param context context for the component being painted
 * @param g the {@code Graphics} object used for painting
 * @see #update(Graphics,JComponent)
 */
protectedvoidpaint(SynthContextcontext, Graphicsg) {
Rectangleclip = g.getClipBounds();

Rectanglebounds = table.getBounds();
// account for the fact that the graphics has already been translated
// into the table's bounds
bounds.x = bounds.y = 0;

if (table.getRowCount() <= 0 || table.getColumnCount() <= 0) {

paintDropLines(context, g);
return;
 }

booleanltr = table.getComponentOrientation().isLeftToRight();

PointupperLeft = clip.getLocation();

PointlowerRight = newPoint(clip.x + clip.width - 1,
clip.y + clip.height - 1);

intrMin = table.rowAtPoint(upperLeft);
intrMax = table.rowAtPoint(lowerRight);
// This should never happen (as long as our bounds intersect the clip,
// which is why we bail above if that is the case).
if (rMin == -1) {
rMin = 0;
 }
// If the table does not have enough rows to fill the view we'll get -1.
// (We could also get -1 if our bounds don't intersect the clip,
// which is why we bail above if that is the case).
// Replace this with the index of the last row.
if (rMax == -1) {
rMax = table.getRowCount()-1;
 }

intcMin = table.columnAtPoint(ltr ? upperLeft : lowerRight);
intcMax = table.columnAtPoint(ltr ? lowerRight : upperLeft);
// This should never happen.
if (cMin == -1) {
cMin = 0;
 }
// If the table does not have enough columns to fill the view we'll get -1.
// Replace this with the index of the last column.
if (cMax == -1) {
cMax = table.getColumnCount()-1;
 }

// Paint the cells.
paintCells(context, g, rMin, rMax, cMin, cMax);

// Paint the grid.
// it is important to paint the grid after the cells, otherwise the grid will be overpainted
// because in Synth cell renderers are likely to be opaque
paintGrid(context, g, rMin, rMax, cMin, cMax);

paintDropLines(context, g);
 }

privatevoidpaintDropLines(SynthContextcontext, Graphicsg) {
JTable.DropLocationloc = table.getDropLocation();
if (loc == null) {
return;
 }

Colorcolor = (Color)style.get(context, "Table.dropLineColor");
ColorshortColor = (Color)style.get(context, "Table.dropLineShortColor");
if (color == null && shortColor == null) {
return;
 }

Rectanglerect;

rect = getHDropLineRect(loc);
if (rect != null) {
intx = rect.x;
intw = rect.width;
if (color != null) {
extendRect(rect, true);
g.setColor(color);
g.fillRect(rect.x, rect.y, rect.width, rect.height);
 }
if (!loc.isInsertColumn() && shortColor != null) {
g.setColor(shortColor);
g.fillRect(x, rect.y, w, rect.height);
 }
 }

rect = getVDropLineRect(loc);
if (rect != null) {
inty = rect.y;
inth = rect.height;
if (color != null) {
extendRect(rect, false);
g.setColor(color);
g.fillRect(rect.x, rect.y, rect.width, rect.height);
 }
if (!loc.isInsertRow() && shortColor != null) {
g.setColor(shortColor);
g.fillRect(rect.x, y, rect.width, h);
 }
 }
 }

privateRectanglegetHDropLineRect(JTable.DropLocationloc) {
if (!loc.isInsertRow()) {
returnnull;
 }

introw = loc.getRow();
intcol = loc.getColumn();
if (col >= table.getColumnCount()) {
col--;
 }

Rectanglerect = table.getCellRect(row, col, true);

if (row >= table.getRowCount()) {
row--;
RectangleprevRect = table.getCellRect(row, col, true);
rect.y = prevRect.y + prevRect.height;
 }

if (rect.y == 0) {
rect.y = -1;
 } else {
rect.y -= 2;
 }

rect.height = 3;

returnrect;
 }

privateRectanglegetVDropLineRect(JTable.DropLocationloc) {
if (!loc.isInsertColumn()) {
returnnull;
 }

booleanltr = table.getComponentOrientation().isLeftToRight();
intcol = loc.getColumn();
Rectanglerect = table.getCellRect(loc.getRow(), col, true);

if (col >= table.getColumnCount()) {
col--;
rect = table.getCellRect(loc.getRow(), col, true);
if (ltr) {
rect.x = rect.x + rect.width;
 }
 } elseif (!ltr) {
rect.x = rect.x + rect.width;
 }

if (rect.x == 0) {
rect.x = -1;
 } else {
rect.x -= 2;
 }

rect.width = 3;

returnrect;
 }

privateRectangleextendRect(Rectanglerect, booleanhorizontal) {
if (rect == null) {
returnrect;
 }

if (horizontal) {
rect.x = 0;
rect.width = table.getWidth();
 } else {
rect.y = 0;

if (table.getRowCount() != 0) {
RectanglelastRect = table.getCellRect(table.getRowCount() - 1, 0, true);
rect.height = lastRect.y + lastRect.height;
 } else {
rect.height = table.getHeight();
 }
 }

returnrect;
 }

/*
 * Paints the grid lines within <I>aRect</I>, using the grid
 * color set with <I>setGridColor</I>. Paints vertical lines
 * if <code>getShowVerticalLines()</code> returns true and paints
 * horizontal lines if <code>getShowHorizontalLines()</code>
 * returns true.
 */
privatevoidpaintGrid(SynthContextcontext, Graphicsg, intrMin,
intrMax, intcMin, intcMax) {
g.setColor(table.getGridColor());

RectangleminCell = table.getCellRect(rMin, cMin, true);
RectanglemaxCell = table.getCellRect(rMax, cMax, true);
RectangledamagedArea = minCell.union( maxCell );
SynthGraphicsUtilssynthG = context.getStyle().getGraphicsUtils(
context);

if (table.getShowHorizontalLines()) {
inttableWidth = damagedArea.x + damagedArea.width;
inty = damagedArea.y;
for (introw = rMin; row <= rMax; row++) {
y += table.getRowHeight(row);
synthG.drawLine(context, "Table.grid",
g, damagedArea.x, y - 1, tableWidth - 1,y - 1);
 }
 }
if (table.getShowVerticalLines()) {
TableColumnModelcm = table.getColumnModel();
inttableHeight = damagedArea.y + damagedArea.height;
intx;
if (table.getComponentOrientation().isLeftToRight()) {
x = damagedArea.x;
for (intcolumn = cMin; column <= cMax; column++) {
intw = cm.getColumn(column).getWidth();
x += w;
synthG.drawLine(context, "Table.grid", g, x - 1, 0,
x - 1, tableHeight - 1);
 }
 } else {
x = damagedArea.x;
for (intcolumn = cMax; column >= cMin; column--) {
intw = cm.getColumn(column).getWidth();
x += w;
synthG.drawLine(context, "Table.grid", g, x - 1, 0, x - 1,
tableHeight - 1);
 }
 }
 }
 }

privateintviewIndexForColumn(TableColumnaColumn) {
TableColumnModelcm = table.getColumnModel();
for (intcolumn = 0; column < cm.getColumnCount(); column++) {
if (cm.getColumn(column) == aColumn) {
returncolumn;
 }
 }
return -1;
 }

privatevoidpaintCells(SynthContextcontext, Graphicsg, intrMin,
intrMax, intcMin, intcMax) {
JTableHeaderheader = table.getTableHeader();
TableColumndraggedColumn = (header == null) ? null : header.getDraggedColumn();

TableColumnModelcm = table.getColumnModel();
intcolumnMargin = cm.getColumnMargin();

RectanglecellRect;
TableColumnaColumn;
intcolumnWidth;
if (table.getComponentOrientation().isLeftToRight()) {
for(introw = rMin; row <= rMax; row++) {
cellRect = table.getCellRect(row, cMin, false);
for(intcolumn = cMin; column <= cMax; column++) {
aColumn = cm.getColumn(column);
columnWidth = aColumn.getWidth();
cellRect.width = columnWidth - columnMargin;
if (aColumn != draggedColumn) {
paintCell(context, g, cellRect, row, column);
 }
cellRect.x += columnWidth;
 }
 }
 } else {
for(introw = rMin; row <= rMax; row++) {
cellRect = table.getCellRect(row, cMin, false);
aColumn = cm.getColumn(cMin);
if (aColumn != draggedColumn) {
columnWidth = aColumn.getWidth();
cellRect.width = columnWidth - columnMargin;
paintCell(context, g, cellRect, row, cMin);
 }
for(intcolumn = cMin+1; column <= cMax; column++) {
aColumn = cm.getColumn(column);
columnWidth = aColumn.getWidth();
cellRect.width = columnWidth - columnMargin;
cellRect.x -= columnWidth;
if (aColumn != draggedColumn) {
paintCell(context, g, cellRect, row, column);
 }
 }
 }
 }

// Paint the dragged column if we are dragging.
if (draggedColumn != null) {
paintDraggedArea(context, g, rMin, rMax, draggedColumn, header.getDraggedDistance());
 }

// Remove any renderers that may be left in the rendererPane.
rendererPane.removeAll();
 }

privatevoidpaintDraggedArea(SynthContextcontext, Graphicsg, intrMin, intrMax, TableColumndraggedColumn, intdistance) {
intdraggedColumnIndex = viewIndexForColumn(draggedColumn);

RectangleminCell = table.getCellRect(rMin, draggedColumnIndex, true);
RectanglemaxCell = table.getCellRect(rMax, draggedColumnIndex, true);

RectanglevacatedColumnRect = minCell.union(maxCell);

// Paint a gray well in place of the moving column.
g.setColor(table.getParent().getBackground());
g.fillRect(vacatedColumnRect.x, vacatedColumnRect.y,
vacatedColumnRect.width, vacatedColumnRect.height);

// Move to the where the cell has been dragged.
vacatedColumnRect.x += distance;

// Fill the background.
g.setColor(context.getStyle().getColor(context, ColorType.BACKGROUND));
g.fillRect(vacatedColumnRect.x, vacatedColumnRect.y,
vacatedColumnRect.width, vacatedColumnRect.height);

SynthGraphicsUtilssynthG = context.getStyle().getGraphicsUtils(
context);


// Paint the vertical grid lines if necessary.
if (table.getShowVerticalLines()) {
g.setColor(table.getGridColor());
intx1 = vacatedColumnRect.x;
inty1 = vacatedColumnRect.y;
intx2 = x1 + vacatedColumnRect.width - 1;
inty2 = y1 + vacatedColumnRect.height - 1;
// Left
synthG.drawLine(context, "Table.grid", g, x1-1, y1, x1-1, y2);
// Right
synthG.drawLine(context, "Table.grid", g, x2, y1, x2, y2);
 }

for(introw = rMin; row <= rMax; row++) {
// Render the cell value
Rectangler = table.getCellRect(row, draggedColumnIndex, false);
r.x += distance;
paintCell(context, g, r, row, draggedColumnIndex);

// Paint the (lower) horizontal grid line if necessary.
if (table.getShowHorizontalLines()) {
g.setColor(table.getGridColor());
Rectanglercr = table.getCellRect(row, draggedColumnIndex, true);
rcr.x += distance;
intx1 = rcr.x;
inty1 = rcr.y;
intx2 = x1 + rcr.width - 1;
inty2 = y1 + rcr.height - 1;
synthG.drawLine(context, "Table.grid", g, x1, y2, x2, y2);
 }
 }
 }

privatevoidpaintCell(SynthContextcontext, Graphicsg,
RectanglecellRect, introw, intcolumn) {
if (table.isEditing() && table.getEditingRow()==row &&
table.getEditingColumn()==column) {
Componentcomponent = table.getEditorComponent();
component.setBounds(cellRect);
component.validate();
 }
else {
TableCellRendererrenderer = table.getCellRenderer(row, column);
Componentcomponent = table.prepareRenderer(renderer, row, column);
Colorb = component.getBackground();
if ((b == null || binstanceofUIResource
 || componentinstanceofSynthBooleanTableCellRenderer)
 && !table.isCellSelected(row, column)) {
if (alternateColor != null && row % 2 != 0) {
component.setBackground(alternateColor);
 }
 }
rendererPane.paintComponent(g, component, table, cellRect.x,
cellRect.y, cellRect.width, cellRect.height, true);
 }
 }

/**
 * {@inheritDoc}
 */
@Override
publicvoidpropertyChange(PropertyChangeEventevent) {
if (SynthLookAndFeel.shouldUpdateStyle(event)) {
updateStyle((JTable)event.getSource());
 }
 }

/**
 * The renderer installed by the UI to render the boolean data.
 */
@SuppressWarnings("serial") // Superclass is not serializable across versions
privatestaticclassSynthBooleanTableCellRendererextendsJCheckBoximplements
TableCellRenderer {
privatebooleanisRowSelected;

publicSynthBooleanTableCellRenderer() {
setHorizontalAlignment(JLabel.CENTER);
setName("Table.cellRenderer");
 }

publicComponentgetTableCellRendererComponent(
JTabletable, Objectvalue, booleanisSelected,
booleanhasFocus, introw, intcolumn) {
isRowSelected = isSelected;

if (isSelected) {
setForeground(unwrap(table.getSelectionForeground()));
setBackground(unwrap(table.getSelectionBackground()));
 } else {
setForeground(unwrap(table.getForeground()));
setBackground(unwrap(table.getBackground()));
 }

setSelected((value != null && ((Boolean)value).booleanValue()));
returnthis;
 }

privateColorunwrap(Colorc) {
if (cinstanceofUIResource) {
returnnewColor(c.getRGB());
 }
returnc;
 }

publicbooleanisOpaque() {
returnisRowSelected ? true : super.isOpaque();
 }
 }

/**
 * The {@code DefaultTableCellRenderer} installed by the UI.
 */
@SuppressWarnings("serial") // Superclass is not serializable across versions
privateclassSynthTableCellRendererextendsDefaultTableCellRenderer {
privateObjectnumberFormat;
privateObjectdateFormat;
privatebooleanopaque;

publicvoidsetOpaque(booleanisOpaque) {
opaque = isOpaque;
 }

publicbooleanisOpaque() {
returnopaque;
 }

publicStringgetName() {
Stringname = super.getName();
if (name == null) {
return"Table.cellRenderer";
 }
returnname;
 }

publicvoidsetBorder(Borderb) {
if (useUIBorder || binstanceofSynthBorder) {
super.setBorder(b);
 }
 }

publicComponentgetTableCellRendererComponent(
JTabletable, Objectvalue, booleanisSelected,
booleanhasFocus, introw, intcolumn) {
if (!useTableColors && (isSelected || hasFocus)) {
SynthLookAndFeel.setSelectedUI((SynthLabelUI)SynthLookAndFeel.
getUIOfType(getUI(), SynthLabelUI.class),
isSelected, hasFocus, table.isEnabled(), false);
 }
else {
SynthLookAndFeel.resetSelectedUI();
 }
super.getTableCellRendererComponent(table, value, isSelected,
hasFocus, row, column);

setIcon(null);
if (table != null) {
configureValue(value, table.getColumnClass(column));
 }
returnthis;
 }

privatevoidconfigureValue(Objectvalue, Class<?> columnClass) {
if (columnClass == Object.class || columnClass == null) {
setHorizontalAlignment(JLabel.LEADING);
 } elseif (columnClass == Float.class || columnClass == Double.class) {
if (numberFormat == null) {
numberFormat = NumberFormat.getInstance();
 }
setHorizontalAlignment(JLabel.TRAILING);
setText((value == null) ? "" : ((NumberFormat)numberFormat).format(value));
 }
elseif (columnClass == Number.class) {
setHorizontalAlignment(JLabel.TRAILING);
// Super will have set value.
 }
elseif (columnClass == Icon.class || columnClass == ImageIcon.class) {
setHorizontalAlignment(JLabel.CENTER);
setIcon((valueinstanceofIcon) ? (Icon)value : null);
setText("");
 }
elseif (columnClass == Date.class) {
if (dateFormat == null) {
dateFormat = DateFormat.getDateInstance();
 }
setHorizontalAlignment(JLabel.LEADING);
setText((value == null) ? "" : ((Format)dateFormat).format(value));
 }
else {
configureValue(value, columnClass.getSuperclass());
 }
 }

publicvoidpaint(Graphicsg) {
super.paint(g);
SynthLookAndFeel.resetSelectedUI();
 }
 }
}