/*

* @(#)ComponentTreeCellRenderer.java 1.0 11/16/08

*/

package darrylbu.renderer;

import darrylbu.model.ComponentTreeModel;

import java.awt.Color;

import java.awt.Component;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.image.BufferedImage;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.Map;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.JTree;

import javax.swing.SwingUtilities;

import javax.swing.border.EmptyBorder;

import javax.swing.tree.DefaultMutableTreeNode;

import javax.swing.tree.DefaultTreeCellRenderer;

/**

* A tree cell renderer that displays scaled replicas of Swing components

* at the nodes of the tree.

* <P>

* Extends {@link DefaultTreeCellRenderer}.

*

* @author Darryl

*/

public class ComponentTreeCellRenderer extends DefaultTreeCellRenderer {

private JTree tree;

private double scale;

private Map<JComponent, DefaultTreeCellRenderer> renderers;

private final Color selColor;

private final Color nonSelColor;

/**

* Returns a <code>ComponentTreeCellRenderer</code> suitable for rendering scaled

* snapshots of Swing components. This class is intended for use with

* a <code>JTree</code> that has a <code>ComponentTreeModel</code>.

*

* @param tree the tree of components

* @param scale the scale at which to render the components

* @see ComponentTreeModel

* @see DefaultTreeCellRenderer

*/

public ComponentTreeCellRenderer(JTree tree, double scale) {

this.tree = tree;

this.scale = scale;

setHorizontalTextPosition(LEFT);

setOpaque(true);

setBorder(new EmptyBorder(2, 0, 2, 0));

setFont(tree.getFont());

renderers = new HashMap<JComponent, DefaultTreeCellRenderer>();

selColor = backgroundSelectionColor == null ?

Color.LIGHT_GRAY :

new Color(backgroundSelectionColor.getRGB());

nonSelColor = backgroundNonSelectionColor == null ?

tree.getBackground() :

backgroundNonSelectionColor;

}

/**

* Configures the renderer based on the passed in component.

* The text and icon are set from the <code>JComponent</code> located

* as the userObject of the node and the scale, or the String returned

* by invoking <code>String.valueOf</code> on <code>value</code> if

* the object at the node is not a <code>JComponent</code>.

* <P>

* The background color is set based on the selection status and the

* icon is a scaled replica of the <code>JComponent</code>.

* <P>

* For the sake of performance, a renderer for each component is cached.

* The cache can be synchronized with the current state of the component

* hierarchy by invoking <code>refresh()</code>

*

* @see #refresh()

* @see DefaultTreeCellRenderer#getTreeCellRendererComponent(JTree,

* Object, boolean, boolean, boolean, int, boolean)

*/

@Override

public Component getTreeCellRendererComponent(JTree tree,

Object value, boolean selected, boolean expanded,

boolean leaf, int row, boolean hasFocus) {

DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;

Object userObject = node.getUserObject();

if (userObject instanceof JComponent) {

DefaultTreeCellRenderer renderer = null;

JComponent component = (JComponent) node.getUserObject();

if (!renderers.containsKey(component)) {

renderer = rendererForComponent(component, tree);

renderers.put(component, renderer);

} else {

renderer = renderers.get(component);

}

setIcon(renderer.getIcon());

setText(renderer.getText());

} else {

setIcon(null);

setText(String.valueOf(userObject));

}

setBackground(selected ? selColor : nonSelColor);

return this;

}

/**

* Creates a renderer with a scaled image of the component

*

* @param component the component

* @param tree the tree

* @return a renderer for the component

*/

private DefaultTreeCellRenderer rendererForComponent(JComponent component,

JTree tree) {

Rectangle visibleRect = component.getVisibleRect();

String className = component.getClass().getName();

DefaultTreeCellRenderer renderer = new DefaultTreeCellRenderer();

renderer.setHorizontalTextPosition(LEFT);

if (component == tree) {

renderer.setText(className + " (this tree)");

return renderer;

}

if (!component.isShowing()) {

renderer.setText(className + " (not visible)");

return renderer;

}

if (visibleRect.width * scale < 1.0 || visibleRect.height * scale < 1.0) {

renderer.setText(className + " (too small to show)");

return renderer;

}

BufferedImage bi = new BufferedImage(

(int) (visibleRect.width * scale) + 2,

(int) (visibleRect.height * scale) + 2,

BufferedImage.TYPE_INT_ARGB);

Graphics2D g2 = bi.createGraphics();

g2.setClip(visibleRect);

g2.scale(scale, scale);

Method method;

try {

method = JComponent.class.getDeclaredMethod("paintComponent",

Graphics.class);

method.setAccessible(true);

method.invoke(component, g2);

method = JComponent.class.getDeclaredMethod("paintBorder",

Graphics.class);

method.setAccessible(true);

method.invoke(component, g2);

// attempting to paint this tree on any of its ancestors causes the

// tree to repaint and leads to infinite recursion

if (SwingUtilities.isDescendingFrom(tree, component)) {

g2.setColor(textNonSelectionColor);

g2.scale(1.0 / scale, 1.0 / scale);

g2.drawString("(Children not shown)", 2, 15);

} else {

method = JComponent.class.getDeclaredMethod("paintChildren",

Graphics.class);

method.setAccessible(true);

method.invoke(component, g2);

}

// ignore checked exceptions

} catch (IllegalAccessException ignore) {

} catch (IllegalArgumentException ignore) {

} catch (InvocationTargetException ignore) {

} catch (NoSuchMethodException ignore) {

} catch (SecurityException ignore) {

}

g2.dispose();

renderer.setText(className);

renderer.setIcon(new ImageIcon(bi));

return renderer;

}

/**

* Reloads the renderer cache using the current state of the components.

*/

public void refresh() {

renderers.clear();

tree.updateUI();

}

/**

* Sets the scale at which components will be rendered. The recommended

* range of vales is 0.1 to 1.0. Setting a scale much in excess of 1.0

* may result in slow rendering of the tree.

* <P>

* Setting the scale will also refresh the tree using the current state

* of the components

*

* @param scale the scale at which to render the components

* @see #refresh

*/

public void setScale(double scale) {

if (this.scale != scale) {

this.scale = scale;

refresh();

}

}

}