import java.awt.*;
import java.beans.*;
import javax.swing.*;

/**
 *	The FormScroller will ensure that when a component gains focus it will
 *  always be visible within the viewport of the scrollpane.
 */
public class FormScroller implements PropertyChangeListener
{
	public enum Type
	{
		COMPONENT,
		PARENT,
		CHILD;
	}

	private JScrollPane scrollPane;
	private Type type;
	private Insets scrollInsets = new Insets(0, 0, 0, 0);
	private boolean scrollingEnabled;

	private Point lastLocation = new Point();

	/**
	 *  Convenience constructor that set the scroll Type to COMPONENT
	 */
	public FormScroller(JScrollPane scrollPane)
	{
		this(scrollPane, Type.COMPONENT);
	}

	/**
	 *   Create a FormScroller for the specified scroll Type
	 */
	public FormScroller(JScrollPane scrollPane, Type type)
	{
		this.scrollPane = scrollPane;
		setType( type );
		setScrollingEnabled( true );
	}

	/**
	 *  Get the Type of scrolling to be attempted by the scroller
	 */
	public Type getType()
	{
		return type;
	}

	/**
	 *  Set the Type of scrolling to be done by the scroller
	 *
	 *  Type.COMPONENT - the focused component should be visible in the viewport.
	 *  Type.PARENT - the parent Container of the focus component should be
	 *                visible in the viewport. If the parent Container does not
	 *                fit completely then use Type.COMPONENT.
	 *  Type.CHILD - the child Contaier of the viewport view component which
	 *               contains the focused component should be visible in the
	 *               viewport. If the child Container does not fit completely
	 *               then use Type.PARENT.
	 *
	 *  @param Type - controls scrolling of the viewport (values given above)
	 */
	public void setType(Type type)
	{
		this.type = type;
	}

	/**
	 *  Get the scroll insets.
	 *
	 *	@return the scroll insets
	 */
	public Insets getScrollInsets()
	{
		return scrollInsets;
	}

	/**
	 *  Set the scroll insets. The scroller will attempt to leave a gap between
     *  the scrolled Container and the edge of the scrollpane.
     *
     *  @paran scrollInsets - Insets for the gap for each edge of the scrollpane
	 */
	public void setScrollInsets(Insets scrollInsets)
	{
		this.scrollInsets = scrollInsets;
	}

	/**
	 *
	 */
	 public boolean isScrollingEnabled()
	 {
	 	return scrollingEnabled;
	 }

	/**
	 *  Enable automatic scrolling on the form.
	 *
	 *  @param scrollingEnabled enable/disable scrolling
	 */
	public void setScrollingEnabled(boolean scrollingEnabled)
	{
		this.scrollingEnabled = scrollingEnabled;

		KeyboardFocusManager.getCurrentKeyboardFocusManager()
			.removePropertyChangeListener("permanentFocusOwner", this);

		if (scrollingEnabled)
		{
			KeyboardFocusManager.getCurrentKeyboardFocusManager()
				.addPropertyChangeListener("permanentFocusOwner", this);
		}
	}

	@Override
	public void propertyChange(PropertyChangeEvent evt)
	{
		Component component = (Component) evt.getNewValue();

		if (component == null) return;

		//  Make sure the component with focus is in the viewport

		JComponent view = (JComponent)scrollPane.getViewport().getView();

		if (! SwingUtilities.isDescendingFrom(component, view)) return;

		//  Scroll the viewport

		Rectangle bounds = determineScrollBounds(component, view);
		view.scrollRectToVisible(bounds);
	}

	/**
	 *  Determine the bounds that must fit into the viewport of the scrollpane
	 *
	 *  @param component the component that currently has focus
	 *  @param view the component added to the viewport of the scrollpane
	 *  @return a Rectangle representing the bounds to be scrolled
	 */
	protected Rectangle determineScrollBounds(Component component, JComponent view)
	{
		//  Determine the scroll bounds based on the scroll Type

		Rectangle bounds = null;

		if (type == Type.COMPONENT)
			bounds = determineComponentBounds(component, view);
		else if (type == Type.PARENT)
			bounds = determineParentBounds(component, view);
		else
			bounds = determineChildBounds(component, view);

		//  Adjust bounds to take scroll insets into consideration

		Point location = component.getLocation();
		location = SwingUtilities.convertPoint(component.getParent(), location, view);

		if (location.x < lastLocation.x)
			bounds.x -= scrollInsets.left;
		else
			bounds.width += scrollInsets.right;

		if (location.y < lastLocation.y)
			bounds.y -= scrollInsets.top;
		else
			bounds.height += scrollInsets.bottom;

		lastLocation = location;

		return bounds;
	}

	private Rectangle determineComponentBounds(Component component, JComponent view)
	{
		// Use the bounds of the focused component

		Rectangle bounds = component.getBounds();
		bounds = SwingUtilities.convertRectangle(component.getParent(), bounds, view);

		return bounds;
	}

	private Rectangle determineParentBounds(Component component, JComponent view)
	{
/*
		//  When focusing on a component in a tabbed pane attempt to keep the tabs
		//  in the viewport by treating the tabbed pane as the component with focus

		Component tabbedPane = (Component)SwingUtilities.getAncestorOfClass(JTabbedPane.class, component);

		if (tabbedPane != null)
			component = tabbedPane;
*/
		//  Use the bounds of the parent Container

		Component parent = component.getParent();
		Rectangle bounds = parent.getBounds();
		bounds = SwingUtilities.convertRectangle(parent.getParent(), bounds, view);

		//  Make sure the Container will fit into the viewport

		if (rectangleFits(bounds))
			return bounds;
		else
			return determineComponentBounds(component, view);
	}

	private Rectangle determineChildBounds(Component component, JComponent view)
	{
		//  Search each child Component of the view to find the Container which
		//  contains the component which current has focus

		Component child = null;

		for (Component c: view.getComponents())
		{
			if (SwingUtilities.isDescendingFrom(component, c))
			{
				child = c;
				break;
			}
		}

		Rectangle bounds = child.getBounds();
		bounds = SwingUtilities.convertRectangle(child.getParent(), bounds, view);

		//  Make sure this container will fit into the viewport

		if (rectangleFits(bounds))
			return bounds;
		else
			return determineParentBounds(component, view);
	}

	private boolean rectangleFits(Rectangle bounds)
	{
		Dimension viewport = scrollPane.getViewport().getSize();

		if (bounds.width > viewport.width || bounds.height > viewport.height)
			return false;
		else
			return true;
	}
}