/*******************************************************************************
* 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.decorator;
import org.eclipse.draw2d.AbstractHintLayout;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.PositionConstants;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.Rectangle;
/**
* This layout is to assist in the placement of decorations in a layer over top
* of a particular figure.
*
* There are nine possible locations for a decoration, as defined in the constants.
*
* Subclasses should implement the calculateLocation method to specify where a
* decoration of a given size should go in the given container, taking into
* account the location hint.
*/
public class DecorationLayout extends AbstractHintLayout {
protected IFigure center, left, top, bottom, right, topLeft, topRight, bottomLeft, bottomRight;
public DecorationLayout() {
super();
}
/**
* Calculate an x+y location for a decoration. This method should take into account the location hint,
* which specifies which of nine locations the decoration should go. Different edit parts could
* consider those locations to be at different x+y coordinates depending on the visuals of that edit
* part. For example, in a leaf edit part which has a round rectangle surrounding the activity label,
* the top left should be considered to be just inside the top left corner of the rectangle, as opposed
* to in the top left corner of the figure, which would lie outside this rectangle.
*
* @param locationHint one of the nine location constants defining where the decoration should go
* @param container the containing figure into which the decoration will be inserted
* @param childDimension the preferred size of the decoration
* @return the preferred location of the decoration based on the input
*/
protected Point calculateLocation(int locationHint, IFigure container, Dimension childDimension) {
Rectangle area = container.getClientArea();
switch (locationHint) {
case PositionConstants.CENTER: // Center
return new Point(area.x + area.width / 2 - childDimension.width / 2, area.y + area.height / 2 - childDimension.height / 2);
case PositionConstants.TOP: // Top Center
return new Point(area.x + area.width / 2 - childDimension.width / 2, area.y );
case PositionConstants.BOTTOM: // Bottom Center
return new Point(area.x + area.width / 2 - childDimension.width / 2, area.y + area.height - childDimension.height);
case PositionConstants.LEFT: // Center Left
return new Point(area.x, area.y + area.height / 2 - childDimension.width / 2);
case PositionConstants.RIGHT: // Center Right
return new Point(area.x + area.width - childDimension.width, area.y + area.height / 2 - childDimension.height / 2);
case PositionConstants.TOP | PositionConstants.LEFT: // Top Left
return new Point(area.x, area.y);
case PositionConstants.TOP | PositionConstants.RIGHT: // Top Right
return new Point(area.x + area.width - childDimension.width, area.y );
case PositionConstants.BOTTOM | PositionConstants.LEFT: // Bottom Left
return new Point(area.x, area.y + area.height - childDimension.height);
case PositionConstants.BOTTOM | PositionConstants.RIGHT: // Bottom Right
return new Point(area.x + area.width - childDimension.width, area.y + area.height - childDimension.height);
default:
return new Point(area.x, area.y);
}
}
@Override
protected Dimension calculatePreferredSize(IFigure container, int wHint, int hHint) {
return new Dimension(0, 0);
}
public void layout(IFigure container) {
Rectangle rect = new Rectangle();
if (top != null && top.isVisible()) {
Dimension d = top.getPreferredSize(-1, -1);
rect.setLocation(calculateLocation(IMarkerConstants.TOP.intValue(), container, d));
rect.setSize(d);
top.setBounds(rect);
}
if (bottom != null && bottom.isVisible()) {
Dimension d = bottom.getPreferredSize(-1, -1);
rect.setLocation(calculateLocation(IMarkerConstants.BOTTOM.intValue(), container, d));
rect.setSize(d);
bottom.setBounds(rect);
}
if (left != null && left.isVisible()) {
Dimension d = left.getPreferredSize(-1, -1);
rect.setLocation(calculateLocation(IMarkerConstants.LEFT.intValue(), container, d));
rect.setSize(d);
left.setBounds(rect);
}
if (right != null && right.isVisible()) {
Dimension d = right.getPreferredSize(-1, -1);
rect.setLocation(calculateLocation(IMarkerConstants.RIGHT.intValue(), container, d));
rect.setSize(d);
right.setBounds(rect);
}
if (center != null && center.isVisible()) {
Dimension d = center.getPreferredSize(-1, -1);
rect.setLocation(calculateLocation(IMarkerConstants.CENTER.intValue(), container, d));
rect.setSize(d);
center.setBounds(rect);
}
if (topLeft != null && topLeft.isVisible()) {
Dimension d = topLeft.getPreferredSize(-1, -1);
rect.setLocation(calculateLocation(IMarkerConstants.TOP_LEFT.intValue(), container, d));
rect.setSize(d);
topLeft.setBounds(rect);
}
if (topRight != null && topRight.isVisible()) {
Dimension d = topRight.getPreferredSize(-1, -1);
rect.setLocation(calculateLocation(IMarkerConstants.TOP_RIGHT.intValue(), container, d));
rect.setSize(d);
topRight.setBounds(rect);
}
if (bottomLeft != null && bottomLeft.isVisible()) {
Dimension d = bottomLeft.getPreferredSize(-1, -1);
rect.setLocation(calculateLocation(IMarkerConstants.BOTTOM_LEFT.intValue(), container, d));
rect.setSize(d);
bottomLeft.setBounds(rect);
}
if (bottomRight != null && bottomRight.isVisible()) {
Dimension d = bottomRight.getPreferredSize(-1, -1);
rect.setLocation(calculateLocation(IMarkerConstants.BOTTOM_RIGHT.intValue(), container, d));
rect.setSize(d);
bottomRight.setBounds(rect);
}
}
@Override
public void remove(IFigure child) {
if (center == child) {
center = null;
} else if (top == child) {
top = null;
} else if (bottom == child) {
bottom = null;
} else if (right == child) {
right = null;
} else if (left == child) {
left = null;
} else if (topLeft == child) {
topLeft = null;
} else if (topRight == child) {
topRight = null;
} else if (bottomLeft == child) {
bottomLeft = null;
} else if (bottomRight == child) {
bottomRight = null;
}
}
@Override
public void setConstraint(IFigure child, Object constraint) {
remove(child);
super.setConstraint(child, constraint);
if (constraint == null) {
return;
}
switch (((Integer) constraint).intValue()) {
case PositionConstants.CENTER :
center = child;
break;
case PositionConstants.TOP :
top = child;
break;
case PositionConstants.BOTTOM :
bottom = child;
break;
case PositionConstants.RIGHT :
right = child;
break;
case PositionConstants.LEFT :
left = child;
break;
case PositionConstants.TOP | PositionConstants.LEFT :
topLeft = child;
break;
case PositionConstants.TOP | PositionConstants.RIGHT :
topRight = child;
break;
case PositionConstants.BOTTOM | PositionConstants.LEFT :
bottomLeft = child;
break;
case PositionConstants.BOTTOM | PositionConstants.RIGHT :
bottomRight = child;
break;
default :
break;
}
}
}