mirror of
https://github.com/correl/mage.git
synced 2024-12-24 03:00:14 +00:00
[UI] RelativeLayout
This commit is contained in:
magenoxx
parent
3d03a37e2d
commit
886bd640ea
1 changed files with 856 additions and 0 deletions
|
|
@ -0,0 +1,856 @@
|
|||
package mage.client.components.layout;
|
||||
|
||||
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)
|
||||
if (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)
|
||||
{
|
||||
int space = (int)(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)
|
||||
{
|
||||
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
|
||||
+ "]";
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue