Attachment #85011 for bug #212460

Lines 1-5 Link Here

(-)src/org/eclipse/draw2d/geometry/PrecisionPoint.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2005 IBM Corporation and others.	2	* Copyright (c) 2000, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 61-69 Link Here
61	* @param y Y value	61	* @param y Y value
62	*/	62	*/
63	public PrecisionPoint(double x, double y) {	63	public PrecisionPoint(double x, double y) {
64	super(x, y);
65	preciseX = x;	64	preciseX = x;
66	preciseY = y;	65	preciseY = y;
		66	updateInts();
67	}	67	}
68		68
69	/**	69	/**




/*******************************************************************************
 * Copyright (c) 2003, 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

	height = (int)Math.floor(preciseHeight + preciseY + 0.000000001) - y;
}

/**
 * Updates this Rectangle's bounds to the minimum size which can hold both this 
 * Rectangle and the coordinate (x,y).
 * 
 * @return  <code>this</code> for convenience
 * @param x1 X coordinate
 * @param y1 Y coordinate
 * @since 3.2
 */
public PrecisionRectangle union(double x1, double y1) {
	if (x1 < preciseX) {
		preciseWidth += (preciseX - x1);
		preciseX = x1;
	} else {
		double right = preciseX + preciseWidth;
		if (x1 >= right) {
			preciseWidth = x1 - preciseX;
		}
	}
	if (y1 < preciseY) {
		preciseHeight += (preciseY - y1);
		preciseY = y1;
	} else {
		double bottom = preciseY + preciseHeight;
		if (y1 >= bottom) {
			bottom = y1 + 1;
			preciseHeight = y1 - preciseY;
		}
	}
	updateInts();
	return this;
}

/**
 * @see org.eclipse.draw2d.geometry.Rectangle#transpose()
 */
public Rectangle transpose() {
	double temp = preciseX;
	preciseX = preciseY;
	preciseY = temp;
	temp = preciseWidth;
	preciseWidth = preciseHeight;
	preciseHeight = temp;
	updateInts();
	return this;
}

/**
 * @see org.eclipse.draw2d.geometry.Rectangle#setLocation(org.eclipse.draw2d.geometry.Point)
 */
public Rectangle setLocation(Point loc) {
	if (loc instanceof PrecisionPoint) {
		PrecisionPoint preciseLoc = (PrecisionPoint) loc;
		this.preciseX = preciseLoc.preciseX;
		this.preciseY = preciseLoc.preciseY;
		updateInts();
		return this;
	} else {
		return super.setLocation(loc);
	}
}

/**
 * Returns the precise geometric centre of the rectangle
 * 
 * @return <code>PrecisionPoint</code> geometric center of the rectangle
 * @since 3.3
 */
public PrecisionPoint getPreciseCenter() {
	return new PrecisionPoint(preciseX + preciseWidth / 2.0, preciseY + preciseHeight / 2.0);
}

/**
 * Shrinks the sides of this Rectangle by the horizontal and vertical values 
 * provided as input, and returns this Rectangle for convenience. The center of 
 * this Rectangle is kept constant.
 *
 * @param h  Horizontal reduction amount
 * @param v  Vertical reduction amount
 * @return  <code>this</code> for convenience
 * @since 3.3
 */
public Rectangle shrink(double h, double v) {
	preciseX += h; 
	preciseWidth -= (h + h);
	preciseY += v; 
	preciseHeight -= (v + v);
	updateInts();
	return this;
}

/**
 * Expands the horizontal and vertical sides of this Rectangle with the values 
 * provided as input, and returns this for convenience. The location of its 
 * center is kept constant.
 * 
 * @param h  Horizontal increment
 * @param v  Vertical increment
 * @return  <code>this</code> for convenience
 * @since 3.3
 */
public Rectangle expand(double h, double v) {
	return shrink(-h, -v);
}

public Rectangle shrink(int h, int v) {
	return shrink((double)h, (double)v);
}

/**
 * Determines whether an (x,y) coordinates is contained within the rectangle
 * 
 * @param x x coordinate
 * @param y y coordinate
 * @return <code>true</code> if coordinate (x,y) is contained within the rectangle
 * @since 3.3
 */
public boolean contains(double x, double y) {
	return preciseX <= x && x <= preciseX + preciseWidth
		&& preciseY <= y && y <= preciseY + preciseHeight;
}

/**
 * @see org.eclipse.draw2d.geometry.Rectangle#contains(org.eclipse.draw2d.geometry.Point)
 */
public boolean contains(Point p) {
	if (p instanceof PrecisionPoint) {
		PrecisionPoint pt = (PrecisionPoint)p;
		return contains(pt.preciseX, pt.preciseY);
	}
	return super.contains(p);
}

}

Return to bug 212460

Lines 1-5 Link Here

(-)src/org/eclipse/draw2d/geometry/PrecisionRectangle.java (-1 / +134 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2003, 2005 IBM Corporation and others.	2	* Copyright (c) 2003, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 244-247 Link Here
244	height = (int)Math.floor(preciseHeight + preciseY + 0.000000001) - y;	244	height = (int)Math.floor(preciseHeight + preciseY + 0.000000001) - y;
245	}	245	}
246		246
		247	/**
		248	* Updates this Rectangle's bounds to the minimum size which can hold both this
		249	* Rectangle and the coordinate (x,y).
		250	*
		251	* @return <code>this</code> for convenience
		252	* @param x1 X coordinate
		253	* @param y1 Y coordinate
		254	* @since 3.2
		255	*/
		256	public PrecisionRectangle union(double x1, double y1) {
		257	if (x1 < preciseX) {
		258	preciseWidth += (preciseX - x1);
		259	preciseX = x1;
		260	} else {
		261	double right = preciseX + preciseWidth;
		262	if (x1 >= right) {
		263	preciseWidth = x1 - preciseX;
		264	}
		265	}
		266	if (y1 < preciseY) {
		267	preciseHeight += (preciseY - y1);
		268	preciseY = y1;
		269	} else {
		270	double bottom = preciseY + preciseHeight;
		271	if (y1 >= bottom) {
		272	bottom = y1 + 1;
		273	preciseHeight = y1 - preciseY;
		274	}
		275	}
		276	updateInts();
		277	return this;
		278	}
		279
		280	/**
		281	* @see org.eclipse.draw2d.geometry.Rectangle#transpose()
		282	*/
		283	public Rectangle transpose() {
		284	double temp = preciseX;
		285	preciseX = preciseY;
		286	preciseY = temp;
		287	temp = preciseWidth;
		288	preciseWidth = preciseHeight;
		289	preciseHeight = temp;
		290	updateInts();
		291	return this;
		292	}
		293
		294	/**
		295	* @see org.eclipse.draw2d.geometry.Rectangle#setLocation(org.eclipse.draw2d.geometry.Point)
		296	*/
		297	public Rectangle setLocation(Point loc) {
		298	if (loc instanceof PrecisionPoint) {
		299	PrecisionPoint preciseLoc = (PrecisionPoint) loc;
		300	this.preciseX = preciseLoc.preciseX;
		301	this.preciseY = preciseLoc.preciseY;
		302	updateInts();
		303	return this;
		304	} else {
		305	return super.setLocation(loc);
		306	}
		307	}
		308
		309	/**
		310	* Returns the precise geometric centre of the rectangle
311	*
312	* @return <code>PrecisionPoint</code> geometric center of the rectangle
313	* @since 3.3
314	*/
315	public PrecisionPoint getPreciseCenter() {
316	return new PrecisionPoint(preciseX + preciseWidth / 2.0, preciseY + preciseHeight / 2.0);
317	}
318
319	/**
320	* Shrinks the sides of this Rectangle by the horizontal and vertical values
321	* provided as input, and returns this Rectangle for convenience. The center of
322	* this Rectangle is kept constant.
323	*
324	* @param h Horizontal reduction amount
325	* @param v Vertical reduction amount
326	* @return <code>this</code> for convenience
327	* @since 3.3
328	*/
329	public Rectangle shrink(double h, double v) {
330	preciseX += h;
331	preciseWidth -= (h + h);
332	preciseY += v;
333	preciseHeight -= (v + v);
334	updateInts();
335	return this;
336	}
337
338	/**
339	* Expands the horizontal and vertical sides of this Rectangle with the values
340	* provided as input, and returns this for convenience. The location of its
341	* center is kept constant.
342	*
343	* @param h Horizontal increment
344	* @param v Vertical increment
345	* @return <code>this</code> for convenience
346	* @since 3.3
347	*/
348	public Rectangle expand(double h, double v) {
349	return shrink(-h, -v);
350	}
351
352	public Rectangle shrink(int h, int v) {
353	return shrink((double)h, (double)v);
354	}
355
356	/**
357	* Determines whether an (x,y) coordinates is contained within the rectangle
358	*
359	* @param x x coordinate
360	* @param y y coordinate
361	* @return <code>true</code> if coordinate (x,y) is contained within the rectangle
362	* @since 3.3
363	*/
364	public boolean contains(double x, double y) {
365	return preciseX <= x && x <= preciseX + preciseWidth
366	&& preciseY <= y && y <= preciseY + preciseHeight;
367	}
368
369	/**
370	* @see org.eclipse.draw2d.geometry.Rectangle#contains(org.eclipse.draw2d.geometry.Point)
371	*/
372	public boolean contains(Point p) {
373	if (p instanceof PrecisionPoint) {
374	PrecisionPoint pt = (PrecisionPoint)p;
375	return contains(pt.preciseX, pt.preciseY);
376	}
377	return super.contains(p);
378	}
379
247	}	380	}