com.sun.openpisces.TransformingPathConsumer2D Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of openjfx-78-backport Show documentation
Show all versions of openjfx-78-backport Show documentation
This is a backport of OpenJFX 8 to run on Java 7.
The newest version!
/*
* Copyright (c) 2007, 2013, 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 com.sun.openpisces;
import com.sun.javafx.geom.PathConsumer2D;
import com.sun.javafx.geom.transform.BaseTransform;
public abstract class TransformingPathConsumer2D implements PathConsumer2D {
protected PathConsumer2D out;
public TransformingPathConsumer2D(PathConsumer2D out) {
this.out = out;
}
public void setConsumer(PathConsumer2D out) {
this.out = out;
}
/*
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 ScaleTranslateFilter(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);
}
}
*/
public static final class FilterSet {
private TranslateFilter translater;
private DeltaScaleFilter deltascaler;
private ScaleTranslateFilter scaletranslater;
private DeltaTransformFilter deltatransformer;
private TransformFilter transformer;
public FilterSet() {
}
public PathConsumer2D getConsumer(PathConsumer2D out,
BaseTransform tx)
{
if (tx == null) {
return out;
}
float Mxx = (float) tx.getMxx();
float Mxy = (float) tx.getMxy();
float Mxt = (float) tx.getMxt();
float Myx = (float) tx.getMyx();
float Myy = (float) tx.getMyy();
float Myt = (float) tx.getMyt();
if (Mxy == 0f && Myx == 0f) {
if (Mxx == 1f && Myy == 1f) {
if (Mxt == 0f && Myt == 0f) {
return out;
} else {
if (translater == null) {
translater = new TranslateFilter(out, Mxt, Myt);
} else {
translater.set(Mxt, Myt);
}
return translater;
}
} else {
if (Mxt == 0f && Myt == 0f) {
if (deltascaler == null) {
deltascaler = new DeltaScaleFilter(out, Mxx, Myy);
} else {
deltascaler.set(Mxx, Myy);
}
return deltascaler;
} else {
if (scaletranslater == null) {
scaletranslater =
new ScaleTranslateFilter(out, Mxx, Myy, Mxt, Myt);
} else {
scaletranslater.set(Mxx, Myy, Mxt, Myt);
}
return scaletranslater;
}
}
} else if (Mxt == 0f && Myt == 0f) {
if (deltatransformer == null) {
deltatransformer =
new DeltaTransformFilter(out, Mxx, Mxy, Myx, Myy);
} else {
deltatransformer.set(Mxx, Mxy, Myx, Myy);
}
return deltatransformer;
} else {
if (transformer == null) {
transformer =
new TransformFilter(out, Mxx, Mxy, Mxt, Myx, Myy, Myt);
} else {
transformer.set(Mxx, Mxy, Mxt, Myx, Myy, Myt);
}
return transformer;
}
}
}
static final class TranslateFilter extends TransformingPathConsumer2D {
private float tx;
private float ty;
TranslateFilter(PathConsumer2D out,
float tx, float ty)
{
super(out);
set(tx, ty);
}
public void set(float tx, float ty) {
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 ScaleTranslateFilter extends TransformingPathConsumer2D {
private float sx;
private float sy;
private float tx;
private float ty;
ScaleTranslateFilter(PathConsumer2D out,
float sx, float sy, float tx, float ty)
{
super(out);
set(sx, sy, tx, ty);
}
public void set(float sx, float sy, float tx, float ty) {
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 extends TransformingPathConsumer2D {
private float Mxx;
private float Mxy;
private float Mxt;
private float Myx;
private float Myy;
private float Myt;
TransformFilter(PathConsumer2D out,
float Mxx, float Mxy, float Mxt,
float Myx, float Myy, float Myt)
{
super(out);
set(Mxx, Mxy, Mxt, Myx, Myy, Myt);
}
public void set(float Mxx, float Mxy, float Mxt,
float Myx, float Myy, float Myt)
{
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 extends TransformingPathConsumer2D {
private float sx;
private float sy;
public DeltaScaleFilter(PathConsumer2D out, float Mxx, float Myy) {
super(out);
set(Mxx, Myy);
}
public void set(float Mxx, float Myy) {
sx = Mxx;
sy = Myy;
}
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 extends TransformingPathConsumer2D {
private float Mxx;
private float Mxy;
private float Myx;
private float Myy;
DeltaTransformFilter(PathConsumer2D out,
float Mxx, float Mxy,
float Myx, float Myy)
{
super(out);
set(Mxx, Mxy, Myx, Myy);
}
public void set(float Mxx, float Mxy,
float Myx, float Myy)
{
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;
}
}
}