A DESCRIPTION OF THE REQUEST :
The TransparentLayout is a straightforward implementation that solves the core problem of Java GUI creation by infering the appropriate resizing behavior, freeing the developers from the complexities of layout managers.

It implements the LayoutManager2 interface to support a brand new "Free Design" paradigm.

The solution can be used either in command-line tools or in graphical ones.


JUSTIFICATION :
Current Java layout managers are too tricky. Even simple GUIs need a
lot of boilerplate code.


EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
Clean code. Straightforward approach.

ACTUAL -
Boilerplate code. Tricky approach.


---------- BEGIN SOURCE ----------
Notorious problem.

---------- END SOURCE ----------

CUSTOMER SUBMITTED WORKAROUND :
/*
 * TransparentLayout.java alpha 06/28/2005
 */

import java.awt.LayoutManager2;
import java.awt.Container;
import java.awt.ComponentOrientation;
import java.awt.Component;
import java.awt.Rectangle;
import java.awt.Dimension;

import java.util.List;
import java.util.LinkedList;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.JButton;

// Helper class
class Child
{
Component comp;
Rectangle bounds;

public Child(Component comp, Rectangle bounds)
{
this.comp = comp;
this.bounds = bounds;
}
}

/**
 * A straightforward layout manager that infers the appropriate resizing behavior
 *
 * @version alpha, 06/28/2005
 * @author Dante <###@###.###>
 */
class TransparentLayout implements LayoutManager2
{
private Container target;
private Dimension containerSize;
        private ComponentOrientation orientation;
private List<Child> children;

        /**
         * Constructs a new <code>TransparentLayout</code>.
         *
         * @param containerSize the reference container size
         * @param orientation the container's component orientation (value must be hardcoded)
         * @see java.awt.ComponentOrientation
         */
public TransparentLayout(Dimension containerSize, ComponentOrientation orientation)
{
this.containerSize = containerSize;
                this.orientation = orientation;
this.children = new LinkedList<Child>();
}

       /**
         * Adds the specified component to the layout, using the specified
         * bounds object. For transparent layouts, the constraint must be
         * a java.awt.Rectangle object.
         * Called when a component is added to a container using the
         * <code>Container.add</code> method with the same argument types.
         * @param comp the component to be added.
         * @param bounds a java.awt.Rectangle object that specifies the component bounds.
         * @see java.awt.Container#add(java.awt.Component, java.lang.Object)
         * @exception IllegalArgumentException if the constraint object is not a Rectangle.
         */
        public void addLayoutComponent(Component comp, Object bounds)
{
                if (bounds == null || ! (bounds instanceof Rectangle))
                {
                 throw new IllegalArgumentException("cannot add to layout: constraint must be a rectangle");
                }
                
this.children.add(new Child(comp, (Rectangle)bounds));
}

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

public void removeLayoutComponent(Component comp)
{
         this.children.remove(comp);
}

public Dimension maximumLayoutSize(Container target)
{
return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
}

public Dimension preferredLayoutSize(Container target)
{
return this.containerSize;
}

public Dimension minimumLayoutSize(Container target)
{
return preferredLayoutSize(target);
}

public float getLayoutAlignmentX(Container target)
{
return 0;
}

public float getLayoutAlignmentY(Container target)
{
return 0;
}

public void invalidateLayout(Container target) {}
   
        /**
         * Lays out the specified container.
         *
         * @param target the specified component being laid out
         * @see Container
         * @see java.awt.Container#doLayout
         */
        public void layoutContainer(Container target)
{
if (this.target == null)
{
this.target = target;
}
synchronized(target.getTreeLock())
{
                        // Container bounds
Rectangle defaultBounds = new Rectangle(this.containerSize),
currentBounds = target.getBounds(),
newBounds = null;
double hScale = (double) currentBounds.width / defaultBounds.width,
vScale = (double) currentBounds.height / defaultBounds.height;
                        // Children bounds
Component currentChild;
                        ComponentOrientation currentOrientation = target.getComponentOrientation();
for (Child c : this.children)
{
currentChild = c.comp;
defaultBounds = c.bounds;

currentBounds = currentChild.getBounds();

newBounds = (Rectangle) currentBounds.clone();

newBounds.x = (int)(defaultBounds.x * hScale);
newBounds.width = (int)(defaultBounds.width * hScale);
newBounds.y = (int)(defaultBounds.y * vScale);
newBounds.height = (int)(defaultBounds.height * vScale);
                                
                                // i18n
                                if (currentOrientation.isLeftToRight() != this.orientation.isLeftToRight())
                                {
                                 newBounds.x = target.getBounds().width - (newBounds.x + newBounds.width);
                                }
                                        
currentChild.setBounds(newBounds);
}
}
}
}

// Sample
public class TransparentLayoutDemo
{
public static void main(String[] args)
{
JFrame f = new JFrame("Transparent layout demo");
f.setLayout(new TransparentLayout(new Dimension(400, 300), f.getComponentOrientation()));
f.add(new JLabel("Label here"), new Rectangle(50, 50, 100, 50));
f.add(new JTextField("Text field here"), new Rectangle(250, 50, 100, 50));
f.add(new JButton("Button here"), new Rectangle(140, 200, 125, 50));
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}
}
###@###.### 2005-06-29 10:58:29 GMT