import java.awt.*;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;

/**
 *  The <code>OverlapLayout</code> class is a layout manager that
 *  lays out a container's components in an overlapping fashion. A
 *	component can be painted "above" or "below" the previous component
 *  in the container.
 *
 *  Like the GridLayout, each component is sized to the largest width and
 *  height of any component in the container. The amount of overlap is
 *  controlled by specifying the overlap postion of each component. You can
 *  simulate, left-to-right, right-to-left, top-to-bottom, bottom-to-top and
 *  diagonal layouts. As well you can "stack" components completely on top of
 *  one another. In this case the components are sized to the space available
 *  in the container.
 *
 *  A main usage for this layout might be in the creation of "card games". A
 *  few features have been added that might be handy in these cases:
 *
 *  a) a "popup" feature - when a component is selected in can "popup" from
 *     its regular location so it visibly stands out. To accomplish this some
 *     extra space must be reserved in the container for the popup. This is
 *     done by using the setPopupInsets method which allow you to control the
 *     popup direction. In addition you can add/remove a simple constraint to
 *     the component. POP_UP will popup the component. POP_DOWN or null
 *     will paint the component in its regular location.
 *  b) when a component is made "invisible" you can reserve its location in the
 *     container so all the other components don't shift.
 *
 *  Note: this layout is achieved by changing the ZOrder of components in the
 *  container. It will not work for all components as some compnents will
 *  always paint themselves on the top of others. This seems to happen with
 *  components like JButton as rollover effects are painted when a mouse moves
 *  over the components.
 */
public class OverlapLayout implements LayoutManager2, java.io.Serializable
{
	public static Boolean POP_UP = Boolean.TRUE;
	public static Boolean POP_DOWN = Boolean.FALSE;

	private static final int PREFERRED = 0;
	private static final int MINIMUM = 1;

	//  Indicates how a component is painted
	private boolean overlapAbove;

	private Point overlapPosition;

	//  Reserve space for invisible components in the Container
	private boolean includeInvisible = true;

	//  Reserve extra space so a component can "popup"
	private Insets popupInsets = new Insets(0, 0, 0, 0);

	//  Track original order in which the components where added
	private List<Component> components = new ArrayList<Component>();

	//  Track a constraint added to a component
	private HashMap<Component, Boolean> constraints = new HashMap<Component, Boolean>();

	/**
	 *  Convenience constructor to provide for "stacking" of components. Each
	 *	component will be stacked above the previous component and sized to
	 *  fill the space of the parent container.
	 */
	public OverlapLayout()
	{
		this( new Point(0, 0) );
	}

	/**
	 *	Convenience constructor. Each component will overlap above the previous
	 *  component.
	 *
	 *  @param overlapPosition a Point defining the relative amount of overlap
	 */
	public OverlapLayout(Point overlapPosition)
	{
		this(overlapPosition, true);
	}

	/**
	 *  Create an overlapping layout.
	 *
	 *  @param overlapPosition a Point defining the relative amount of overlap
	 *  @param overlayAbove when true components are painted above the previous
	 *                      component, otherwise they are painted below.
	 */
	public OverlapLayout(Point overlapPosition, boolean overlapAbove)
	{
		setOverlapPosition( overlapPosition );
		this.overlapAbove = overlapAbove;
	}

	/**
	 *  When components are overlapped above the ZOrder of each component is
	 *  changed resulting in the components position in the container being
	 *  changed. For example when you add a component to the end of the
	 *  container it will be moved to the beginning. If you then try to access
	 *  the component using Component.componentAt(), you will get the first
	 *  component, not the last.
	 *
	 *  This method will convert the index to you access the proper component.
	 *
	 *  @param index the index to convert
	 */
	public int convertIndex(int index)
	{
		if (overlapAbove)
			return components.size() - index - 1;
		else
			return index;
	}

	/**
	 *  Get the include invisible property
	 *
	 *  @returns the include invisible property
	 */
	public boolean isIncludeInvisible()
	{
		return includeInvisible;
	}

	/**
	 *	Controls whether spaces should reserved for invisible components in
	 *  the container
	 *
	 *  @param includeInvisible  when true, space is reserved otherwise the
	 *                           component is not included in the layout sizing
	 */
	public void	setIncludeInvisible(boolean includeInvisible)
	{
		this.includeInvisible = includeInvisible;
	}

	/**
	 *  Get the overlapping position of each component
	 *
	 *  @returns the Point representing the overlapped position
	 */
	public Point getOverlapPosition()
	{
		return overlapPosition;
	}

	/**
	 *  Specify the position where the overlapped component should be painted.
	 *
	 *  @param overlapPosition the position where the next component is painted
	 */
	public void setOverlapPosition(Point overlapPosition)
	{
		this.overlapPosition = overlapPosition;
	}

	/**
	 *	Get the popup insets
	 *
	 *  @returns the popup insets
	 */
	public Insets getPopupInsets()
	{
		return popupInsets;
	}

	/**
	 *	Define extra space to be reserved by the container. This will allow
	 *  components to be "popped up" if required. Generally space would only be
	 *  reserved on one side of the container.
	 *
	 *  @param popupInsets Insets defining extra space for a particular side
	 *                     of the container.
	 */
	public void setPopupInsets(Insets popupInsets)
	{
		this.popupInsets = popupInsets;
	}

	/**
	 *  Gets the constraints for the specified component.
	 *
	 *  @param   component the component to be queried
	 *  @return  the constraint for the specified component, or null
	 *           if component is null or is not present in this layout
     */
    public Boolean getConstraints(Component component)
    {
    	return (Boolean)constraints.get(component);
    }

	/**
	 * 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
	 */
	public void addLayoutComponent(String name, Component comp) {}

	/*
	 *	Keep track of any specified constraint for the component.
	 */
	public void addLayoutComponent(Component component, Object constraint)
	{
		//  Support simple Boolean constraint for painting a Component in
		//  its "popped up" position

		if (constraint == null)
		{
			constraints.remove(component);
		}
		else if (constraint instanceof Boolean)
		{
			constraints.put(component, (Boolean)constraint);
		}
		else
		{
			String message = "Constraint parameter must be of type Boolean";
			throw new IllegalArgumentException( message );
		}

		//  Keep a separate List of components in the order in which they where
		//  added to the Container. This makes layout easier. First we need
		//  to find the position the component was added at. We can't depend
		//  on the component order in the parent Container as changing the
		//  Z-Order also changes the order in the Container

		if (!components.contains(component))
		{
			Container parent = component.getParent();
			int size = parent.getComponentCount();

			for (int i = 0 ; i < size ; i++)
			{
				Component c = parent.getComponent(i);

				if (c == component)
				{
					components.add(i, component);

					//  Need to change Z-Order so added components are painted
					//  above the previously added component.

					if (overlapAbove)
					{
						parent.setComponentZOrder(component, size - i - 1);
					}

		  	  		break;
				}
			}
		}
	}

	/**
	 * Removes the specified component from the layout.
	 *
	 * @param comp the component to be removed
	 */
	public void removeLayoutComponent(Component component)
	{
		components.remove( component );
		constraints.remove( 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
	 */
	public Dimension minimumLayoutSize(Container parent)
	{
		synchronized (parent.getTreeLock())
		{
			return getLayoutSize(parent, MINIMUM);
		}
	}

	/**
	 *	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
	 */
	public Dimension preferredLayoutSize(Container parent)
	{
		synchronized (parent.getTreeLock())
		{
			return getLayoutSize(parent, PREFERRED);
		}
	}

	/*
	 *  The calculation for minimum/preferred size it the same. The only
	 *  difference is the need to use the minimum or preferred size of the
	 *  component in the calculation.
	 *
	 *  @param	 parent  the container in which to do the layout
	 *  @param	 type    either MINIMUM or PREFERRED
	 */
	private Dimension getLayoutSize(Container parent, int type)
	{
		int visibleComponents = 0;
		int width = 0;
		int height = 0;

		//  All components will be resized to the maximum dimension

		for (Component component: components)
		{
			if (component.isVisible()
			||  includeInvisible)
			{
				Dimension size = getDimension(component, type);
				width = Math.max(size.width, width);
				height = Math.max(size.height, height);
				visibleComponents++;
			}
		}

		if (visibleComponents == 0)
			return new Dimension(0, 0);

		//  Adjust size for each overlapping component

		visibleComponents--;
		width  += visibleComponents * Math.abs(overlapPosition.x);
		height += visibleComponents * Math.abs(overlapPosition.y);

		//  Adjust for parent Container and popup insets

		Insets parentInsets = parent.getInsets();
		width += parentInsets.left + parentInsets.right;
		height += parentInsets.top + parentInsets.bottom;

		width += popupInsets.left + popupInsets.right;
		height += popupInsets.top + popupInsets.bottom;

		return new Dimension(width, height);
	}

	private Dimension getDimension(Component component, int type)
	{
		switch (type)
		{
			case PREFERRED: return component.getPreferredSize();
			case MINIMUM: return component.getMinimumSize();
			default: return new Dimension(0, 0);
		}
	}

	/**
	 * Lays out the specified container using this layout.
	 * <p>
	 *
	 * @param	  target   the container in which to do the layout
	 */
	public void layoutContainer(Container parent)
	{
	synchronized (parent.getTreeLock())
	{
		int size = components.size();

		if (size == 0) return;

		//  Determine the maximum size of the components

		Dimension maximumSize = new Dimension();

		for (Component component: components)
		{
			if (component.isVisible()
			||  includeInvisible)
			{
				Dimension preferred = component.getPreferredSize();
				maximumSize.width = Math.max(preferred.width, maximumSize.width);
				maximumSize.height = Math.max(preferred.height, maximumSize.height);
			}
		}

		//  Determine location of first component

		Point location = new Point(0, 0);
		Insets parentInsets = parent.getInsets();

		//  Layout right-to-left, else left-to-right

		if (overlapPosition.x < 0)
			location.x = parent.getWidth() - maximumSize.width - parentInsets.right - popupInsets.right;
		else
			location.x = parentInsets.left + popupInsets.left;

		//  Layout bottom-to-top, else top-to-bottom

		if (overlapPosition.y < 0)
			location.y = parent.getHeight() - maximumSize.height - parentInsets.bottom - popupInsets.bottom;
		else
			location.y = parentInsets.top + popupInsets.top;

		//  Set the size and location for each component

		for (int i = 0 ; i < size ; i++)
		{
			Component component = components.get(i);

			if (component.isVisible()
			||  includeInvisible)
			{
				//  When components are "stacked" resize each component to fill
				//  the size of the parent container

				if (overlapPosition.x == 0 && overlapPosition.y == 0)
				{
					int width = parent.getWidth() - parentInsets.left - parentInsets.right;
					int height = parent.getHeight() - parentInsets.top - parentInsets.bottom;
					component.setSize(width, height);
				}
				else  //  resize each component to be the same size
				{
					component.setSize( maximumSize );
				}

				//  Set location of the component

				int x = location.x;
				int y = location.y;

				//  Adjust location when component is "popped up"

				Boolean constraint = constraints.get(component);

				if (constraint != null
				&&  constraint == Boolean.TRUE)
				{
					x += popupInsets.right - popupInsets.left;
					y += popupInsets.bottom - popupInsets.top;
				}

				component.setLocation(x, y);

				//  Calculate location of next component using the overlap offsets

				location.x += overlapPosition.x;
				location.y += overlapPosition.y;
			}
		}
	}}

	/**
	 * There is no maximum.
	 */
	public Dimension maximumLayoutSize(Container target)
	{
		return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
	}

	/**
	 * Returns the alignment along the x axis.  Use center alignment.
	 */
	public float getLayoutAlignmentX(Container parent)
	{
		return 0.5f;
	}

	/**
	 * Returns the alignment along the y axis.  Use center alignment.
	 */
	public float getLayoutAlignmentY(Container parent)
	{
		return 0.5f;
	}

	/**
	 * Invalidates the layout, indicating that if the layout manager
	 * has cached information it should be discarded.
	 */
	public void invalidateLayout(Container target)
	{
		// remove constraints here?
	}

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