plugins/org.eclipse.bpel.common.ui.noEmbeddedEditors/src/org/eclipse/bpel/common/ui/layouts/AlignedFlowLayout.java - bpel/org.eclipse.bpel - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.bpel.common.ui.layouts;

 import java.util.Iterator;
 import java.util.List;

 import org.eclipse.draw2d.AbstractHintLayout;
 import org.eclipse.draw2d.IFigure;
 import org.eclipse.draw2d.geometry.Dimension;
 import org.eclipse.draw2d.geometry.Rectangle;
 import org.eclipse.draw2d.geometry.Transposer;

 /** A version of FlowLayout that doesn't wrap the children
  * and allows aligning in both orientations
  * as well as alignment of the children relative to each other
  *
  * some parameters you can set:
  *
  * horizontal - orientation of children
  * 	if true, children laid across, and width respected
  * 	if false. children laid downwards, height respected.
  *
  * fill - if true and layout is horizontal, height not respected
  * 		  if false and layout is horizontal, height respected
  *        if true and layout is vertical, width not respected
  *
  * fillParent - if true, tries to fill the child to the container size
  *
  * horizontal or vertical alignment
  * 	specifies which 1 of 3 areas the children are placed into
  *
  * ALIGN_BEGIN means either left or top
  * ALIGN_END means either right or bottom
  * ALIGN_CENTER means in the middle
  *
  * secondaryAlignment - how the children are lined up in secondary axis
  *   if horizontal - specfies if children are aligned to their tops, center or bottom
  * 	 if vertical - specifies if children are aligned to left, right or center.
  *
  */

 public class AlignedFlowLayout extends AbstractHintLayout {
 	/*
 	 * Constants defining the alignment of the components
 	 */
 	public static final int ALIGN_CENTER = 0, ALIGN_BEGIN = 1, ALIGN_END = 2;
 	public static final boolean HORIZONTAL = true, VERTICAL = false;

 	protected boolean horizontal = true;
 	protected boolean fill = false;
 	protected boolean fillParent = false;

 	protected Transposer transposer;
 	{
 		transposer = new Transposer();
 		transposer.setEnabled(!horizontal);
 	}

 	/*
 	 * Internal state
 	 */
 	protected int horizontalAlignment = ALIGN_BEGIN;
 	protected int verticalAlignment = ALIGN_BEGIN;
 	protected int secondaryAlignment = ALIGN_BEGIN;


 	protected int horizontalSpacing = 5, verticalSpacing = 5;
 	private WorkingData data = null;

 	/**
 	 * Holds the necessary information for layout calculations.
 	 */
 	class WorkingData {
 		int rowHeight, rowWidth, rowCount, rowX, rowY;
 		Rectangle bounds[], area;
 		IFigure row[];
 		Dimension spacing;
 	}

 	public AlignedFlowLayout() {
 	}

 	public AlignedFlowLayout(boolean isHorizontal) {
 		setHorizontal(isHorizontal);
 	}

 	@Override
 	protected Dimension calculatePreferredSize(IFigure container, int wHint, int hHint) {
 		int cHorizontalSpacing = horizontalSpacing;
 		if (!isHorizontal()) {
 			cHorizontalSpacing = verticalSpacing;
 		}

 		// Subtract out the insets from the hints
 		if (wHint > -1)
 			wHint = Math.max(0, wHint - container.getInsets().getWidth());
 		if (hHint > -1)
 			hHint = Math.max(0, hHint - container.getInsets().getHeight());

 		// Figure out the new hint that we are interested in based on the orientation
 		// Ignore the other hint (by setting it to -1).  NOTE: The children of the
 		// parent figure will then be asked to ignore that hint as well.
 		int maxWidth;
 		if (isHorizontal()) {
 			maxWidth = wHint;
 			hHint = -1;
 		} else {
 			maxWidth = hHint;
 			wHint = -1;
 		}
 		if (maxWidth <= 0) {
 			maxWidth = Integer.MAX_VALUE;
 		}

 		// The preferred dimension that is to be calculated and returned
 		Dimension prefSize = new Dimension();

 		List children = container.getChildren();
 		int width = 0;
 		int height = 0;
 		IFigure child;
 		Dimension childSize;

 		//Build the sizes for each row, and update prefSize accordingly
 		for (int i = 0; i < children.size(); i++) {
 			child = (IFigure) children.get(i);
 			childSize = transposer.t(getChildSize(child, wHint, hHint));
 			if (i == 0) {
 				width = childSize.width;
 				height = childSize.height;
 			} else
 			{
 				// fit another child.
 				width += childSize.width + cHorizontalSpacing;
 				height = Math.max(height, childSize.height);
 			}
 		}

 		// Flush out the last row's data
 		prefSize.height += height;
 		prefSize.width = Math.max(prefSize.width, width);

 		// Transpose the dimension back, and compensate for the border.
 		prefSize = transposer.t(prefSize);
 		prefSize.width += container.getInsets().getWidth();
 		prefSize.height += container.getInsets().getHeight();
 		prefSize.union(getBorderPreferredSize(container));
 		return prefSize;
 	}

 	/**
 	 * Provides the given child's preferred size
 	 *
 	 * @param child	The Figure whose preferred size needs to be calculated
 	 * @param wHint	The width hint to be used when calculating the child's preferred size
 	 * @param hHint	The height hint to be used when calculating the child's preferred size
 	 * @return the child's preferred size
 	 */
 	protected Dimension getChildSize(IFigure child, int wHint, int hHint) {
 		return child.getPreferredSize(wHint, hHint);
 	}

 	public int getHorizontalAlignment() {
 		return horizontalAlignment;
 	}

 	public int getVerticalSpacing() {
 		return verticalSpacing;
 	}

 	public int getVerticalAlignment() {
 		return verticalAlignment;
 	}

 	public int getHorizontalSpacing() {
 		return horizontalSpacing;
 	}

 	/**
 	 * Initializes the state of row data, which is internal
 	 * to the layout process.
 	 */
 	private void initRow() {
 		data.rowX = 0;
 		data.rowHeight = 0;
 		data.rowWidth = 0;
 		data.rowCount = 0;
 	}

 	/**
 	 * Initializes state data for laying out children, based
 	 * on the Figure given as input.
 	 *
 	 * @param parent  Figure for which the children are to
 	 *                 be arranged.
 	 * @since 2.0
 	 */
 	private void initVariables(IFigure parent) {
 		data.row = new IFigure[parent.getChildren().size()];
 		data.bounds = new Rectangle[data.row.length];
 	}

 	public boolean isHorizontal() {
 		return horizontal;
 	}

 	@Override
 	protected boolean isSensitiveHorizontally(IFigure parent) {
 		return isHorizontal();
 	}

 	@Override
 	protected boolean isSensitiveVertically(IFigure parent) {
 		return !isHorizontal();
 	}

 	public void layout(IFigure parent) {
 		data = new WorkingData();
 		Rectangle relativeArea = parent.getClientArea();
 		data.area = transposer.t(relativeArea);
 		data.spacing = transposer.t(new Dimension(horizontalSpacing, verticalSpacing));

 		Iterator iterator = parent.getChildren().iterator();
 		int dx;

 		//Calculate the hints to be passed to children
 		int wHint = -1;
 		int hHint = -1;
 		if (isHorizontal())
 			wHint = parent.getClientArea().width;
 		else
 			hHint = parent.getClientArea().height;

 		initVariables(parent);
 		initRow();
 		int i = 0;
 		while (iterator.hasNext()) {
 			IFigure f = (IFigure) iterator.next();
 			Dimension pref = transposer.t(getChildSize(f, wHint, hHint));
 			Rectangle r = new Rectangle(0, 0, pref.width, pref.height);
 			r.x = data.rowX;
 			r.y = data.rowY;
 			dx = r.width + data.spacing.width;
 			data.rowX += dx;
 			data.rowWidth += dx;
 			data.rowHeight = Math.max(data.rowHeight, r.height);
 			if (fillParent)
 			    data.rowHeight = Math.max(data.area.height, r.height);

 			data.row[data.rowCount] = f;
 			data.bounds[data.rowCount] = r;
 			data.rowCount++;
 			i++;
 		}
 		if (data.rowCount != 0)
 			layoutRow(parent);
 		data = null;
 	}

 	/**
 	 * Layouts one row of components. This is done based on
 	 * the layout's orientation, minor alignment and major alignment.
 	 *
 	 * @param parent  Figure whose children are to be placed.
 	 * @since 2.0
 	 */
 	protected void layoutRow(IFigure parent) {
 		int majorAdjustment = 0;
 		int minorAdjustment = 0;
 		int justification = 0;
 		int correctHorizontalAlignment = horizontalAlignment;
 		int correctVerticalAlignment = verticalAlignment;

 		majorAdjustment = data.area.width - data.rowWidth;
 		if (!isHorizontal()) {
 			correctHorizontalAlignment = verticalAlignment;
 			correctVerticalAlignment = horizontalAlignment;
 		}
 		switch (correctHorizontalAlignment) {
 			case ALIGN_BEGIN :
 				majorAdjustment = 0;
 				break;
 			case ALIGN_CENTER :
 				majorAdjustment /= 2;
 				break;
 			case ALIGN_END :
 				break;
 		}
 		minorAdjustment = data.area.height - data.rowHeight;
 		switch (correctVerticalAlignment) {
 			case ALIGN_BEGIN :
 				minorAdjustment = 0;
 				break;
 			case ALIGN_CENTER :
 				minorAdjustment /= 2;
 				break;
 			case ALIGN_END :
 				break;
 		}

 		for (int j = 0; j < data.rowCount; j++) {
 			if (fill) {
 				data.bounds[j].height = data.rowHeight;
 			} else {
 				justification = data.rowHeight - data.bounds[j].height;
 				switch (secondaryAlignment) {
 					case ALIGN_BEGIN :
 						justification = 0;
 						break;
 					case ALIGN_CENTER :
 						justification /= 2;
 						break;
 					case ALIGN_END :
 						break;
 				}
 				data.bounds[j].y += minorAdjustment + justification;
 			}
 			data.bounds[j].x += majorAdjustment;

 			setBoundsOfChild(parent, data.row[j], transposer.t(data.bounds[j]));
 		}
 		data.rowY += data.spacing.height + data.rowHeight;
 		initRow();
 	}

 	/**
 	 * Sets the given bounds for the child figure input.
 	 *
 	 * @param parent  Parent Figure which holds the child.
 	 * @param child   Child Figure whose bounds are to be set.
 	 * @param bounds  The size of the child to be set.
 	 * @since 2.0
 	 */
 	protected void setBoundsOfChild(IFigure parent, IFigure child, Rectangle bounds) {
 		parent.getClientArea(Rectangle.SINGLETON);
 		bounds.translate(Rectangle.SINGLETON.x, Rectangle.SINGLETON.y);
 		child.setBounds(bounds);
 	}

 	/**
 	 * Sets flag based on layout orientation.
 	 * If in Horizontal orientation, all Figures will have the same height.
 	 * If in vertical orientation, all Figures will have the same width.
 	 *
 	 * @param value  Fill state desired.
 	 * @since 2.0
 	 */
 	public void setStretchMinorAxis(boolean value) {
 		fill = value;
 	}

 	public void setHorizontal(boolean flag) {
 		if (horizontal == flag)
 			return;
 		invalidate();
 		horizontal = flag;
 		transposer.setEnabled(!horizontal);
 	}

 	public void setHorizontalAlignment(int align) {
 		horizontalAlignment = align;
 	}

 	/**
 	 * Sets the spacing in pixels to be used between children in
 	 * the direction parallel to the layout's orientation.
 	 *
 	 * @param n  Amount of major space.
 	 * @see  #setHorizontalSpacing(int)
 	 * @since 2.0
 	 */
 	public void setVerticalSpacing(int n) {
 		verticalSpacing = n;
 	}

 	public void setVerticalAlignment(int align) {
 		verticalAlignment = align;
 	}

 	public void setHorizontalSpacing(int n) {
 		horizontalSpacing = n;
 	}

 	public int getSecondaryAlignment() {
 		return secondaryAlignment;
 	}

 	public void setSecondaryAlignment(int i) {
 		secondaryAlignment = i;
 	}

 	/**
 	 *
 	 * @param fillParent - if setStretchMinorAxis is true, setting
 	 * this flag will make the stretch fill the client area of the container
 	 */
     public void setStretchMinorAxisToParent(boolean fillParent) {
         this.fillParent = fillParent;
     }


 }
	/*******************************************************************************
	* Copyright (c) 2005 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.bpel.common.ui.layouts;

	import java.util.Iterator;
	import java.util.List;

	import org.eclipse.draw2d.AbstractHintLayout;
	import org.eclipse.draw2d.IFigure;
	import org.eclipse.draw2d.geometry.Dimension;
	import org.eclipse.draw2d.geometry.Rectangle;
	import org.eclipse.draw2d.geometry.Transposer;

	/** A version of FlowLayout that doesn't wrap the children
	* and allows aligning in both orientations
	* as well as alignment of the children relative to each other
	*
	* some parameters you can set:
	*
	* horizontal - orientation of children
	* if true, children laid across, and width respected
	* if false. children laid downwards, height respected.
	*
	* fill - if true and layout is horizontal, height not respected
	* if false and layout is horizontal, height respected
	* if true and layout is vertical, width not respected
	*
	* fillParent - if true, tries to fill the child to the container size
	*
	* horizontal or vertical alignment
	* specifies which 1 of 3 areas the children are placed into
	*
	* ALIGN_BEGIN means either left or top
	* ALIGN_END means either right or bottom
	* ALIGN_CENTER means in the middle
	*
	* secondaryAlignment - how the children are lined up in secondary axis
	* if horizontal - specfies if children are aligned to their tops, center or bottom
	* if vertical - specifies if children are aligned to left, right or center.
	*
	*/

	public class AlignedFlowLayout extends AbstractHintLayout {
	/*
	* Constants defining the alignment of the components
	*/
	public static final int ALIGN_CENTER = 0, ALIGN_BEGIN = 1, ALIGN_END = 2;
	public static final boolean HORIZONTAL = true, VERTICAL = false;

	protected boolean horizontal = true;
	protected boolean fill = false;
	protected boolean fillParent = false;

	protected Transposer transposer;
	{
	transposer = new Transposer();
	transposer.setEnabled(!horizontal);
	}

	/*
	* Internal state
	*/
	protected int horizontalAlignment = ALIGN_BEGIN;
	protected int verticalAlignment = ALIGN_BEGIN;
	protected int secondaryAlignment = ALIGN_BEGIN;


	protected int horizontalSpacing = 5, verticalSpacing = 5;
	private WorkingData data = null;

	/**
	* Holds the necessary information for layout calculations.
	*/
	class WorkingData {
	int rowHeight, rowWidth, rowCount, rowX, rowY;
	Rectangle bounds[], area;
	IFigure row[];
	Dimension spacing;
	}

	public AlignedFlowLayout() {
	}

	public AlignedFlowLayout(boolean isHorizontal) {
	setHorizontal(isHorizontal);
	}

	@Override
	protected Dimension calculatePreferredSize(IFigure container, int wHint, int hHint) {
	int cHorizontalSpacing = horizontalSpacing;
	if (!isHorizontal()) {
	cHorizontalSpacing = verticalSpacing;
	}

	// Subtract out the insets from the hints
	if (wHint > -1)
	wHint = Math.max(0, wHint - container.getInsets().getWidth());
	if (hHint > -1)
	hHint = Math.max(0, hHint - container.getInsets().getHeight());

	// Figure out the new hint that we are interested in based on the orientation
	// Ignore the other hint (by setting it to -1). NOTE: The children of the
	// parent figure will then be asked to ignore that hint as well.
	int maxWidth;
	if (isHorizontal()) {
	maxWidth = wHint;
	hHint = -1;
	} else {
	maxWidth = hHint;
	wHint = -1;
	}
	if (maxWidth <= 0) {
	maxWidth = Integer.MAX_VALUE;
	}

	// The preferred dimension that is to be calculated and returned
	Dimension prefSize = new Dimension();

	List children = container.getChildren();
	int width = 0;
	int height = 0;
	IFigure child;
	Dimension childSize;

	//Build the sizes for each row, and update prefSize accordingly
	for (int i = 0; i < children.size(); i++) {
	child = (IFigure) children.get(i);
	childSize = transposer.t(getChildSize(child, wHint, hHint));
	if (i == 0) {
	width = childSize.width;
	height = childSize.height;
	} else
	{
	// fit another child.
	width += childSize.width + cHorizontalSpacing;
	height = Math.max(height, childSize.height);
	}
	}

	// Flush out the last row's data
	prefSize.height += height;
	prefSize.width = Math.max(prefSize.width, width);

	// Transpose the dimension back, and compensate for the border.
	prefSize = transposer.t(prefSize);
	prefSize.width += container.getInsets().getWidth();
	prefSize.height += container.getInsets().getHeight();
	prefSize.union(getBorderPreferredSize(container));
	return prefSize;
	}

	/**
	* Provides the given child's preferred size
	*
	* @param child The Figure whose preferred size needs to be calculated
	* @param wHint The width hint to be used when calculating the child's preferred size
	* @param hHint The height hint to be used when calculating the child's preferred size
	* @return the child's preferred size
	*/
	protected Dimension getChildSize(IFigure child, int wHint, int hHint) {
	return child.getPreferredSize(wHint, hHint);
	}

	public int getHorizontalAlignment() {
	return horizontalAlignment;
	}

	public int getVerticalSpacing() {
	return verticalSpacing;
	}

	public int getVerticalAlignment() {
	return verticalAlignment;
	}

	public int getHorizontalSpacing() {
	return horizontalSpacing;
	}

	/**
	* Initializes the state of row data, which is internal
	* to the layout process.
	*/
	private void initRow() {
	data.rowX = 0;
	data.rowHeight = 0;
	data.rowWidth = 0;
	data.rowCount = 0;
	}

	/**
	* Initializes state data for laying out children, based
	* on the Figure given as input.
	*
	* @param parent Figure for which the children are to
	* be arranged.
	* @since 2.0
	*/
	private void initVariables(IFigure parent) {
	data.row = new IFigure[parent.getChildren().size()];
	data.bounds = new Rectangle[data.row.length];
	}

	public boolean isHorizontal() {
	return horizontal;
	}

	@Override
	protected boolean isSensitiveHorizontally(IFigure parent) {
	return isHorizontal();
	}

	@Override
	protected boolean isSensitiveVertically(IFigure parent) {
	return !isHorizontal();
	}

	public void layout(IFigure parent) {
	data = new WorkingData();
	Rectangle relativeArea = parent.getClientArea();
	data.area = transposer.t(relativeArea);
	data.spacing = transposer.t(new Dimension(horizontalSpacing, verticalSpacing));

	Iterator iterator = parent.getChildren().iterator();
	int dx;

	//Calculate the hints to be passed to children
	int wHint = -1;
	int hHint = -1;
	if (isHorizontal())
	wHint = parent.getClientArea().width;
	else
	hHint = parent.getClientArea().height;

	initVariables(parent);
	initRow();
	int i = 0;
	while (iterator.hasNext()) {
	IFigure f = (IFigure) iterator.next();
	Dimension pref = transposer.t(getChildSize(f, wHint, hHint));
	Rectangle r = new Rectangle(0, 0, pref.width, pref.height);
	r.x = data.rowX;
	r.y = data.rowY;
	dx = r.width + data.spacing.width;
	data.rowX += dx;
	data.rowWidth += dx;
	data.rowHeight = Math.max(data.rowHeight, r.height);
	if (fillParent)
	data.rowHeight = Math.max(data.area.height, r.height);

	data.row[data.rowCount] = f;
	data.bounds[data.rowCount] = r;
	data.rowCount++;
	i++;
	}
	if (data.rowCount != 0)
	layoutRow(parent);
	data = null;
	}

	/**
	* Layouts one row of components. This is done based on
	* the layout's orientation, minor alignment and major alignment.
	*
	* @param parent Figure whose children are to be placed.
	* @since 2.0
	*/
	protected void layoutRow(IFigure parent) {
	int majorAdjustment = 0;
	int minorAdjustment = 0;
	int justification = 0;
	int correctHorizontalAlignment = horizontalAlignment;
	int correctVerticalAlignment = verticalAlignment;

	majorAdjustment = data.area.width - data.rowWidth;
	if (!isHorizontal()) {
	correctHorizontalAlignment = verticalAlignment;
	correctVerticalAlignment = horizontalAlignment;
	}
	switch (correctHorizontalAlignment) {
	case ALIGN_BEGIN :
	majorAdjustment = 0;
	break;
	case ALIGN_CENTER :
	majorAdjustment /= 2;
	break;
	case ALIGN_END :
	break;
	}
	minorAdjustment = data.area.height - data.rowHeight;
	switch (correctVerticalAlignment) {
	case ALIGN_BEGIN :
	minorAdjustment = 0;
	break;
	case ALIGN_CENTER :
	minorAdjustment /= 2;
	break;
	case ALIGN_END :
	break;
	}

	for (int j = 0; j < data.rowCount; j++) {
	if (fill) {
	data.bounds[j].height = data.rowHeight;
	} else {
	justification = data.rowHeight - data.bounds[j].height;
	switch (secondaryAlignment) {
	case ALIGN_BEGIN :
	justification = 0;
	break;
	case ALIGN_CENTER :
	justification /= 2;
	break;
	case ALIGN_END :
	break;
	}
	data.bounds[j].y += minorAdjustment + justification;
	}
	data.bounds[j].x += majorAdjustment;

	setBoundsOfChild(parent, data.row[j], transposer.t(data.bounds[j]));
	}
	data.rowY += data.spacing.height + data.rowHeight;
	initRow();
	}

	/**
	* Sets the given bounds for the child figure input.
	*
	* @param parent Parent Figure which holds the child.
	* @param child Child Figure whose bounds are to be set.
	* @param bounds The size of the child to be set.
	* @since 2.0
	*/
	protected void setBoundsOfChild(IFigure parent, IFigure child, Rectangle bounds) {
	parent.getClientArea(Rectangle.SINGLETON);
	bounds.translate(Rectangle.SINGLETON.x, Rectangle.SINGLETON.y);
	child.setBounds(bounds);
	}

	/**
	* Sets flag based on layout orientation.
	* If in Horizontal orientation, all Figures will have the same height.
	* If in vertical orientation, all Figures will have the same width.
	*
	* @param value Fill state desired.
	* @since 2.0
	*/
	public void setStretchMinorAxis(boolean value) {
	fill = value;
	}

	public void setHorizontal(boolean flag) {
	if (horizontal == flag)
	return;
	invalidate();
	horizontal = flag;
	transposer.setEnabled(!horizontal);
	}

	public void setHorizontalAlignment(int align) {
	horizontalAlignment = align;
	}

	/**
	* Sets the spacing in pixels to be used between children in
	* the direction parallel to the layout's orientation.
	*
	* @param n Amount of major space.
	* @see #setHorizontalSpacing(int)
	* @since 2.0
	*/
	public void setVerticalSpacing(int n) {
	verticalSpacing = n;
	}

	public void setVerticalAlignment(int align) {
	verticalAlignment = align;
	}

	public void setHorizontalSpacing(int n) {
	horizontalSpacing = n;
	}

	public int getSecondaryAlignment() {
	return secondaryAlignment;
	}

	public void setSecondaryAlignment(int i) {
	secondaryAlignment = i;
	}

	/**
	*
	* @param fillParent - if setStretchMinorAxis is true, setting
	* this flag will make the stretch fill the client area of the container
	*/
	public void setStretchMinorAxisToParent(boolean fillParent) {
	this.fillParent = fillParent;
	}


	}