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

/**
 *  The DragLayout is used as a layout manager for a Container that supports
 *  random dragging of components with the Container.
 *
 *  The location of the component will not be managed by the layout manager.
 *
 *	The size of the component can be either the preferred size of the component,
 *  or the actual size of the component.
 *
 *  The preferred size of the container will calculated normally based on the
 *  actual location and size of each component.
 *
 *  A Component cannot have a location outside the bounds of the parent container.
 *  That is the x/y coordinate must be withing the Insets of the Container. If
 *  any component is outside the bounds, then the location of all components
 *  will be adjusted by the same amount.
 */
public class DragLayout implements LayoutManager, java.io.Serializable
{
	private boolean usePreferredSize;

	/**
	 *  Convenience constructor
	 */
	public DragLayout()
	{
		this(true);
	}

	/**
	 *  Create a DragLayout and indicate how the component size is determined.
	 *
	 *  @param usePreferred size see setPreferredSize() for values.
	 */
	public DragLayout(boolean usePreferredSize)
	{
		setUsePreferredSize( usePreferredSize );
	}

	/**
	 *  Set the use preferred size property
	 *
	 *  @param usePreferredSize when true, use the preferred size of the component
	 *                          in layout calculations. When false, use the size
	 *                          of the component, unless the size is 0, in which
	 *                          case use the preferred size as a default.
	 */
	public void setUsePreferredSize(boolean usePreferredSize)
	{
		this.usePreferredSize = usePreferredSize;
	}

	/**
	 *  Get the use Preferred Size property
	 *
	 *@return the use preferred size property
	 */
	public boolean isUsePreferredSize()
	{
		return usePreferredSize;
	}

	/**
	 * Adds the specified component with the specified name to the layout.
	 * @param name the name of the component
	 * @param comp the component to be added
	 */
	@Override
	public void addLayoutComponent(String name, Component comp) {}


	/**
	 * Removes the specified component from the layout.
	 *
	 * @param comp the component to be removed
	 */
	@Override
	public void removeLayoutComponent(Component component)
	{
	}

	/**
	 *	Determine the minimum size on the Container
	 *
	 *  @param	 target   the container in which to do the layout
	 *  @return	 the minimum dimensions needed to lay out the
	 *			 subcomponents of the specified container
	 */
	@Override
	public Dimension minimumLayoutSize(Container parent)
	{
		synchronized (parent.getTreeLock())
		{
			return preferredLayoutSize(parent);
		}
	}

	/**
	 *	Determine the preferred size on the Container
	 *
	 *  @param	 parent   the container in which to do the layout
	 *  @return  the preferred dimensions to lay out the
	 *	         subcomponents of the specified container
	 */
	@Override
	public Dimension preferredLayoutSize(Container parent)
	{
		synchronized (parent.getTreeLock())
		{
			return getLayoutSize(parent);
		}
	}

	/*
	 *  The calculation for minimum/preferred size is the same.
	 *
	 *  @param	 parent  the container in which to do the layout
	 */
	private Dimension getLayoutSize(Container parent)
	{
		Insets parentInsets = parent.getInsets();
		int x = parentInsets.left;
		int y = parentInsets.top;
		int width = 0;
		int height = 0;

		//  Get extreme values of the components on the container.
		//  The x/y values represent the starting point relative to the
		//  top/left of the container. The width/height values represent
		//  the bottom/right value within the container.

		for (Component component: parent.getComponents())
		{
			if (component.isVisible())
			{
				Point p = component.getLocation();
				Dimension d = getActualSize(component);
				x = Math.min(x, p.x);
				y = Math.min(y, p.y);
				width = Math.max(width, p.x + d.width);
				height = Math.max(height, p.y + d.height);
			}
		}

		// Width/Height is adjusted if any component is outside left/top edge

		if (x < parentInsets.left)
			width += parentInsets.left - x;

		if (y < parentInsets.top)
			height += parentInsets.top - y;

		//  Adjust for insets

		width += parentInsets.right;
		height += parentInsets.bottom;
		Dimension d = new Dimension(width, height);

		return d;
	}

	private Dimension getActualSize(Component component)
	{
		if (usePreferredSize)
			return component.getPreferredSize();

		//  Use the preferred size as a default when a size has not been set.

		Dimension d = component.getSize();

		if (d.width == 0 || d.height == 0)
			return component.getPreferredSize();
		else
			return d;
	}

	/**
	 * Lays out the specified container using this layout.
	 *
	 * @param	  target   the container in which to do the layout
	 */
	@Override
	public void layoutContainer(Container parent)
	{
	synchronized (parent.getTreeLock())
	{
		Insets parentInsets = parent.getInsets();

		int x = parentInsets.left;
		int y = parentInsets.top;

		//  Get x/y location of any component outside the bounds of the panel.
		//  All components will be adjust by the x/y values, if necessary.

		for (Component component: parent.getComponents())
		{
			if (component.isVisible())
			{
				Point location = component.getLocation();
				x = Math.min(x, location.x);
				y = Math.min(y, location.y);
			}
		}

		x = (x < parentInsets.left) ? parentInsets.left - x : 0;
		y = (y < parentInsets.top) ? parentInsets.top - y : 0;

		//  Set bounds of each component

		for (Component component: parent.getComponents())
		{
			if (component.isVisible())
			{
				Point p = component.getLocation();
				Dimension d = getActualSize(component);

				component.setBounds(p.x + x, p.y + y, d.width, d.height);
			}
		}
	}}

	/**
	 * Returns the string representation of this column layout's values.
	 *
	 * @return	 a string representation of this layout
	 */
	@Override
	public String toString()
	{
		return "["
			+ getClass().getName()
			+ "]";
	}
}