Back to index...

	/*
	* Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.java2d.pisces;

	import sun.awt.geom.PathConsumer2D;
	import java.awt.geom.AffineTransform;

	final class TransformingPathConsumer2D {
	public static PathConsumer2D
	transformConsumer(PathConsumer2D out,
	AffineTransform at)
	{
	if (at == null) {
	return out;
	}
	float Mxx = (float) at.getScaleX();
	float Mxy = (float) at.getShearX();
	float Mxt = (float) at.getTranslateX();
	float Myx = (float) at.getShearY();
	float Myy = (float) at.getScaleY();
	float Myt = (float) at.getTranslateY();
	if (Mxy == 0f && Myx == 0f) {
	if (Mxx == 1f && Myy == 1f) {
	if (Mxt == 0f && Myt == 0f) {
	return out;
	} else {
	return new TranslateFilter(out, Mxt, Myt);
	}
	} else {
	if (Mxt == 0f && Myt == 0f) {
	return new DeltaScaleFilter(out, Mxx, Myy);
	} else {
	return new ScaleFilter(out, Mxx, Myy, Mxt, Myt);
	}
	}
	} else if (Mxt == 0f && Myt == 0f) {
	return new DeltaTransformFilter(out, Mxx, Mxy, Myx, Myy);
	} else {
	return new TransformFilter(out, Mxx, Mxy, Mxt, Myx, Myy, Myt);
	}
	}

	public static PathConsumer2D
	deltaTransformConsumer(PathConsumer2D out,
	AffineTransform at)
	{
	if (at == null) {
	return out;
	}
	float Mxx = (float) at.getScaleX();
	float Mxy = (float) at.getShearX();
	float Myx = (float) at.getShearY();
	float Myy = (float) at.getScaleY();
	if (Mxy == 0f && Myx == 0f) {
	if (Mxx == 1f && Myy == 1f) {
	return out;
	} else {
	return new DeltaScaleFilter(out, Mxx, Myy);
	}
	} else {
	return new DeltaTransformFilter(out, Mxx, Mxy, Myx, Myy);
	}
	}

	public static PathConsumer2D
	inverseDeltaTransformConsumer(PathConsumer2D out,
	AffineTransform at)
	{
	if (at == null) {
	return out;
	}
	float Mxx = (float) at.getScaleX();
	float Mxy = (float) at.getShearX();
	float Myx = (float) at.getShearY();
	float Myy = (float) at.getScaleY();
	if (Mxy == 0f && Myx == 0f) {
	if (Mxx == 1f && Myy == 1f) {
	return out;
	} else {
	return new DeltaScaleFilter(out, 1.0f/Mxx, 1.0f/Myy);
	}
	} else {
	float det = Mxx * Myy - Mxy * Myx;
	return new DeltaTransformFilter(out,
	Myy / det,
	-Mxy / det,
	-Myx / det,
	Mxx / det);
	}
	}

	static final class TranslateFilter implements PathConsumer2D {
	private final PathConsumer2D out;
	private final float tx;
	private final float ty;

	TranslateFilter(PathConsumer2D out,
	float tx, float ty)
	{
	this.out = out;
	this.tx = tx;
	this.ty = ty;
	}

	public void moveTo(float x0, float y0) {
	out.moveTo(x0 + tx, y0 + ty);
	}

	public void lineTo(float x1, float y1) {
	out.lineTo(x1 + tx, y1 + ty);
	}

	public void quadTo(float x1, float y1,
	float x2, float y2)
	{
	out.quadTo(x1 + tx, y1 + ty,
	x2 + tx, y2 + ty);
	}

	public void curveTo(float x1, float y1,
	float x2, float y2,
	float x3, float y3)
	{
	out.curveTo(x1 + tx, y1 + ty,
	x2 + tx, y2 + ty,
	x3 + tx, y3 + ty);
	}

	public void closePath() {
	out.closePath();
	}

	public void pathDone() {
	out.pathDone();
	}

	public long getNativeConsumer() {
	return 0;
	}
	}

	static final class ScaleFilter implements PathConsumer2D {
	private final PathConsumer2D out;
	private final float sx;
	private final float sy;
	private final float tx;
	private final float ty;

	ScaleFilter(PathConsumer2D out,
	float sx, float sy, float tx, float ty)
	{
	this.out = out;
	this.sx = sx;
	this.sy = sy;
	this.tx = tx;
	this.ty = ty;
	}

	public void moveTo(float x0, float y0) {
	out.moveTo(x0 * sx + tx, y0 * sy + ty);
	}

	public void lineTo(float x1, float y1) {
	out.lineTo(x1 * sx + tx, y1 * sy + ty);
	}

	public void quadTo(float x1, float y1,
	float x2, float y2)
	{
	out.quadTo(x1 * sx + tx, y1 * sy + ty,
	x2 * sx + tx, y2 * sy + ty);
	}

	public void curveTo(float x1, float y1,
	float x2, float y2,
	float x3, float y3)
	{
	out.curveTo(x1 * sx + tx, y1 * sy + ty,
	x2 * sx + tx, y2 * sy + ty,
	x3 * sx + tx, y3 * sy + ty);
	}

	public void closePath() {
	out.closePath();
	}

	public void pathDone() {
	out.pathDone();
	}

	public long getNativeConsumer() {
	return 0;
	}
	}

	static final class TransformFilter implements PathConsumer2D {
	private final PathConsumer2D out;
	private final float Mxx;
	private final float Mxy;
	private final float Mxt;
	private final float Myx;
	private final float Myy;
	private final float Myt;

	TransformFilter(PathConsumer2D out,
	float Mxx, float Mxy, float Mxt,
	float Myx, float Myy, float Myt)
	{
	this.out = out;
	this.Mxx = Mxx;
	this.Mxy = Mxy;
	this.Mxt = Mxt;
	this.Myx = Myx;
	this.Myy = Myy;
	this.Myt = Myt;
	}

	public void moveTo(float x0, float y0) {
	out.moveTo(x0 * Mxx + y0 * Mxy + Mxt,
	x0 * Myx + y0 * Myy + Myt);
	}

	public void lineTo(float x1, float y1) {
	out.lineTo(x1 * Mxx + y1 * Mxy + Mxt,
	x1 * Myx + y1 * Myy + Myt);
	}

	public void quadTo(float x1, float y1,
	float x2, float y2)
	{
	out.quadTo(x1 * Mxx + y1 * Mxy + Mxt,
	x1 * Myx + y1 * Myy + Myt,
	x2 * Mxx + y2 * Mxy + Mxt,
	x2 * Myx + y2 * Myy + Myt);
	}

	public void curveTo(float x1, float y1,
	float x2, float y2,
	float x3, float y3)
	{
	out.curveTo(x1 * Mxx + y1 * Mxy + Mxt,
	x1 * Myx + y1 * Myy + Myt,
	x2 * Mxx + y2 * Mxy + Mxt,
	x2 * Myx + y2 * Myy + Myt,
	x3 * Mxx + y3 * Mxy + Mxt,
	x3 * Myx + y3 * Myy + Myt);
	}

	public void closePath() {
	out.closePath();
	}

	public void pathDone() {
	out.pathDone();
	}

	public long getNativeConsumer() {
	return 0;
	}
	}

	static final class DeltaScaleFilter implements PathConsumer2D {
	private final float sx, sy;
	private final PathConsumer2D out;

	public DeltaScaleFilter(PathConsumer2D out, float Mxx, float Myy) {
	sx = Mxx;
	sy = Myy;
	this.out = out;
	}

	public void moveTo(float x0, float y0) {
	out.moveTo(x0 * sx, y0 * sy);
	}

	public void lineTo(float x1, float y1) {
	out.lineTo(x1 * sx, y1 * sy);
	}

	public void quadTo(float x1, float y1,
	float x2, float y2)
	{
	out.quadTo(x1 * sx, y1 * sy,
	x2 * sx, y2 * sy);
	}

	public void curveTo(float x1, float y1,
	float x2, float y2,
	float x3, float y3)
	{
	out.curveTo(x1 * sx, y1 * sy,
	x2 * sx, y2 * sy,
	x3 * sx, y3 * sy);
	}

	public void closePath() {
	out.closePath();
	}

	public void pathDone() {
	out.pathDone();
	}

	public long getNativeConsumer() {
	return 0;
	}
	}

	static final class DeltaTransformFilter implements PathConsumer2D {
	private PathConsumer2D out;
	private final float Mxx;
	private final float Mxy;
	private final float Myx;
	private final float Myy;

	DeltaTransformFilter(PathConsumer2D out,
	float Mxx, float Mxy,
	float Myx, float Myy)
	{
	this.out = out;
	this.Mxx = Mxx;
	this.Mxy = Mxy;
	this.Myx = Myx;
	this.Myy = Myy;
	}

	public void moveTo(float x0, float y0) {
	out.moveTo(x0 * Mxx + y0 * Mxy,
	x0 * Myx + y0 * Myy);
	}

	public void lineTo(float x1, float y1) {
	out.lineTo(x1 * Mxx + y1 * Mxy,
	x1 * Myx + y1 * Myy);
	}

	public void quadTo(float x1, float y1,
	float x2, float y2)
	{
	out.quadTo(x1 * Mxx + y1 * Mxy,
	x1 * Myx + y1 * Myy,
	x2 * Mxx + y2 * Mxy,
	x2 * Myx + y2 * Myy);
	}

	public void curveTo(float x1, float y1,
	float x2, float y2,
	float x3, float y3)
	{
	out.curveTo(x1 * Mxx + y1 * Mxy,
	x1 * Myx + y1 * Myy,
	x2 * Mxx + y2 * Mxy,
	x2 * Myx + y2 * Myy,
	x3 * Mxx + y3 * Mxy,
	x3 * Myx + y3 * Myy);
	}

	public void closePath() {
	out.closePath();
	}

	public void pathDone() {
	out.pathDone();
	}

	public long getNativeConsumer() {
	return 0;
	}
	}
	}

Back to index...