import java.awt.*;

import java.util.*;

/**

* The <code>RelativeLayout</code> class is a layout manager that

* lays out a container's components on the specified X or Y axis.

*

* Components can be layed out at their preferred size or at a

* relative size. When relative sizing is used the component must be added

* to the container using a relative size constraint, which is simply a

* Float value.

*

* The space available for relative sized components is determined by

* subtracting the preferred size of the other components from the space

* available in the container. Each component is then assigned a size

* based on its relative size value. For example:

*

* container.add(component1, new Float(1));

* container.add(component2, new Float(2));

*

* There is a total of 3 relative units. If the container has 300 pixels

* of space available then component1 will get 100 and component2, 200.

*

* It is possible that rounding errors will occur in which case you can

* specify a rounding policy to use to allocate the extra pixels.

*

* By defaults components are center aligned on the secondary axis

* however this can be changed at the container or component level.

*/

public class RelativeLayout implements LayoutManager2, java.io.Serializable

{

// Used in the constructor

public final static int X_AXIS = 0;

public final static int Y_AXIS = 1;

// See setAlignment() method

public final static float LEADING = 0.0f;

public final static float CENTER = 0.5f;

public final static float TRAILING = 1.0f;

public final static float COMPONENT = -1.0f;

// See setRoundingPolicy() method

public final static int DO_NOTHING = 0;

public final static int FIRST = 1;

public final static int LAST = 2;

public final static int LARGEST = 3;

public final static int EQUAL = 4;

private final static int MINIMUM = 0;

private final static int PREFERRED = 1;

private HashMap<Component, Float> constraints = new HashMap<Component, Float>();

/**

* The axis of the Components within the Container.

*/

private int axis;

/**

* The alignment of the Components on the other axis of the Container.

* For X-AXIS this would refer to the Y alignemt.

* For Y-AXIS this would refer to the X alignment.

*/

private float alignment = CENTER;

/**

* This is the gap (in pixels) which specifies the space between components

* It can be changed at any time and should be a non-negative integer.

*/

private int gap;

/**

* The gap (in pixels) used before the leading component and after the

* trailing component.

* It can be changed at any time and should be a non-negative integer.

*/

private int borderGap;

// Fill space available for relative components

private boolean fill = false;

// Gap to prevent the component from completely filling the space available

private int fillGap;

// Specify the rounding policy when rounding problems happen.

private int roundingPolicy = LARGEST;

/**

* Creates a relative layout with the components layed out on the X-Axis

* using the default gap

*/

public RelativeLayout()

{

this(X_AXIS, 0);

}

/**

* Creates a relative layout with the components layed out on the specified

* axis using the default gap

* <p>

* @param axis X-AXIS or Y_AXIS

*/

public RelativeLayout(int axis)

{

this(axis, 0);

}

/**

* Creates a relative layout with the components layed out on the specified

* axis using the specfied gap

* <p>

* All <code>RelativeLayout</code> constructors defer to this one.

* @param axis X-AXIS or Y_AXIS

* @param gap the gap

*/

public RelativeLayout(int axis, int gap)

{

setAxis( axis );

setGap( gap );

setBorderGap( gap );

}

/**

* Gets the layout axis.

* @return the layout axis

*/

public int getAxis()

{

return axis;

}

/**

* Sets the layout axis

* @param axis the layout axis

*/

public void setAxis(int axis)

{

if (axis != X_AXIS

&& axis != Y_AXIS)

throw new IllegalArgumentException("invalid axis specified");

this.axis = axis;

}

/**

* Gets the gap between components.

* @return the gap between components

*/

public int getGap()

{

return gap;

}

/**

* Sets the gap between components to the specified value.

* @param gap the gap between components

*/

public void setGap(int gap)

{

this.gap = gap < 0 ? 0 : gap;

}

/**

* Gets the initial gap. This gap is used before the leading component

* and after the trailing component.

*

* @return the leading/trailing gap

*/

public int getBorderGap()

{

return borderGap;

}

/**

* Sets the initial gap. This gap is used before the leading component

* and after the trailing component. The default is set to the gap.

*

* @param borderGap the leading/trailing gap

*/

public void setBorderGap(int borderGap)

{

this.borderGap = borderGap < 0 ? 0 : borderGap;

}

/**

* Gets the alignment of the components on the opposite axis.

* @return the alignment

*/

public float getAlignment()

{

return alignment;

}

/*

* Set the alignment of the component on the opposite axis.

*

* For X-AXIS this would refer to the Y alignemt.

* For Y-AXIS this would refer to the X alignment.

*

* Must be between 0.0 and 1.0, or -1. Values can be specified using:

*

* RelativeLayout.LEADING

* RelativeLayout.CENTER

* RelativeLayout.TRAILING

* RelativeLayout.COMPONENT - the getAlignemntX/Y method for the

* opposite axis will be used

*/

public void setAlignment(float alignment)

{

this.alignment = alignment > 1.0f ? 1.0f : alignment < 0.0f ? -1.0f : alignment;

}

/**

* Gets the fill property for the component size on the opposite edge.

* @return the fill property

*/

public boolean isFill()

{

return fill;

}

/**

* Change size of relative components to fill the space available

* For X-AXIS aligned components the height will be filled.

* For Y-AXIS aligned components the width will be filled.

*/

public void setFill(boolean fill)

{

this.fill = fill;

}

/**

* Gets the fill gap amount.

* @return the fill gap value

*/

public int getFillGap()

{

return fillGap;

}

/**

* Specify the number of pixels by which the fill size is decreased when

* setFill(true) has been specified.

*/

public void setFillGap(int fillGap)

{

this.fillGap = fillGap;

}

/**

* Gets the rounding policy.

* @return the rounding policy

*/

public int getRoundingPolicy()

{

return roundingPolicy;

}

/**

* Specify the rounding policy to be used when all the avialable pixels

* have not been allocated to a component.

*

* DO_NOTHING

* FIRST - extra pixels added to the first relative component

* LAST - extra pixels added to the last relative component

* LARGEST (default) - extra pixels added to the larger relative component

* EQUAL - a single pixel is added to each relative component

* (until pixels are used up)

*/

public void setRoundingPolicy(int roundingPolicy)

{

this.roundingPolicy = roundingPolicy;

}

/**

* 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 Float getConstraints(Component component)

{

return (Float)constraints.get(component);

}

/**

* Not supported

*/

public void addLayoutComponent(String name, Component component) {}

/*

* Keep track of any specified constraint for the component.

*/

public void addLayoutComponent(Component component, Object constraint)

{

if (constraint == null || constraint instanceof Float)

{

constraints.put(component, (Float)constraint);

}

else

throw new IllegalArgumentException("Constraint parameter must be of type Float");

}

/**

* Removes the specified component from the layout.

* @param comp the component to be removed

*/

public void removeLayoutComponent(Component comp) {}

/**

* Determines the preferred size of the container argument using

* this column layout.

* <p>

* The preferred width of a column layout is the largest preferred

* width of each column in the container, plus the horizontal padding

* times the number of columns minus one,

* plus the left and right insets of the target container.

* <p>

* The preferred height of a column layout is the largest preferred

* height of each row in the container, plus the vertical padding

* times the number of rows minus one,

* plus the top and bottom insets of the target container.

*

* @param target the container in which to do the layout

* @return the preferred dimensions to lay out the

* subcomponents of the specified container

* @see java.awt.RelativeLayout#minimumLayoutSize

* @see java.awt.Container#getPreferredSize()

*/

public Dimension preferredLayoutSize(Container parent)

{

synchronized (parent.getTreeLock())

{

return getLayoutSize(parent, PREFERRED);

}

}

/**

* Determines the minimum size of the container argument using this

* column layout.

* <p>

* The minimum width of a grid layout is the largest minimum width

* of each column in the container, plus the horizontal padding

* times the number of columns minus one,

* plus the left and right insets of the target container.

* <p>

* The minimum height of a column layout is the largest minimum height

* of each row in the container, plus the vertical padding

* times the number of rows minus one,

* plus the top and bottom insets of the target 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

* @see java.awt.RelativeLayout#preferredLayoutSize

* @see java.awt.Container#doLayout

*/

public Dimension minimumLayoutSize(Container parent)

{

synchronized (parent.getTreeLock())

{

return getLayoutSize(parent, MINIMUM);

}

}

/**

* Lays out the specified container using this layout.

* <p>

* This method reshapes the components in the specified target

* container in order to satisfy the constraints of the

* <code>RelativeLayout</code> object.

* <p>

* The grid layout manager determines the size of individual

* components by dividing the free space in the container into

* equal-sized portions according to the number of rows and columns

* in the layout. The container's free space equals the container's

* size minus any insets and any specified horizontal or vertical

* gap. All components in a grid layout are given the same size.

*

* @param target the container in which to do the layout

* @see java.awt.Container

* @see java.awt.Container#doLayout

*/

public void layoutContainer(Container parent)

{

synchronized (parent.getTreeLock())

{

if (axis == X_AXIS)

layoutContainerHorizontally(parent);

else

layoutContainerVertically(parent);

}

}

/*

* Lay out all the components in the Container along the X-Axis

*/

private void layoutContainerHorizontally(Container parent)

{

int components = parent.getComponentCount();

int visibleComponents = getVisibleComponents( parent );

if (components == 0) return;

// Determine space available for components using relative sizing

float relativeTotal = 0.0f;

Insets insets = parent.getInsets();

int spaceAvailable = parent.getSize().width

- insets.left

- insets.right

- ((visibleComponents - 1) * gap)

- (2 * borderGap);

for (int i = 0 ; i < components ; i++)

{

Component component = parent.getComponent(i);

if (! component.isVisible()) continue;

Float constraint = constraints.get(component);

if (constraint == null)

{

Dimension d = component.getPreferredSize();

spaceAvailable -= d.width;

}

else

{

relativeTotal += constraint.doubleValue();

}

}

// Allocate space to each component using relative sizing

int[] relativeSpace = allocateRelativeSpace(parent, spaceAvailable, relativeTotal);

// Position each component in the container

int x = insets.left + borderGap;

int y = insets.top;

int insetGap = insets.top + insets.bottom;

int parentHeight = parent.getSize().height - insetGap;

for (int i = 0 ; i < components ; i++)

{

Component component = parent.getComponent(i);

if (! component.isVisible()) continue;

if (i > 0)

x += gap;

Dimension d = component.getPreferredSize();

if (fill)

d.height = parentHeight - fillGap;

Float constraint = constraints.get(component);

if (constraint == null)

{

component.setSize( d );

int locationY = getLocationY(component, parentHeight) + y;

component.setLocation(x, locationY);

x += d.width;

}

else

{

int width = relativeSpace[i];

component.setSize(width, d.height);

int locationY = getLocationY(component, parentHeight) + y;

component.setLocation(x, locationY);

x += width;

}

}

}

/*

* Align the component on the Y-Axis

*/

private int getLocationY(Component component, int height)

{

// Use the Container alignment policy

float alignmentY = alignment;

// Override with the Component alignment

if (alignmentY == COMPONENT)

alignmentY = component.getAlignmentY();

float y = (height - component.getSize().height) * alignmentY;

return (int)y;

}

/*

* Lay out all the components in the Container along the Y-Axis

*/

private void layoutContainerVertically(Container parent)

{

int components = parent.getComponentCount();

int visibleComponents = getVisibleComponents( parent );

if (components == 0) return;

// Determine space available for components using relative sizing

float relativeTotal = 0.0f;

Insets insets = parent.getInsets();

int spaceAvailable = parent.getSize().height

- insets.top

- insets.bottom

- ((visibleComponents - 1) * gap)

- (2 * borderGap);

for (int i = 0 ; i < components ; i++)

{

Component component = parent.getComponent(i);

if (! component.isVisible()) continue;

Float constraint = constraints.get(component);

if (constraint == null)

{

Dimension d = component.getPreferredSize();

spaceAvailable -= d.height;

}

else

{

relativeTotal += constraint.doubleValue();

}

}

// Allocate space to each component using relative sizing

int[] relativeSpace = allocateRelativeSpace(parent, spaceAvailable, relativeTotal);

// Position each component in the container

int x = insets.left;

int y = insets.top + borderGap;

int insetGap = insets.left + insets.right;

int parentWidth = parent.getSize().width - insetGap;

for (int i = 0 ; i < components ; i++)

{

Component component = parent.getComponent(i);

if (! component.isVisible()) continue;

if (i > 0)

y += gap;

Dimension d = component.getPreferredSize();

if (fill)

d.width = parentWidth - fillGap;

Float constraint = constraints.get(component);

if (constraint == null)

{

component.setSize( d );

int locationX = getLocationX(component, parentWidth) + x;

component.setLocation(locationX, y);

y += d.height;

}

else

{

int height = relativeSpace[i];

component.setSize(d.width, height);

int locationX = getLocationX(component, parentWidth) + x;

component.setLocation(locationX, y);

y += height;

}

}

}

/*

* Align the component on the X-Axis

*/

private int getLocationX(Component component, int width)

{

// Use the Container alignment policy

float alignmentX = alignment;

// Override with the Component alignment

if (alignmentX == COMPONENT)

alignmentX = component.getAlignmentX();

float x = (width - component.getSize().width) * alignmentX;

return (int)x;

}

/*

* Allocate the space available to each component using relative sizing

*/

private int[] allocateRelativeSpace(Container parent, int spaceAvailable, float relativeTotal)

{

int spaceUsed = 0;

int components = parent.getComponentCount();

int[] relativeSpace = new int[components];

for (int i = 0 ; i < components ; i++)

{

relativeSpace[i] = 0;

if (relativeTotal > 0 && spaceAvailable > 0)

{

Component component = parent.getComponent(i);

Float constraint = constraints.get(component);

// if (constraint != null)

if (constraint != null && component.isVisible())

{

int space = (int)(Math.round(spaceAvailable * constraint.floatValue() / relativeTotal));

relativeSpace[i] = space;

spaceUsed += space;

}

}

}

int spaceRemaining = spaceAvailable - spaceUsed;

if (relativeTotal > 0 && spaceRemaining != 0)

adjustForRounding(relativeSpace, spaceRemaining);

return relativeSpace;

}

/*

* Because of rounding, all the space has not been allocated

* Override this method to create a custom rounding policy

*/

protected void adjustForRounding(int[] relativeSpace, int spaceRemaining)

{

switch(roundingPolicy)

{

case DO_NOTHING:

break;

case FIRST:

adjustFirst(relativeSpace, spaceRemaining);

break;

case LAST:

adjustLast(relativeSpace, spaceRemaining);

break;

case LARGEST:

adjustLargest(relativeSpace, spaceRemaining);

break;

case EQUAL:

adjustEqual(relativeSpace, spaceRemaining);

break;

default:

adjustLargest(relativeSpace, spaceRemaining);

}

}

/*

* First component using relative sizing gets all the space

*/

private void adjustFirst(int[] relativeSpace, int spaceRemaining)

{

for (int i = 0; i < relativeSpace.length; i++)

{

if (relativeSpace[i] > 0)

{

relativeSpace[i] += spaceRemaining;

break;

}

}

}

/*

* Last component using relative sizing gets all the space

*/

private void adjustLast(int[] relativeSpace, int spaceRemaining)

{

for (int i = relativeSpace.length - 1; i > 0; i--)

{

if (relativeSpace[i] > 0)

{

relativeSpace[i] += spaceRemaining;

break;

}

}

}

/*

* Largest component using relative sizing gets all the space.

* When multiple components are the same size, the last one found is used.

*/

private void adjustLargest(int[] relativeSpace, int spaceRemaining)

{

int largest = 0;

int largestSpace = 0;

for (int i = 0; i < relativeSpace.length; i++)

{

int space = relativeSpace[i];

if (space > 0)

{

if (largestSpace <= space)

{

largestSpace = space;

largest = i;

}

}

}

relativeSpace[largest] += spaceRemaining;

}

/*

* Each component using relative sizing gets 1 more pixel

* until all the space is used, starting with the first.

*/

private void adjustEqual(int[] relativeSpace, int spaceRemaining)

{

for (int i = 0; i < relativeSpace.length; i++)

{

if (relativeSpace[i] > 0)

{

if (spaceRemaining > 0)

{

relativeSpace[i]++;

spaceRemaining--;

}

else

{

relativeSpace[i]--;

spaceRemaining++;

}

if (spaceRemaining == 0)

break;

}

}

}

/*

* Determine the Preferred or Minimum layout size

*/

private Dimension getLayoutSize(Container parent, int type)

{

int width = 0;

int height = 0;

int components = parent.getComponentCount();

int visibleComponents = getVisibleComponents( parent );

for (int i = 0 ; i < components ; i++)

{

Component component = parent.getComponent(i);

if (! component.isVisible()) continue;

Dimension d = getDimension(component, type);

if (axis == X_AXIS)

{

width += d.width;

height = Math.max(height, d.height);

}

else

{

width = Math.max(width, d.width);

height += d.height;

}

}

Insets insets = parent.getInsets();

int totalGap = ((visibleComponents - 1) * gap) + (2 * borderGap);

if (axis == X_AXIS)

{

width += insets.left + insets.right + totalGap;

height += insets.top + insets.bottom;

}

else

{

width += insets.left + insets.right;

height += insets.top + insets.bottom + totalGap;

}

Dimension size = new Dimension(width, height);

return size;

}

private int getVisibleComponents(Container container)

{

int visibleComponents = 0;

for (Component component : container.getComponents())

{

if (component.isVisible())

visibleComponents++;

}

return visibleComponents;

}

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);

}

}

/**

* 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()

+ "[axis=" + axis

+ ",gap=" + gap

+ "]";

}

}