/*******************************************************************************
 * Copyright (c) 2000, 2007 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.draw2d;

import java.util.List;

import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Insets;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.draw2d.geometry.Transposer;

/**
 * Arranges figures in a single row or column.  Orientation can be set to produce either
 * a row or column layout. This layout tries to fit all children within the parent's 
 * client area.  To do this, it compresses the children by some amount, but will not 
 * compress them smaller than their minimum size. If a child's preferred size is smaller 
 * than the row's or column's minor dimension, the layout can be configured to stretch the
 * child.
 */
public class ToolbarLayout
	extends AbstractHintLayout
{

/** Space in pixels between Figures **/
protected int spacing;
/** Sets whether children should "stretch" with their container **/
protected boolean matchWidth;
/** Orientation of layout **/
protected boolean horizontal = false;
/** Alignment of layout **/
protected int minorAlignment;

/** Constant for center alignment **/
public static final int ALIGN_CENTER = 0;
/** Constant for top-left alignment **/
public static final int ALIGN_TOPLEFT = 1;
/** Constant for bottom-right alignment **/
public static final int ALIGN_BOTTOMRIGHT = 2;

/** Constant for horizontal alignment **/
public static final boolean HORIZONTAL = true;
/** Constant for vertical alignment **/
public static final boolean VERTICAL = false;

/** Transposer object used in layout calculations **/
protected Transposer transposer; {
	transposer = new Transposer();
	transposer.setEnabled(horizontal);
}	
	
/**
 * Constructs a vertically oriented ToolbarLayout with child spacing of 0 pixels, 
 * matchWidth <code>true</code>, and {@link #ALIGN_TOPLEFT} alignment.
 * 
 * @since 2.0
 */		
public ToolbarLayout() {
	spacing = 0;
	matchWidth = true;
	minorAlignment = ALIGN_TOPLEFT;
	horizontal = false;
}

/**
 * Constructs a ToolbarLayout with a specified orientation. Default values are: child 
 * spacing 0 pixels, matchWidth <code>false</code>, and {@link #ALIGN_TOPLEFT} 
 * alignment.
 * 
 * @param isHorizontal whether the children are oriented horizontally
 * @since 2.0
 */
public ToolbarLayout(boolean isHorizontal) {
	horizontal = isHorizontal; 
	transposer.setEnabled(horizontal);
	spacing = 0;
	matchWidth = false;
	minorAlignment = ALIGN_TOPLEFT;
}

private Dimension calculateChildrenSize(List children, int wHint, int hHint,
			boolean preferred) {
	Dimension childSize;
	IFigure child;
	int height = 0, width = 0;
	for (int i = 0; i < children.size(); i++) {
		child = (IFigure)children.get(i);
		childSize = transposer.t(preferred ? getChildPreferredSize(child, wHint, hHint)
		                                   : getChildMinimumSize(child, wHint, hHint));
		height += childSize.height;
		width = Math.max(width, childSize.width);
	}
	return new Dimension(width, height);
}

/**
 * Calculates the minimum size of the container based on the given hints. If this is a
 * vertically-oriented Toolbar Layout, then only the widthHint is respected (which means
 * that the children can be as tall as they desire).   In this case, the minimum width
 * is that of the widest child, and the minimum height is the sum of the minimum
 * heights of all children, plus the spacing between them. The border and insets of the
 * container figure are also accounted for.
 * 
 * @param container the figure whose minimum size has to be calculated
 * @param wHint the width hint (the desired width of the container)
 * @param hHint the height hint (the desired height of the container)
 * @return the minimum size of the container
 * @see #getMinimumSize(IFigure, int, int)
 * @since 2.1
 */
protected Dimension calculateMinimumSize(IFigure container, int wHint, int hHint) {
	Insets insets = container.getInsets();
	if (isHorizontal()) {
		wHint = -1;
		if (hHint >= 0)
			hHint = Math.max(0, hHint - insets.getHeight());
	} else {
		hHint = -1;
		if (wHint >= 0)
			wHint = Math.max(0, wHint - insets.getWidth());
	}
	
	List children = container.getChildren();
	Dimension minSize = calculateChildrenSize(children, wHint, hHint, false);
	// Do a second pass, if necessary
	if (wHint >= 0 && minSize.width > wHint) {
		minSize = calculateChildrenSize(children, minSize.width, hHint, false);	
	} else if (hHint >= 0 && minSize.width > hHint) {
		minSize = calculateChildrenSize(children, wHint, minSize.width, false);
	}
	
	minSize.height += Math.max(0, children.size() - 1) * spacing;
	return transposer.t(minSize)
			.expand(insets.getWidth(), insets.getHeight())
			.union(getBorderPreferredSize(container));
}

/** 
 * Calculates the preferred size of the container based on the given hints. If this is a
 * vertically-oriented Toolbar Layout, then only the widthHint is respected (which means
 * that the children can be as tall as they desire).   In this case, the preferred width
 * is that of the widest child, and the preferred height is the sum of the preferred
 * heights of all children, plus the spacing between them.  The border and insets of the
 * container figure are also accounted for.
 * 
 * @param container the figure whose preferred size has to be calculated
 * @param wHint the width hint (the desired width of the container)
 * @param hHint the height hint (the desired height of the container)
 * @return the preferred size of the container
 * @see #getPreferredSize(IFigure, int, int)
 * @since 2.0
 */
protected Dimension calculatePreferredSize(IFigure container, int wHint, int hHint) {
	Insets insets = container.getInsets();
	if (isHorizontal()) {
		wHint = -1;
		if (hHint >= 0)
			hHint = Math.max(0, hHint - insets.getHeight());
	} else {
		hHint = -1;
		if (wHint >= 0)
			wHint = Math.max(0, wHint - insets.getWidth());
	}
	
	List children = container.getChildren();
	Dimension prefSize = calculateChildrenSize(children, wHint, hHint, true);
	// Do a second pass, if necessary
	if (wHint >= 0 && prefSize.width > wHint) {
		prefSize = calculateChildrenSize(children, prefSize.width, hHint, true);	
	} else if (hHint >= 0 && prefSize.width > hHint) {
		prefSize = calculateChildrenSize(children, wHint, prefSize.width, true);
	}
	
	prefSize.height += Math.max(0, children.size() - 1) * spacing;
	return transposer.t(prefSize)
			.expand(insets.getWidth(), insets.getHeight())
			.union(getBorderPreferredSize(container));
}

/**
 * @param child the figure whose minimum size is to be determined
 * @param wHint the width hint
 * @param hHint the height hint
 * @return the given figure's minimum size
 * @since 3.3
 */
protected Dimension getChildMinimumSize(IFigure child, int wHint, int hHint) {
	return child.getMinimumSize(wHint, hHint);
}

/**
 * @param child the figure whose preferred size is to be determined
 * @param wHint the width hint
 * @param hHint the height hint
 * @return given figure's preferred size
 * @since 3.3
 */
protected Dimension getChildPreferredSize(IFigure child, int wHint, int hHint) {
	return child.getPreferredSize(wHint, hHint);
}

/**
 * Returns the minor aligment of the layout.  Minor minor axis is the axis perpindicular
 * to the overall orientation set in the contructor.
 * @return the minor aligment
 */
public int getMinorAlignment() {
	return minorAlignment;
}

/**
 * @return the spacing between children
 */
public int getSpacing() {
	return spacing;
}

/**
 * Returns <code>true</code> if stretch minor axis has been enabled. The default value is
 * false.
 * @return <code>true</code> if stretch minor axis is enabled
 */
public boolean getStretchMinorAxis() {
	return matchWidth;
}

/**
 * @return whether the orientation of the layout is horizontal
 * @since 2.0
 */
public boolean isHorizontal() {
	return horizontal;
}

/**
 * @see org.eclipse.draw2d.AbstractHintLayout#isSensitiveHorizontally(IFigure)
 */
protected boolean isSensitiveHorizontally(IFigure parent) {
	return !isHorizontal();
}

/**
 * @see org.eclipse.draw2d.AbstractHintLayout#isSensitiveVertically(IFigure)
 */
protected boolean isSensitiveVertically(IFigure parent) {
	return isHorizontal();
}

/**
 * @see org.eclipse.draw2d.LayoutManager#layout(IFigure)
 */
public void layout(IFigure parent) {
	List children = parent.getChildren();
	int numChildren = children.size();
	Rectangle clientArea = transposer.t(parent.getClientArea());
	int x = clientArea.x;
	int y = clientArea.y;
	int availableHeight = clientArea.height;

	Dimension prefSizes [] = new Dimension[numChildren];
	Dimension minSizes [] = new Dimension[numChildren];
	
	// Calculate the width and height hints.  If it's a vertical ToolBarLayout,
	// then ignore the height hint (set it to -1); otherwise, ignore the 
	// width hint.  These hints will be passed to the children of the parent
	// figure when getting their preferred size. 
	int wHint = -1;
	int hHint = -1;    
	if (isHorizontal()) {
		hHint = parent.getClientArea(Rectangle.SINGLETON).height;
	} else {
		wHint = parent.getClientArea(Rectangle.SINGLETON).width;
	}

	/*		
	 * Calculate sum of preferred heights of all children(totalHeight). 
	 * Calculate sum of minimum heights of all children(minHeight).
	 * Cache Preferred Sizes and Minimum Sizes of all children.
	 *
	 * totalHeight is the sum of the preferred heights of all children
	 * totalMinHeight is the sum of the minimum heights of all children
	 * prefMinSumHeight is the sum of the difference between all children's
	 * preferred heights and minimum heights. (This is used as a ratio to 
	 * calculate how much each child will shrink). 
	 */
	IFigure child; 
	int totalHeight = 0;
	int totalMinHeight = 0;
	int prefMinSumHeight = 0;

	for (int i = 0; i < numChildren; i++) {
		child = (IFigure)children.get(i);
		
		prefSizes[i] = transposer.t(getChildPreferredSize(child, wHint, hHint));
		minSizes[i] = transposer.t(getChildMinimumSize(child, wHint, hHint));
		
		totalHeight += prefSizes[i].height;
		totalMinHeight += minSizes[i].height;
	}
	totalHeight += (numChildren - 1) * spacing;
	totalMinHeight += (numChildren - 1) * spacing;
	prefMinSumHeight = totalHeight - totalMinHeight;
    /* 
	 * The total amount that the children must be shrunk is the 
	 * sum of the preferred Heights of the children minus  
	 * Max(the available area and the sum of the minimum heights of the children).
	 *
	 * amntShrinkHeight is the combined amount that the children must shrink
	 * amntShrinkCurrentHeight is the amount each child will shrink respectively  
	 */	
	int amntShrinkHeight = totalHeight - Math.max(availableHeight, totalMinHeight);

	if (amntShrinkHeight < 0) {
		amntShrinkHeight = 0;
	}

	for (int i = 0; i < numChildren; i++) {
		int amntShrinkCurrentHeight = 0;
		int prefHeight = prefSizes[i].height;
		int minHeight = minSizes[i].height;
		int prefWidth = prefSizes[i].width;
		int minWidth = minSizes[i].width;
		Rectangle newBounds = new Rectangle(x, y, prefWidth, prefHeight);

		child = (IFigure)children.get(i);
	    if (prefMinSumHeight != 0)
			amntShrinkCurrentHeight = 
					(prefHeight - minHeight) * amntShrinkHeight / (prefMinSumHeight);

	    int width = Math.min(prefWidth, transposer.t(child.getMaximumSize()).width);
		if (matchWidth)
			width = transposer.t(child.getMaximumSize()).width;
		width = Math.max(minWidth, Math.min(clientArea.width, width));
		newBounds.width = width;

	      int adjust = clientArea.width - width;
		switch (minorAlignment) {
		case ALIGN_TOPLEFT: 
			adjust = 0;
			break;
		case ALIGN_CENTER:
			adjust /= 2;
			break;
		case ALIGN_BOTTOMRIGHT:
			break;
		}
		newBounds.x += adjust;
		newBounds.height -= amntShrinkCurrentHeight;
		child.setBounds(transposer.t(newBounds));

		amntShrinkHeight -= amntShrinkCurrentHeight;
		prefMinSumHeight -= (prefHeight - minHeight);
		y += newBounds.height + spacing;
	}
}				

/**
 * Sets the alignment of the children contained in the layout.  Possible values are 
 * {@link #ALIGN_CENTER}, {@link #ALIGN_BOTTOMRIGHT} and {@link #ALIGN_TOPLEFT}.
 * 
 * @param align the minor alignment
 * @since 2.0
 */
public void setMinorAlignment(int align) {
	minorAlignment = align;
}

/**
 * Sets the amount of space between children.
 * 
 * @param space the amount of space between children
 * @since 2.0
 */
public void setSpacing(int space) {
	spacing = space;
}

/**
 * Sets children's width (if vertically oriented) or height (if horizontally oriented) to 
 * stretch with their container.
 * 
 * @deprecated use {@link #setStretchMinorAxis(boolean)}
 * @param match whether to stretch children
 * @since 2.0
 */
public void setMatchWidth(boolean match) {
	matchWidth = match;
}

/**
 * Causes children that are smaller in the dimension of the minor axis to be stretched to
 * fill the minor axis.  The minor axis is the opposite of the orientation.
 * @param stretch whether to stretch children
 * @since 2.0
 */
public void setStretchMinorAxis(boolean stretch) {
	matchWidth = stretch;
}

/**
 * Sets the orientation of the children in the ToolbarLayout.
 * 
 * @param flag whether the orientation should be vertical
 * @since 2.0
 */
public void setVertical(boolean flag) {
	if (horizontal != flag) return;
	invalidate();
	horizontal = !flag;
	transposer.setEnabled(horizontal);
}

}
