plugins/org.eclipse.bpel.ui.noEmbeddedEditors/src/org/eclipse/bpel/ui/editparts/borders/CollapsableBorder.java - bpel/org.eclipse.bpel - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2012 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.ui.editparts.borders;

 import org.eclipse.bpel.ui.BPELUIPlugin;
 import org.eclipse.bpel.ui.IBPELUIConstants;
 import org.eclipse.core.resources.IMarker;
 import org.eclipse.draw2d.Graphics;
 import org.eclipse.draw2d.IFigure;
 import org.eclipse.draw2d.ImageFigure;
 import org.eclipse.draw2d.Label;
 import org.eclipse.draw2d.geometry.Insets;
 import org.eclipse.draw2d.geometry.Point;
 import org.eclipse.draw2d.geometry.Rectangle;
 import org.eclipse.jface.resource.ColorRegistry;
 import org.eclipse.jface.resource.JFaceResources;
 import org.eclipse.swt.graphics.Image;


 /**
  * This border knows about collapsability. Specifically, it has icons for expand
  * and collapse, does hit testing for these icons, has an image and label to use
  * when collapsed, and does complete rendering when collapsed to look similar to
  * a leaf border (except with the addition of an expand icon).
  *
  * It does not do rendering for the expanded state. The rationale is that things
  * should look similar when collapsed (like a leaf node) but may have different
  * appearances when expanded.
  */
 public abstract class CollapsableBorder extends GradientBorder {

 	// Whether or not we are collapsed.
 	private boolean collapsed = false;
 	// The location of the collapsed image (+).
 	protected Rectangle rectCollapsed;
 	// The images for collapsed (+) and expanded (-).
 	protected Image collapsedImage, expandedImage;
 	// The width and height of the expanded image. Collapsed should be the same.
 	protected int expandedWidth, expandedHeight;
 	// The label to use when collapsed. Subclasses may also use it when expanded.
 	protected Label collapsedNameLabel = null;
 	// The image to use when collapsed. Subclasses may also use it when expanded.
 	protected Image image;
 	// The label containing the image.
 	protected ImageFigure imageLabel = null;
 	// Our parent figure. Used for relative location calculation.
 	protected IFigure parentFigure;
 	// The calculated rectangle for the collapsed border. This is null
 	// when not collapsed, so subclasses shouldn't assume it's there.
 	protected Rectangle collapsedBounds;
 	// The calculated location of the top and bottom drawer images as well as
 	// the top and bottom drawers themselves.
 	protected Point topImageLocation = new Point(), bottomImageLocation = new Point();
 	protected Point topDrawerLocation = new Point(), bottomDrawerLocation = new Point();
 	// The calculated bounds of the rectangle to draw when collapsed
 	protected Rectangle collapsedRectangle;

 	public CollapsableBorder(boolean isVertical, int arcWidth, IFigure parentFigure, String labelText, Image image) {
 		super(isVertical, arcWidth);
 		this.parentFigure = parentFigure;

 		this.image = image;
 		this.imageLabel = new ImageFigure(image);

 		this.collapsedImage = BPELUIPlugin.INSTANCE.getImage(IBPELUIConstants.ICON_FIGURE_COLLAPSED);
 		this.expandedImage = BPELUIPlugin.INSTANCE.getImage(IBPELUIConstants.ICON_FIGURE_EXPANDED);
 		this.expandedHeight = expandedImage.getBounds().height;
 		this.expandedWidth = expandedImage.getBounds().width;

 		this.collapsedNameLabel = new Label(labelText);
 		this.collapsedNameLabel.setFont(JFaceResources.getFontRegistry().get(JFaceResources.DEFAULT_FONT));
 	}

 	/**
 	 * Tests whether the given point is inside the collapsed image.
 	 * The superclass only knows where the collapsed image is located; if subclasses
 	 * want to do hit testing on the expanded image, they may override but may want
 	 * to call super if we are collapsed.
 	 */
 	public boolean isPointInCollapseImage(int x, int y) {
 		if (!isCollapsed()) return false;
 		Point p = new Point(x,y);
 		parentFigure.translateToRelative(p);
 		Rectangle rect = rectCollapsed.getCopy();
 		rect.expand(new Insets(1,1,1,1));
 		return rect.contains(p);
 	}

 	public boolean isCollapsed() {
 		return collapsed;
 	}

 	public void setCollapsed(boolean showCollapse) {
 		this.collapsed = showCollapse;
 	}

 	/**
 	 * Throw away computed values that determine the layout
 	 */
 	public void invalidate() {
 		// rectCollapsed = null;
 		collapsedBounds = null;
 	}

 	public Label getLabel() {
 		return collapsedNameLabel;
 	}

 	public void setName(String name) {
 		collapsedNameLabel.setText(name);
 	}

 	protected void calculate(IFigure figure) {
 		// Calculate the coordinates for collapsed state, even though
 		// we may currently be expanded.
 		if (collapsedBounds == null) {
 			collapsedBounds = figure.getBounds().getCopy();
 			this.collapsedRectangle = collapsedBounds.getCopy();

 			// Leave room on the left and right for the drawer.
 			collapsedRectangle.x += DRAWER_WIDTH;
 			collapsedRectangle.width -= DRAWER_WIDTH * 2;

 			// area for collapsed button
 			rectCollapsed = new Rectangle(collapsedBounds.x + collapsedBounds.width / 2 - expandedWidth/2, collapsedBounds.y + collapsedBounds.height - expandedHeight, expandedWidth, expandedHeight);
 		}
 	}

 	/**
 	 * This method first invalidates and recalculates any bounds, and then
 	 * paints the top and bottom drawers, as well as any markers contained within them.
 	 */
 	@Override
 	public final void paint(IFigure figure, Graphics graphics, Insets insets) {
 		invalidate();
 		calculate(figure);
 		doPaint(figure, graphics, insets);
 	}

 	/**
 	 * Subclasses should call this paint method unless there is a very good
 	 * reason for overriding its behaviour. To affect where various things
 	 * appear, override the calculate() method.
 	 */
 	protected void doPaint(IFigure figure, Graphics graphics, Insets insets) {
 		// Remember the clipping rectangle
 		Rectangle oldClip = new Rectangle();
 		oldClip = graphics.getClip(oldClip);

 		IMarker topMarker = getTopMarker();
 		IMarker bottomMarker = getBottomMarker();
 		if (topMarker != null || bottomMarker != null) {
 			ColorRegistry registry = BPELUIPlugin.INSTANCE.getColorRegistry();
 			graphics.setForegroundColor(registry.get(IBPELUIConstants.COLOR_ACTIVITY_BORDER));
 			Rectangle clippingRect;
 			if (bottomMarker == null) {
 				clippingRect = new Rectangle(topDrawerLocation.x, topDrawerLocation.y, DRAWER_WIDTH, DRAWER_HALF_HEIGHT + 1);
 			} else if (topMarker == null) {
 				clippingRect = new Rectangle(bottomDrawerLocation.x, bottomDrawerLocation.y, DRAWER_WIDTH, DRAWER_HALF_HEIGHT + 1);
 			} else {
 				clippingRect = new Rectangle(topDrawerLocation.x, topDrawerLocation.y, DRAWER_WIDTH, DRAWER_HEIGHT + 1);
 			}
 			graphics.setClip(clippingRect);
 			// -1 due to GEF
 			graphics.drawRoundRectangle(new Rectangle(topDrawerLocation.x + DRAWER_INSET, topDrawerLocation.y, DRAWER_WIDTH * 2, DRAWER_HEIGHT - 1), IBPELUIConstants.ARC_WIDTH, IBPELUIConstants.ARC_WIDTH);
 			graphics.setClip(oldClip);
 			if (bottomMarker == null || topMarker == null) {
 				graphics.drawLine(topDrawerLocation.x + DRAWER_INSET, topDrawerLocation.y + DRAWER_HALF_HEIGHT, topDrawerLocation.x + DRAWER_WIDTH, topDrawerLocation.y + DRAWER_HALF_HEIGHT);
 			}

 		}

 		// Draw the actual breakpoints
 		Image topImage = getTopImage();
 		if (topImage != null) {
 			graphics.drawImage(topImage, topImageLocation);
 		}
 		Image bottomImage = getBottomImage();
 		if (bottomImage != null) {
 			graphics.drawImage(bottomImage, bottomImageLocation);
 		}
 	}

 	/**
 	 * We only know about the gradient rectangle when we are collapsed.
 	 * TODO: Do we need a gradient rectangle when collapsed?
 	 */
 	@Override
 	protected Rectangle getGradientRect() {
 		return new Rectangle(0,0,0,0);
 	}

 	@Override
 	public boolean isPointInTopDrawer(int x, int y) {
 		if (getTopMarker() == null) return false;
 		Point p = new Point(x, y);
 		Image image = getTopImage();
 		org.eclipse.swt.graphics.Rectangle imageSize = image.getBounds();
 		Rectangle imageBounds = new Rectangle(topImageLocation.x, topImageLocation.y, imageSize.width, imageSize.height);
 		return imageBounds.contains(p);
 	}

 	@Override
 	public boolean isPointInBottomDrawer(int x, int y) {
 		if (getBottomMarker() == null) return false;
 		Point p = new Point(x, y);
 		Image image = getBottomImage();
 		org.eclipse.swt.graphics.Rectangle imageSize = image.getBounds();
 		Rectangle imageBounds = new Rectangle(bottomImageLocation.x, bottomImageLocation.y, imageSize.width, imageSize.height);
 		return imageBounds.contains(p);
 	}

 	/**
 	 * Calculate the insets when in the collapsed state. In expanded state, we don't
 	 * know how to answer. Insets don't matter in the collapsed state because there
 	 * are no children.
 	 */
 	@Override
 	public Insets getInsets(IFigure figure) {
 		return new Insets(0, 0, 0, 0);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2012 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.ui.editparts.borders;

	import org.eclipse.bpel.ui.BPELUIPlugin;
	import org.eclipse.bpel.ui.IBPELUIConstants;
	import org.eclipse.core.resources.IMarker;
	import org.eclipse.draw2d.Graphics;
	import org.eclipse.draw2d.IFigure;
	import org.eclipse.draw2d.ImageFigure;
	import org.eclipse.draw2d.Label;
	import org.eclipse.draw2d.geometry.Insets;
	import org.eclipse.draw2d.geometry.Point;
	import org.eclipse.draw2d.geometry.Rectangle;
	import org.eclipse.jface.resource.ColorRegistry;
	import org.eclipse.jface.resource.JFaceResources;
	import org.eclipse.swt.graphics.Image;


	/**
	* This border knows about collapsability. Specifically, it has icons for expand
	* and collapse, does hit testing for these icons, has an image and label to use
	* when collapsed, and does complete rendering when collapsed to look similar to
	* a leaf border (except with the addition of an expand icon).
	*
	* It does not do rendering for the expanded state. The rationale is that things
	* should look similar when collapsed (like a leaf node) but may have different
	* appearances when expanded.
	*/
	public abstract class CollapsableBorder extends GradientBorder {

	// Whether or not we are collapsed.
	private boolean collapsed = false;
	// The location of the collapsed image (+).
	protected Rectangle rectCollapsed;
	// The images for collapsed (+) and expanded (-).
	protected Image collapsedImage, expandedImage;
	// The width and height of the expanded image. Collapsed should be the same.
	protected int expandedWidth, expandedHeight;
	// The label to use when collapsed. Subclasses may also use it when expanded.
	protected Label collapsedNameLabel = null;
	// The image to use when collapsed. Subclasses may also use it when expanded.
	protected Image image;
	// The label containing the image.
	protected ImageFigure imageLabel = null;
	// Our parent figure. Used for relative location calculation.
	protected IFigure parentFigure;
	// The calculated rectangle for the collapsed border. This is null
	// when not collapsed, so subclasses shouldn't assume it's there.
	protected Rectangle collapsedBounds;
	// The calculated location of the top and bottom drawer images as well as
	// the top and bottom drawers themselves.
	protected Point topImageLocation = new Point(), bottomImageLocation = new Point();
	protected Point topDrawerLocation = new Point(), bottomDrawerLocation = new Point();
	// The calculated bounds of the rectangle to draw when collapsed
	protected Rectangle collapsedRectangle;

	public CollapsableBorder(boolean isVertical, int arcWidth, IFigure parentFigure, String labelText, Image image) {
	super(isVertical, arcWidth);
	this.parentFigure = parentFigure;

	this.image = image;
	this.imageLabel = new ImageFigure(image);

	this.collapsedImage = BPELUIPlugin.INSTANCE.getImage(IBPELUIConstants.ICON_FIGURE_COLLAPSED);
	this.expandedImage = BPELUIPlugin.INSTANCE.getImage(IBPELUIConstants.ICON_FIGURE_EXPANDED);
	this.expandedHeight = expandedImage.getBounds().height;
	this.expandedWidth = expandedImage.getBounds().width;

	this.collapsedNameLabel = new Label(labelText);
	this.collapsedNameLabel.setFont(JFaceResources.getFontRegistry().get(JFaceResources.DEFAULT_FONT));
	}

	/**
	* Tests whether the given point is inside the collapsed image.
	* The superclass only knows where the collapsed image is located; if subclasses
	* want to do hit testing on the expanded image, they may override but may want
	* to call super if we are collapsed.
	*/
	public boolean isPointInCollapseImage(int x, int y) {
	if (!isCollapsed()) return false;
	Point p = new Point(x,y);
	parentFigure.translateToRelative(p);
	Rectangle rect = rectCollapsed.getCopy();
	rect.expand(new Insets(1,1,1,1));
	return rect.contains(p);
	}

	public boolean isCollapsed() {
	return collapsed;
	}

	public void setCollapsed(boolean showCollapse) {
	this.collapsed = showCollapse;
	}

	/**
	* Throw away computed values that determine the layout
	*/
	public void invalidate() {
	// rectCollapsed = null;
	collapsedBounds = null;
	}

	public Label getLabel() {
	return collapsedNameLabel;
	}

	public void setName(String name) {
	collapsedNameLabel.setText(name);
	}

	protected void calculate(IFigure figure) {
	// Calculate the coordinates for collapsed state, even though
	// we may currently be expanded.
	if (collapsedBounds == null) {
	collapsedBounds = figure.getBounds().getCopy();
	this.collapsedRectangle = collapsedBounds.getCopy();

	// Leave room on the left and right for the drawer.
	collapsedRectangle.x += DRAWER_WIDTH;
	collapsedRectangle.width -= DRAWER_WIDTH * 2;

	// area for collapsed button
	rectCollapsed = new Rectangle(collapsedBounds.x + collapsedBounds.width / 2 - expandedWidth/2, collapsedBounds.y + collapsedBounds.height - expandedHeight, expandedWidth, expandedHeight);
	}
	}

	/**
	* This method first invalidates and recalculates any bounds, and then
	* paints the top and bottom drawers, as well as any markers contained within them.
	*/
	@Override
	public final void paint(IFigure figure, Graphics graphics, Insets insets) {
	invalidate();
	calculate(figure);
	doPaint(figure, graphics, insets);
	}

	/**
	* Subclasses should call this paint method unless there is a very good
	* reason for overriding its behaviour. To affect where various things
	* appear, override the calculate() method.
	*/
	protected void doPaint(IFigure figure, Graphics graphics, Insets insets) {
	// Remember the clipping rectangle
	Rectangle oldClip = new Rectangle();
	oldClip = graphics.getClip(oldClip);

	IMarker topMarker = getTopMarker();
	IMarker bottomMarker = getBottomMarker();
	if (topMarker != null \|\| bottomMarker != null) {
	ColorRegistry registry = BPELUIPlugin.INSTANCE.getColorRegistry();
	graphics.setForegroundColor(registry.get(IBPELUIConstants.COLOR_ACTIVITY_BORDER));
	Rectangle clippingRect;
	if (bottomMarker == null) {
	clippingRect = new Rectangle(topDrawerLocation.x, topDrawerLocation.y, DRAWER_WIDTH, DRAWER_HALF_HEIGHT + 1);
	} else if (topMarker == null) {
	clippingRect = new Rectangle(bottomDrawerLocation.x, bottomDrawerLocation.y, DRAWER_WIDTH, DRAWER_HALF_HEIGHT + 1);
	} else {
	clippingRect = new Rectangle(topDrawerLocation.x, topDrawerLocation.y, DRAWER_WIDTH, DRAWER_HEIGHT + 1);
	}
	graphics.setClip(clippingRect);
	// -1 due to GEF
	graphics.drawRoundRectangle(new Rectangle(topDrawerLocation.x + DRAWER_INSET, topDrawerLocation.y, DRAWER_WIDTH * 2, DRAWER_HEIGHT - 1), IBPELUIConstants.ARC_WIDTH, IBPELUIConstants.ARC_WIDTH);
	graphics.setClip(oldClip);
	if (bottomMarker == null \|\| topMarker == null) {
	graphics.drawLine(topDrawerLocation.x + DRAWER_INSET, topDrawerLocation.y + DRAWER_HALF_HEIGHT, topDrawerLocation.x + DRAWER_WIDTH, topDrawerLocation.y + DRAWER_HALF_HEIGHT);
	}

	}

	// Draw the actual breakpoints
	Image topImage = getTopImage();
	if (topImage != null) {
	graphics.drawImage(topImage, topImageLocation);
	}
	Image bottomImage = getBottomImage();
	if (bottomImage != null) {
	graphics.drawImage(bottomImage, bottomImageLocation);
	}
	}

	/**
	* We only know about the gradient rectangle when we are collapsed.
	* TODO: Do we need a gradient rectangle when collapsed?
	*/
	@Override
	protected Rectangle getGradientRect() {
	return new Rectangle(0,0,0,0);
	}

	@Override
	public boolean isPointInTopDrawer(int x, int y) {
	if (getTopMarker() == null) return false;
	Point p = new Point(x, y);
	Image image = getTopImage();
	org.eclipse.swt.graphics.Rectangle imageSize = image.getBounds();
	Rectangle imageBounds = new Rectangle(topImageLocation.x, topImageLocation.y, imageSize.width, imageSize.height);
	return imageBounds.contains(p);
	}

	@Override
	public boolean isPointInBottomDrawer(int x, int y) {
	if (getBottomMarker() == null) return false;
	Point p = new Point(x, y);
	Image image = getBottomImage();
	org.eclipse.swt.graphics.Rectangle imageSize = image.getBounds();
	Rectangle imageBounds = new Rectangle(bottomImageLocation.x, bottomImageLocation.y, imageSize.width, imageSize.height);
	return imageBounds.contains(p);
	}

	/**
	* Calculate the insets when in the collapsed state. In expanded state, we don't
	* know how to answer. Insets don't matter in the collapsed state because there
	* are no children.
	*/
	@Override
	public Insets getInsets(IFigure figure) {
	return new Insets(0, 0, 0, 0);
	}
	}