Later version. It was only the assert that trips up 1.4 with default
options. If you add -source 1.4 (which should have been the default if
Sun were awake), then it will compile.

A ListCellRenderer is what you want. It's pretty easy to modify the
DefaultListCellRenderer to change colour of the whole text. To just do
part of the text, you will need something a little more sophisticated.
Instead of Strings in the ListModel, use a custom class describing the
required display. The ListCellRenderer can then cast the cell data back
and paint something appropriate. I suggest keeping the renderer as
simple as possible, pushing as much logic back to the cell data model as
possible.

Tom Hawtin

For JTree you write customCellRenderers. That should be many times
faster than using HTML.  Presumably there is a similar feature for
your component.

The key is a method something like this:

 /**
   *  Returns the component used for drawing the cell.  This method
is
   *  used to configure the renderer appropriately before drawing.
   *  Associated TableModel must implement DangerTableModel.
   *
   * @param    table           the <code>JTable</code> that is asking
the
   *                           renderer to draw; can be
<code>null</code>
   * @param    value           the value of the cell to be rendered.
It is
   *                           up to the specific renderer to
interpret
   *                           and draw the value.  For example, if
   *                           <code>value</code>
   *                           is the string "true", it could be
rendered as a
   *                           string or it could be rendered as a
check
   *                           box that is checked. <code>null</code>
is a
   *                           valid value
   * @param    isSelected      true if the cell is to be rendered
with the
   *                           selection highlighted; otherwise false
   * @param    hasFocus        if true, render cell appropriately.
For
   *                           example, put a special border on the
cell, if
   *                           the cell can be edited, render in the
color used
   *                           to indicate editing
   * @param    row             the row index of the cell being drawn.
When
   *                           drawing the header, the value of
   *                           <code>row</code> is -1
   * @param    column          the column index of the cell being
drawn
   */
  public Component getTableCellRendererComponent( JTable table,
                                                  Object value,
                                                  boolean isSelected,
                                                  boolean hasFocus,
                                                  int row,
                                                  int column)
     {

     Component cell = super.getTableCellRendererComponent( table,
                                                           value,
isSelected,
                                                           hasFocus,
                                                           row,
                                                           column);

     int dangerLevel =
((DangerTableModel)(table.getModel())).getDangerLevel( row );
   

     // normal
     cell.setForeground( winAttrScheme.getForeground( dangerLevel )
);
     cell.setBackground( winAttrScheme.getBackground( dangerLevel )
);

     cell.setFont( winAttrScheme.getFont ( dangerLevel ) );
     return cell;
     }

It occurred to me that you can keep your HTML and make it go at a
reasonable speed (unless you run low on memory). The Swing cell renderer
design is based on assumptions that construction is expensive and
updating values is cheap. Clearly, even for the humble JLabel, the
second is not correct when the value is HTML. So let's cache.

The approach I have taken is to have a renderer lazily create a
conventional renderer for each index. The renderers are softly
referenced, in a naive manner. There are lots of variations with
different trade-offs. This seems to work quite well for me. It is worth
noting that the classical approach is probably going to be faster to
show the initial screen. And my class name is too cute for production use.

The only necessary addition to original program is:

        list.setCellRenderer(new DaisyListCellRenderer());

I think I shall add an improved version to my weblog.

Tom Hawtin

(Usual disclaimer.)

import java.lang.ref.Reference;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import javax.swing.*;

class DaisyListCellRenderer implements ListCellRenderer {
    private final Map<
        JList,List<Reference<ListCellRenderer>>
    > caches =
        new java.util.WeakHashMap<
            JList,List<Reference<ListCellRenderer>>
        >();
    public java.awt.Component getListCellRendererComponent(
        javax.swing.JList list,
        Object value,
        int index,
        boolean isSelected,
        boolean cellHasFocus
    ) {
        // Find cache for this list.
        List<Reference<ListCellRenderer>> cache = caches.get(list);
        if (cache == null) {
            cache =
                new java.util.ArrayList<Reference<ListCellRenderer>>();
            caches.put(list, cache);
        }

        // Cache list may need extending.
        int shortfall = index+1 - cache.size();
        if (shortfall > 0) {
            assert cache.size()+shortfall == index+1;
            cache.addAll(
                Collections.<Reference<ListCellRenderer>>nCopies(
                    shortfall, null
                )
            );
        }

        // Find renderer.
        Reference<ListCellRenderer> rendererRef = cache.get(index);
        ListCellRenderer renderer =
            rendererRef==null ? null : rendererRef.get();
        if (renderer == null) {
            renderer = createRenderer(/*...*/);
            cache.set(
                index,
                new java.lang.ref.SoftReference<ListCellRenderer>(
                    renderer
                )
            );
        }

        // Forward.
        return renderer.getListCellRendererComponent(
            list, value, index, isSelected, cellHasFocus
        );
    }
    private ListCellRenderer createRenderer(/*...*/) {
        return new javax.swing.DefaultListCellRenderer();
    }
}
class LighstSpeed {
    public static void main(String[] args) {
        java.awt.EventQueue.invokeLater(new Runnable() {
                public void run() {
                    swing();
                }
        });
    }
    private static final java.util.Random random =
        new java.util.Random();
    private static void swing() {
        assert java.awt.EventQueue.isDispatchThread();
        JFrame frame = new JFrame("LighstSpeed");
        final DefaultListModel model = new DefaultListModel();
        for (int ct=0; ct<50; ++ct) {
            model.addElement("<html>some data "+new java.util.Date());
        }
        final JList list = new JList(model);
        list.setCellRenderer(new DaisyListCellRenderer());
        frame.add(list);//new JScrollPane(list));//
        frame.pack();
        frame.setVisible(true);
        new javax.swing.Timer(1000, new ActionListener() {
                private boolean set;
                public void actionPerformed(ActionEvent event) {
                    model.setElementAt(
                        "<html>new data "+new java.util.Date(),
                        random.nextInt(model.size())
                    );
                }
        }).start();
    }
}