import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void adjustAnchors(EditPart editPart) {
	if (editPart instanceof IGraphicalEditPart) {
		View view = ((IGraphicalEditPart) editPart).getNotationView();
		EList<Edge> targetEdges = view.getTargetEdges();
		for (Edge edge : targetEdges) {
			Anchor targetAnchor = edge.getTargetAnchor();
			if (targetAnchor instanceof IdentityAnchor) {
				PrecisionPoint anchorPoint = BaseSlidableAnchor.parseTerminalString(((IdentityAnchor) targetAnchor)
						.getId());
				IFigure figure = ((IGraphicalEditPart) editPart).getFigure();
				Dimension sizeBefore = figure.getBounds().getSize();
				float widthFactor = (float) (sizeBefore.width() + request.getSizeDelta().width())
						/ (float) sizeBefore.width();
				float heightFactor = (float) (sizeBefore.height() + request.getSizeDelta().height())
						/ (float) sizeBefore.height();
				PrecisionPoint newPoint = new PrecisionPoint(anchorPoint.preciseX() / widthFactor,
						anchorPoint.preciseY() / heightFactor);
				((IdentityAnchor) targetAnchor).setId(composeTerminalString(newPoint));
			}
		}
	}

}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
/**
 * This method can be overridden by clients to customize the snapping behavior.
 * 
 * @param request
 *          the <code>ChangeBoundsRequest</code> from which the move delta can be extracted and updated
 * @since 3.4
 */
protected void snapPoint(ChangeBoundsRequest request) {
	Point moveDelta = request.getMoveDelta();
	if (editpart != null && getOperationSet().size() > 0)
		snapToHelper = (SnapToHelper) editpart.getParent().getAdapter(SnapToHelper.class);
	if (snapToHelper != null && !getCurrentInput().isModKeyDown(MODIFIER_NO_SNAPPING)) {
		PrecisionRectangle baseRect = sourceRectangle.getPreciseCopy();
		PrecisionRectangle jointRect = compoundSrcRect.getPreciseCopy();
		baseRect.translate(moveDelta);
		jointRect.translate(moveDelta);

		PrecisionPoint preciseDelta = new PrecisionPoint(moveDelta);
		snapToHelper.snapPoint(request, PositionConstants.HORIZONTAL | PositionConstants.VERTICAL,
				new PrecisionRectangle[] { baseRect, jointRect }, preciseDelta);
		request.setMoveDelta(preciseDelta);
	}
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
public void setNormalizedPointList(PrecisionPointList norms) {
	this.norms = norms;
	// dimensions
	Dimension parentSize = getParent().getSize();
	int parentY = (int) (parentSize.height * ChartFigure.DESIGN_BOUNDARY_PERCENTAGE);
	int parentHeight = (int) (parentSize.height - 2*parentSize.height*ChartFigure.DESIGN_BOUNDARY_PERCENTAGE);
	PointList pointList = new PointList();
	int length = norms.size();
	int previous_x = Integer.MIN_VALUE;
	int previous_y = Integer.MIN_VALUE;
	for (int i=0; i<length; i++) {
		PrecisionPoint pt = (PrecisionPoint) norms.getPoint(i);
		int x = Math.max(0, (int)pt.preciseX());
		int y = (int)((parentHeight * (1.0 - pt.preciseY())) + parentY);
		if ((x != previous_x) || (y != previous_y)) {
			pointList.addPoint(x, y);
			previous_x = x;
			previous_y = y;
		}
	}
	setPoints(pointList);
	intArray = pointList.toIntArray();
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
@Override
public Point getPoint(Point p, int index) {
	if (index < 0 || index >= size)
	    throw new IndexOutOfBoundsException(
	    	"Index: " + index + //$NON-NLS-1$
	    	", Size: " + size); //$NON-NLS-1$
	index *= 2;
	if (p instanceof PrecisionPoint) {
		PrecisionPoint preciseP = (PrecisionPoint) p;
		preciseP.setPreciseX(points[index]);
		preciseP.setPreciseY(points[index + 1]);
		// preciseP.updateInts(); done automatically from setPreciseX/Y
	} else {
		p.x = (int)Math.floor(points[index] + 0.000000001);
		p.y = (int)Math.floor(points[index + 1] + 0.000000001);
	}
	return p;
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
@Override
public void insertPoint(Point p, int index) {
	if (bounds != null && !bounds.contains(p))
		bounds = null;
	if (index > size || index < 0)
	    throw new IndexOutOfBoundsException(
	    	"Index: " + index + //$NON-NLS-1$
	    	", Size: " + size); //$NON-NLS-1$
	index *= 2;

	int length = points.length;
	double old[] = points;
	points = new double[length + 2];
	System.arraycopy(old, 0, points, 0, index);
	System.arraycopy(old, index, points, index + 2, length - index);
	
	if (p instanceof PrecisionPoint) {
		PrecisionPoint precisionPt = (PrecisionPoint)p;
		points[index] = precisionPt.preciseX();
		points[index + 1] = precisionPt.preciseY();
	} else {
		points[index] = p.x;
		points[index + 1] = p.y;
	}
	size++;
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
@Override
public void setPoint(Point pt, int index) {
	if (index < 0 || index >= size)
	    throw new IndexOutOfBoundsException(
	    	"Index: " + index + //$NON-NLS-1$
	    	", Size: " + size); //$NON-NLS-1$
	if (bounds != null && !bounds.contains(pt))
		bounds = null;
	if (pt instanceof PrecisionPoint) {
		PrecisionPoint precisionPt = (PrecisionPoint)pt;
		points[index * 2] = precisionPt.preciseX();
		points[index * 2 + 1] = precisionPt.preciseY();
	} else {
		points[index * 2] = pt.x;
		points[index * 2 + 1] = pt.y;
	}
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
/**
 * If auto scroll (also called auto expose) is being performed, the start
 * location moves during the scroll. This method updates that location.
 */
protected void repairStartLocation() {
	if (sourceRelativeStartPoint == null)
		return;
	IFigure figure = ((GraphicalEditPart) getSourceEditPart()).getFigure();
	PrecisionPoint newStart = (PrecisionPoint) sourceRelativeStartPoint
			.getCopy();
	figure.translateToAbsolute(newStart);
	Point delta = new Point(newStart.x - getStartLocation().x, newStart.y
			- getStartLocation().y);
	setStartLocation(newStart);
	// sourceRectangle and compoundSrcRect need to be updated as well when
	// auto-scrolling
	if (sourceRectangle != null)
		sourceRectangle.translate(delta);
	if (compoundSrcRect != null)
		compoundSrcRect.translate(delta);
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
/**
 * This method can be overridden by clients to customize the snapping
 * behavior.
 * 
 * @param request
 *            the <code>ChangeBoundsRequest</code> from which the move delta
 *            can be extracted and updated
 * @since 3.4
 */
protected void snapPoint(ChangeBoundsRequest request) {
	Point moveDelta = request.getMoveDelta();
	if (snapToHelper != null && request.isSnapToEnabled()) {
		PrecisionRectangle baseRect = sourceRectangle.getPreciseCopy();
		PrecisionRectangle jointRect = compoundSrcRect.getPreciseCopy();
		baseRect.translate(moveDelta);
		jointRect.translate(moveDelta);

		PrecisionPoint preciseDelta = new PrecisionPoint(moveDelta);
		snapToHelper.snapPoint(request, PositionConstants.HORIZONTAL
				| PositionConstants.VERTICAL, new PrecisionRectangle[] {
				baseRect, jointRect }, preciseDelta);
		request.setMoveDelta(preciseDelta);
	}
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
/**
 * Calculates and returns this Bendpoint's new location.
 * 
 * @return This Bendpoint's new location
 * @since 2.0
 */
public Point getLocation() {
	PrecisionPoint a1 = new PrecisionPoint(getConnection()
			.getSourceAnchor().getReferencePoint());
	PrecisionPoint a2 = new PrecisionPoint(getConnection()
			.getTargetAnchor().getReferencePoint());

	getConnection().translateToRelative(a1);
	getConnection().translateToRelative(a2);

	return new PrecisionPoint(
			(a1.preciseX() + d1.preciseWidth()) * (1.0 - weight) + weight
					* (a2.preciseX() + d2.preciseWidth()),
			(a1.preciseY() + d1.preciseHeight()) * (1.0 - weight) + weight
					* (a2.preciseY() + d2.preciseHeight()));
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
/**
 * In this relations browser, we want the related items to be displayed in
 * concentric circles around the center of the browser window.
 */
@SuppressWarnings("unchecked")
private void setAroundCenter() {
	final Map<IItemModel, GraphicalEditPart> lRegistry = viewer.getEditPartRegistry();
	final org.eclipse.swt.graphics.Point lSize = getSize();
	final PrecisionPoint lTranslate = new PrecisionPoint(lSize.x / 2 - (RelationsConstants.ITEM_WIDTH / 2),
			(lSize.y / 2) - RelationsConstants.ITEM_HEIGHT);
	moveFigure(lRegistry, model.getCenter(), new PrecisionPoint(0, 0), lTranslate);

	final List<ItemAdapter> lRelated = model.getRelatedItems();
	int lNumber = lRelated.size();
	int lCount = 0;
	int lOffset = 0;
	final ItemPositionCalculator lCalculator = new ItemPositionCalculator(RelationsConstants.ITEM_WIDTH,
			RelationsConstants.ITEM_HEIGHT, getRadius(++lCount), lNumber);
	while (lCalculator.hasMore()) {
		lOffset = setPositions(lRegistry, lCalculator.getPositions(), lOffset, lRelated, lTranslate);
		lNumber -= lCalculator.getCount();
		lCalculator.recalculate(getRadius(++lCount), lNumber);
	}
	setPositions(lRegistry, lCalculator.getPositions(), lOffset, lRelated, lTranslate);
	oldSize = lSize;
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
public LineController ( final SymbolController controller, final Line element, final ResourceManager manager )
{
    super ( controller, manager );

    this.figure = new PolylineShape () {
        @Override
        public void addNotify ()
        {
            super.addNotify ();
            start ();
        }

        @Override
        public void removeNotify ()
        {
            stop ();
            super.removeNotify ();
        }
    };

    final PointList points = new PointList ();
    for ( final Position pos : element.getPoints () )
    {
        final Point p = new PrecisionPoint ( pos.getX (), pos.getY () );
        points.addPoint ( p );
    }
    setPoints ( points );

    controller.addElement ( element, this );

    applyCommon ( element );
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
/**
 * Set points as string
 * <p>
 * <code>
 * 1.5;2.5|1.5;2.5
 * </code>
 * </p>
 * 
 * @param points
 */
public void setPointsString ( final String pointsString )
{
    final PointList pointList = new PointList ();

    final String[] points = pointsString.split ( "\\|" );
    for ( final String point : points )
    {
        final String[] toks = point.split ( ";" );
        final PrecisionPoint p = new PrecisionPoint ( Double.parseDouble ( toks[0] ), Double.parseDouble ( toks[1] ) );
        pointList.addPoint ( p );
    }
    setPoints ( pointList );
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
public PolygonController ( final SymbolController controller, final Polygon element, final ResourceManager manager )
{
    super ( controller, manager );

    this.figure = new PolygonShape () {
        @Override
        public void addNotify ()
        {
            super.addNotify ();
            start ();
        }

        @Override
        public void removeNotify ()
        {
            stop ();
            super.removeNotify ();
        }
    };

    final PointList points = new PointList ();
    for ( final Position pos : element.getPoints () )
    {
        final Point p = new PrecisionPoint ( pos.getX (), pos.getY () );
        points.addPoint ( p );
    }
    setPoints ( points );

    controller.addElement ( element, this );

    applyCommon ( element );
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
protected String composeTerminalString(PrecisionPoint p) {
	StringBuffer s = new StringBuffer(24);
	s.append(TERMINAL_START_CHAR); // 1 char
	s.append(p.preciseX()); // 10 chars
	s.append(TERMINAL_DELIMITER_CHAR); // 1 char
	s.append(p.preciseY()); // 10 chars
	s.append(TERMINAL_END_CHAR); // 1 char
	return s.toString(); // 24 chars max (+1 for safety, i.e. for string
							// termination)
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
public Point getLocation() {
	Rectangle r = getOwner().getBounds();
	Point p = new PrecisionPoint(r.x + r.width * xOffset, r.y + r.height
			* yOffset);
	getOwner().translateToAbsolute(p);
	return p;
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
/**
 * Test for setConnectionAnchors
 */
@Test
public void setConnectionAnchorsTest() {
	Pair<String, Class<?>> A = new Pair<String, Class<?>>("ClassA",
			org.eclipse.uml2.uml.Class.class);
	Pair<String, Class<?>> B = new Pair<String, Class<?>>("ClassB",
			org.eclipse.uml2.uml.Class.class);

	List<Pair<String, Class<?>>> objects = Arrays.asList(A, B);
	List<Pair<Pair<String, Class<?>>, Pair<String, Class<?>>>> associations = Arrays
			.asList(new Pair<Pair<String, Class<?>>, Pair<String, Class<?>>>(
					A, B));

	init(objects, associations);
	@SuppressWarnings("unchecked")
	List<EditPart> eps = getDiagramEditPart().getChildren();
	ClassEditPart classAEp = (ClassEditPart) eps.get(0);
	ClassEditPart classBEp = (ClassEditPart) eps.get(1);

	@SuppressWarnings("unchecked")
	List<ConnectionEditPart> conns = classBEp.getSourceConnections();
	ConnectionEditPart assoc = conns.get(0);
	DiagramElementsModifier.setConnectionAnchors(assoc, "(1, 0.5)",
			"(0, 0.5)");

	ConnectionAnchor source = classAEp.getSourceConnectionAnchor(assoc);
	ConnectionAnchor target = classBEp.getTargetConnectionAnchor(assoc);
	Point sourceReferencePoint = ((SlidableAnchor) source)
			.getReferencePoint();
	Point targetReferencePoint = ((SlidableAnchor) target)
			.getReferencePoint();
	PrecisionPoint sourceAnchor = SlidableAnchor.getAnchorRelativeLocation(
			sourceReferencePoint, source.getOwner().getBounds());
	PrecisionPoint targetAnchor = SlidableAnchor.getAnchorRelativeLocation(
			targetReferencePoint, target.getOwner().getBounds());

	Assert.assertEquals(new PrecisionPoint(1, 0.5), sourceAnchor);
	Assert.assertEquals(new PrecisionPoint(0, 0.5), targetAnchor);
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void updatePointList() throws ProfileUpdatedException {
	final LineFigure figure = (LineFigure)getFigure();
	Profile profile = getModel().getProfile();
	PrecisionPointList pointList = null;
	if (profile != null) {
		// SPF-9109 Removed boolean check of isNumeric value that is
		// returned from createPrecisionPoints(pointList, profile). We will
		// go ahead and plot all data from the pointList.
		pointList = createPrecisionPoints(profile);
		if (pointList.size() > 0) {
			PrecisionPoint first_pt = (PrecisionPoint) pointList.getFirstPoint();
			pointList.insertPoint(new PrecisionPoint(0, first_pt.preciseY()), 0);
			
			PrecisionPoint last_pt = (PrecisionPoint) pointList.getLastPoint();
			pointList.addPrecisionPoint(figure.getParent().getBounds().width, last_pt.preciseY());
		}
	} else {
		pointList = new PrecisionPointList();
	}
	final PrecisionPointList list;
	if(profile!=null && 
			(INTERPOLATION.INSTANTANEOUS == profile.getInterpolation())) {
		// Instantaneous, no need to strip midpoints
		list = new PrecisionPointList(pointList);
	}
	else {
		list = stripRedundantMidpoints(pointList);
	}
	GEFUtils.runInDisplayThread(this, new Runnable() {
		@Override
		public void run() {
			figure.setNormalizedPointList(list);
		}
	});
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
@Override
public void addPoint(Point p) {
	if (p instanceof PrecisionPoint) {
		PrecisionPoint precisionPt = (PrecisionPoint)p;
		addPrecisionPoint(precisionPt.preciseX(), precisionPt.preciseY());
	} else {
		addPrecisionPoint(p.preciseX(), p.preciseY());
	}
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
@Override
public Point removePoint(int index) {
	bounds = null;
	if (index < 0 || index >= size)
	    throw new IndexOutOfBoundsException(
	    	"Index: " + index + //$NON-NLS-1$
	    	", Size: " + size); //$NON-NLS-1$
		
	index *= 2;
	PrecisionPoint pt = new PrecisionPoint(points[index], points[index + 1]);
	if (index != size * 2 - 2)
		System.arraycopy(points, index + 2, points, index, size * 2 - index - 2);
	size--;
	return pt;
}
 

import org.eclipse.draw2d.geometry.PrecisionPoint; //导入依赖的package包/类
@Override
public Point getBorderPoint(Point reference) {
	// 得到owner矩形，转换为绝对坐标
	Rectangle r = Rectangle.SINGLETON;
	r.setBounds(getOwner().getBounds());
	getOwner().translateToAbsolute(r);
	
	// 根据角度，计算锚点相对于owner中心点的偏移
	double dx = 0.0, dy = 0.0;
	double tan = Math.atan2(r.height, r.width);
	if(angle >= -tan && angle <= tan) {
		dx = r.width >> 1;
		dy = dx * Math.tan(angle);
	} else if(angle >= tan && angle <= Math.PI - tan) {
		dy = r.height >> 1;
		dx = dy / Math.tan(angle);
	} else if(angle <= -tan && angle >= tan - Math.PI) {
		dy = -(r.height >> 1);
		dx = dy / Math.tan(angle);
	} else {
		dx = -(r.width >> 1);
		dy = dx * Math.tan(angle);
	}

	// 得到长方形中心点，加上偏移，得到最终锚点坐标
	PrecisionPoint pp = new PrecisionPoint(r.getCenter());	
	pp.translate((int)dx, (int)dy);
	return new Point(pp);	
}