import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import javax.swing.AbstractButton;
import javax.swing.DefaultButtonModel;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JTable;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableModel;

/**
 * The package-private class javax.swing.JTable.IconRenderer, which is the
 * default renderer for columns of class Icon and ImageIcon, is known to
 * give rise to a ClassCastException when attempting to render an Icon whose
 * implementation of paintIcon(Component c, Graphics g, int x, int y) requires
 * a cast of its first parameter to a specific subclass of Component.  Many
 * icons obtained from standard JDK classes trigger this ClassCastException.
 * <P>
 * IconTableCellRenderer addresses this issue in the following manner:
 * <UL>
 * <LI> First, attempt to paint the Icon to the Graphics context of a
 * BufferedImage with a reference to itself as the Component parameter.</LI>
 * <LI> In case of a ClassCastException, the desired class is identified by
 * parsing the exception's message.  An attempt is made to instantiate a
 * Component of the desired class and use it as a valid reference.</LI>
 * <LI> In case of an InstantiationException, which is thrown if the desired
 * class is abstract, a final attempt is made to draw the icon with a
 * concretized AbstractButton as the Component parameter.</LI>
 * <LI> All else failing, the icon is rendered as a crossed rectangle of the
 * same size as the original icon, or the default icon if supplied as a
 * parameter to the constructor.</LI>
 * <P>
 * Extends DefaultTableCellRenderer
 *
 * @see DefaultTableCellRenderer
 * @author Darryl
 */
public class IconTableCellRenderer extends DefaultTableCellRenderer {

  Icon defaultIcon;
  static AbstractButton button = new AbstractButton() {
  };

  static {
    button.setModel(new DefaultButtonModel());
  }

  /**
   * Constructs an IconTableCellRenderer which will use a crossed rectangle as
   * default icon
   */
  public IconTableCellRenderer() {
  }

  /**
   * Constructs an IconTableCellRenderer which will use the supplied
   * default icon, which must be an icon that is capable of being painted
   * to any JComponent.
   *
   * @param defaultIcon
   */
  public IconTableCellRenderer(Icon defaultIcon) {
    this.defaultIcon = defaultIcon;
  }

  /**
   * @see DefaultTableCellRenderer#getTableCellRendererComponent(JTable,
   * Object, boolean, boolean, int, int)
   */
  @Override
  public Component getTableCellRendererComponent(final JTable table,
          Object value, boolean isSelected, boolean hasFocus,
          int row, int column) {
    Icon icon = (Icon) value;
    setIcon(null);
    setText("width=" + icon.getIconWidth()
            + ", height=" + icon.getIconHeight());
    setBackground(getCorrectBackground(table, isSelected));

    try {
      createIcon(icon, this);
    } catch (ClassCastException cce) {
      // some paintIcon implementations cast the component to a
      // specific subclass of JComponent
      try {
        String className = cce.getMessage();
        className = className.substring(className.lastIndexOf(" ") + 1);
        Class clazz = Class.forName(className);
        createIcon(icon, (JComponent) clazz.newInstance());
      } catch (InstantiationException ie) {
        // OceanTheme.IFIcon#paintIcon casts the component to
        // AbstractButton
        try {
          createIcon(icon, button);
        } catch (ClassCastException cce2) {
        } catch (InstantiationException ie2) {
        }
      } catch (IllegalAccessException iae) {
      } catch (ClassNotFoundException cnfe) {
      }
    } catch (InstantiationException ie3) {
    }
    if (getIcon() == null) {
      try {
        createIcon(defaultIcon == null
                ? new XIcon(icon.getIconWidth(), icon.getIconHeight())
                : defaultIcon, null);
      } catch (Exception ex) {
      }
    }
    setBackground(getCorrectBackground(table, isSelected));

    return this;
  }

  /**
   * Paints the icon to a BufferedImage for use as the renderer's Icon.
   * Also sets the height of the table row to accommodate the icon.
   *
   * @param table the JTable
   * @param row row number
   * @param icon the icon to be painted
   * @param component the component it represents
   * @throws java.lang.ClassCastException may originate in paintIcon
   * @throws java.lang.InstantiationException for a default abstract class
   */
  private void createIcon(Icon icon, JComponent component)
          throws ClassCastException, InstantiationException {
    BufferedImage image = new BufferedImage(icon.getIconWidth() + 2,
            icon.getIconHeight() + 2, BufferedImage.TYPE_INT_ARGB);
    Graphics g = image.createGraphics();
    icon.paintIcon(component, g, 2, 2);
    setIcon(new ImageIcon(image));
  }

  /**
   * Obtains the correct background as per the selection status
   *
   * @param table the JTable
   * @param isSelected selection status
   * @return the correct background Color
   */
  private Color getCorrectBackground(JTable table, boolean isSelected) {
    return isSelected ? table.getSelectionBackground() : table.getBackground();
  }

  public static void setRowHeightsForIcons(JTable table) {
    TableModel model = table.getModel();

    for (int col = 0; col < table.getColumnCount(); col++) {
      if (Icon.class.isAssignableFrom(table.getColumnClass(col))
              && table.getDefaultRenderer(Icon.class) instanceof IconTableCellRenderer) {
        for (int row = 0; row < model.getRowCount(); row++) {
          Icon icon = (Icon) model.getValueAt(row, col);
          table.setRowHeight(table.convertRowIndexToView(row),
                  Math.max(table.getRowHeight(row), icon.getIconHeight() + 2));
        }
      }
    }
  }

  /**
   * The default icon used if none is supplied.  It is drawn as a rectangle
   * with diagonals
   */
  class XIcon implements Icon {

    int width;
    int height;

    XIcon(int width, int height) {
      this.width = width;
      this.height = height;
    }

    public void paintIcon(Component c, Graphics g, int x, int y) {
      g.drawRect(x, y, width, height);
      g.drawLine(x, y, x + width, y + height);
      g.drawLine(x + width, y, x, y + height);
    }

    public int getIconWidth() {
      return width;
    }

    public int getIconHeight() {
      return height;
    }
  }
}