jfxrt

 boolean almostOne(double paramDouble)
  {
    return (paramDouble < 1.00001D) && (paramDouble > 0.99999D);
  }
  
  public GeneralTransform3D copy()
  {
    GeneralTransform3D localGeneralTransform3D = new GeneralTransform3D();
    localGeneralTransform3D.set(this);
    return localGeneralTransform3D;
  }
  
  public String toString()
  {
    return mat[0] + ", " + mat[1] + ", " + mat[2] + ", " + mat[3] + "\n" + mat[4] + ", " + mat[5] + ", " + mat[6] + ", " + mat[7] + "\n" + mat[8] + ", " + mat[9] + ", " + mat[10] + ", " + mat[11] + "\n" + mat[12] + ", " + mat[13] + ", " + mat[14] + ", " + mat[15] + "\n";
  }
}

/* Location:
 * Qualified Name:     com.sun.javafx.geom.transform.GeneralTransform3D
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.geom.transform;

import com.sun.javafx.geom.BaseBounds;
import com.sun.javafx.geom.Path2D;
import com.sun.javafx.geom.Point2D;
import com.sun.javafx.geom.Rectangle;
import com.sun.javafx.geom.Shape;
import com.sun.javafx.geom.Vec3d;

public final class Identity
  extends BaseTransform
{
  public BaseTransform.Degree getDegree()
  {
    return BaseTransform.Degree.IDENTITY;
  }
  
  public int getType()
  {
    return 0;
  }
  
  public boolean isIdentity()
  {
    return true;
  }
  
  public boolean isTranslateOrIdentity()
  {
    return true;
  }
  
  public boolean is2D()
  {
    return true;
  }
  
  public double getDeterminant()
  {
    return 1.0D;
  }
  
  public Point2D transform(Point2D paramPoint2D1, Point2D paramPoint2D2)
  {
    if (paramPoint2D2 == null) {
      paramPoint2D2 = makePoint(paramPoint2D1, paramPoint2D2);
    }
    paramPoint2D2.setLocation(paramPoint2D1);
    return paramPoint2D2;
  }
  
  public Point2D inverseTransform(Point2D paramPoint2D1, Point2D paramPoint2D2)
  {
    if (paramPoint2D2 == null) {
      paramPoint2D2 = makePoint(paramPoint2D1, paramPoint2D2);
    }
    paramPoint2D2.setLocation(paramPoint2D1);
    return paramPoint2D2;
  }
  
  public Vec3d transform(Vec3d paramVec3d1, Vec3d paramVec3d2)
  {
    if (paramVec3d2 == null) {
      return new Vec3d(paramVec3d1);
    }
    paramVec3d2.set(paramVec3d1);
    return paramVec3d2;
  }
  
  public void transform(float[] paramArrayOfFloat1, int paramInt1, float[] paramArrayOfFloat2, int paramInt2, int paramInt3)
  {
    if ((paramArrayOfFloat1 != paramArrayOfFloat2) || (paramInt1 != paramInt2)) {
      System.arraycopy(paramArrayOfFloat1, paramInt1, paramArrayOfFloat2, paramInt2, paramInt3 * 2);
    }
  }
  
  public void transform(double[] paramArrayOfDouble1, int paramInt1, double[] paramArrayOfDouble2, int paramInt2, int paramInt3)
  {
    if ((paramArrayOfDouble1 != paramArrayOfDouble2) || (paramInt1 != paramInt2)) {
      System.arraycopy(paramArrayOfDouble1, paramInt1, paramArrayOfDouble2, paramInt2, paramInt3 * 2);
    }
  }
  
  public void transform(float[] paramArrayOfFloat, int paramInt1, double[] paramArrayOfDouble, int paramInt2, int paramInt3)
  {
    for (int i = 0; i < paramInt3; i++)
    {
      paramArrayOfDouble[(paramInt2++)] = paramArrayOfFloat[(paramInt1++)];
      paramArrayOfDouble[(paramInt2++)] = paramArrayOfFloat[(paramInt1++)];
    }
  }
  
  public void transform(double[] paramArrayOfDouble, int paramInt1, float[] paramArrayOfFloat, int paramInt2, int paramInt3)
  {
    for (int i = 0; i < paramInt3; i++)
    {
      paramArrayOfFloat[(paramInt2++)] = ((float)paramArrayOfDouble[(paramInt1++)]);
      paramArrayOfFloat[(paramInt2++)] = ((float)paramArrayOfDouble[(paramInt1++)]);
    }
  }
  
  public void deltaTransform(float[] paramArrayOfFloat1, int paramInt1, float[] paramArrayOfFloat2, int paramInt2, int paramInt3)
  {
    if ((paramArrayOfFloat1 != paramArrayOfFloat2) || (paramInt1 != paramInt2)) {
      System.arraycopy(paramArrayOfFloat1, paramInt1, paramArrayOfFloat2, paramInt2, paramInt3 * 2);
    }
  }
  
  public void deltaTransform(double[] paramArrayOfDouble1, int paramInt1, double[] paramArrayOfDouble2, int paramInt2, int paramInt3)
  {
    if ((paramArrayOfDouble1 != paramArrayOfDouble2) || (paramInt1 != paramInt2)) {
      System.arraycopy(paramArrayOfDouble1, paramInt1, paramArrayOfDouble2, paramInt2, paramInt3 * 2);
    }
  }
  
  public void inverseTransform(float[] paramArrayOfFloat1, int paramInt1, float[] paramArrayOfFloat2, int paramInt2, int paramInt3)
  {
    if ((paramArrayOfFloat1 != paramArrayOfFloat2) || (paramInt1 != paramInt2)) {
      System.arraycopy(paramArrayOfFloat1, paramInt1, paramArrayOfFloat2, paramInt2, paramInt3 * 2);
    }
  }
  
  public void inverseDeltaTransform(float[] paramArrayOfFloat1, int paramInt1, float[] paramArrayOfFloat2, int paramInt2, int paramInt3)
  {
    if ((paramArrayOfFloat1 != paramArrayOfFloat2) || (paramInt1 != paramInt2)) {
      System.arraycopy(paramArrayOfFloat1, paramInt1, paramArrayOfFloat2, paramInt2, paramInt3 * 2);
    }
  }
  
  public void inverseTransform(double[] paramArrayOfDouble1, int paramInt1, double[] paramArrayOfDouble2, int paramInt2, int paramInt3)
  {
    if ((paramArrayOfDouble1 != paramArrayOfDouble2) || (paramInt1 != paramInt2)) {
      System.arraycopy(paramArrayOfDouble1, paramInt1, paramArrayOfDouble2, paramInt2, paramInt3 * 2);
    }
  }
  
  public BaseBounds transform(BaseBounds paramBaseBounds1, BaseBounds paramBaseBounds2)
  {
    if (paramBaseBounds2 != paramBaseBounds1) {
      paramBaseBounds2 = paramBaseBounds2.deriveWithNewBounds(paramBaseBounds1);
    }
    return paramBaseBounds2;
  }
  
  public void transform(Rectangle paramRectangle1, Rectangle paramRectangle2)
  {
    if (paramRectangle2 != paramRectangle1) {
      paramRectangle2.setBounds(paramRectangle1);
    }
  }
  
  public BaseBounds inverseTransform(BaseBounds paramBaseBounds1, BaseBounds paramBaseBounds2)
  {
    if (paramBaseBounds2 != paramBaseBounds1) {
      paramBaseBounds2 = paramBaseBounds2.deriveWithNewBounds(paramBaseBounds1);
    }
    return paramBaseBounds2;
  }
  
  public void inverseTransform(Rectangle paramRectangle1, Rectangle paramRectangle2)
  {
    if (paramRectangle2 != paramRectangle1) {
      paramRectangle2.setBounds(paramRectangle1);
    }
  }
  
  public Shape createTransformedShape(Shape paramShape)
  {
    return new Path2D(paramShape);
  }
  
  public void setToIdentity() {}
  
  public void setTransform(BaseTransform paramBaseTransform)
  {
    if (!paramBaseTransform.isIdentity()) {
      degreeError(BaseTransform.Degree.IDENTITY);
    }
  }
  
  public void invert() {}
  
  public void restoreTransform(double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4, double paramDouble5, double paramDouble6)
  {
    if ((paramDouble1 != 1.0D) || (paramDouble2 != 0.0D) || (paramDouble3 != 0.0D) || (paramDouble4 != 1.0D) || (paramDouble5 != 0.0D) || (paramDouble6 != 0.0D)) {
      degreeError(BaseTransform.Degree.IDENTITY);
    }
  }
  
  public void restoreTransform(double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4, double paramDouble5, double paramDouble6, double paramDouble7, double paramDouble8, double paramDouble9, double paramDouble10, double paramDouble11, double paramDouble12)
  {
    if ((paramDouble1 != 1.0D) || (paramDouble2 != 0.0D) || (paramDouble3 != 0.0D) || (paramDouble4 != 0.0D) || (paramDouble5 != 0.0D) || (paramDouble6 != 1.0D) || (paramDouble7 != 0.0D) || (paramDouble8 != 0.0D) || (paramDouble9 != 0.0D) || (paramDouble10 != 0.0D) || (paramDouble11 != 1.0D) || (paramDouble12 != 0.0D)) {
      degreeError(BaseTransform.Degree.IDENTITY);
    }
  }
  
  public BaseTransform deriveWithTranslation(double paramDouble1, double paramDouble2)
  {
    return Translate2D.getInstance(paramDouble1, paramDouble2);
  }
  
  public BaseTransform deriveWithPreTranslation(double paramDouble1, double paramDouble2)
  {
    return Translate2D.getInstance(paramDouble1, paramDouble2);
  }
  
  public BaseTransform deriveWithConcatenation(double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4, double paramDouble5, double paramDouble6)
  {
    return getInstance(paramDouble1, paramDouble2, paramDouble3, paramDouble4, paramDouble5, paramDouble6);
  }
  
  public BaseTransform deriveWithConcatenation(BaseTransform paramBaseTransform)
  {
    return getInstance(paramBaseTransform);
  }
  
  public BaseTransform deriveWithPreConcatenation(BaseTransform paramBaseTransform)
  {
    return getInstance(paramBaseTransform);
  }
  
  public BaseTransform deriveWithNewTransform(BaseTransform paramBaseTransform)
  {
    return getInstance(paramBaseTransform);
  }
  
  public BaseTransform createInverse()
  {
    return this;
  }
  
  public String toString()
  {
    return "Identity[]";
  }
  
  public BaseTransform copy()
  {
    return this;
  }
  
  public boolean equals(Object paramObject)
  {
    return ((paramObject instanceof BaseTransform)) && (((BaseTransform)paramObject).isIdentity());
  }
  
  public int hashCode()
  {
    return 0;
  }
}

/* Location:
 * Qualified Name:     com.sun.javafx.geom.transform.Identity
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.geom.transform;

public class NoninvertibleTransformException
  extends Exception
{
  public NoninvertibleTransformException(String paramString)
  {
    super(paramString);
  }
}

/* Location:
 * Qualified Name:     com.sun.javafx.geom.transform.NoninvertibleTransformException
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.geom.transform;

public class SingularMatrixException
  extends RuntimeException
{
  public SingularMatrixException() {}
  
  public SingularMatrixException(String paramString)
  {
    super(paramString);
  }
}

/* Location:
 * Qualified Name:     com.sun.javafx.geom.transform.SingularMatrixException
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.geom.transform;

import com.sun.javafx.geom.BaseBounds;
import com.sun.javafx.geom.Vec3d;

public class TransformHelper
{
  public static BaseBounds general3dBoundsTransform(CanTransformVec3d paramCanTransformVec3d, BaseBounds paramBaseBounds1, BaseBounds paramBaseBounds2, Vec3d paramVec3d)
  {
    if (paramVec3d == null) {
      paramVec3d = new Vec3d();
    }
    double d1 = paramBaseBounds1.getMinX();
    double d2 = paramBaseBounds1.getMinY();
    double d3 = paramBaseBounds1.getMinZ();
    double d4 = paramBaseBounds1.getMaxX();
    double d5 = paramBaseBounds1.getMaxY();
    double d6 = paramBaseBounds1.getMaxZ();
    paramVec3d.set(d4, d5, d6);
    paramVec3d = paramCanTransformVec3d.transform(paramVec3d, paramVec3d);
    double d7 = x;
    double d8 = y;
    double d9 = z;
    double d10 = x;
    double d11 = y;
    double d12 = z;
    paramVec3d.set(d1, d5, d6);
    paramVec3d = paramCanTransformVec3d.transform(paramVec3d, paramVec3d);
    if (x > d10) {
      d10 = x;
    }
    if (y > d11) {
      d11 = y;
    }
    if (z > d12) {
      d12 = z;
    }
    if (x < d7) {
      d7 = x;
    }
    if (y < d8) {
      d8 = y;
    }
    if (z < d9) {
      d9 = z;
    }
    paramVec3d.set(d1, d2, d6);
    paramVec3d = paramCanTransformVec3d.transform(paramVec3d, paramVec3d);
    if (x > d10) {
      d10 = x;
    }
    if (y > d11) {
      d11 = y;
    }
    if (z > d12) {
      d12 = z;
    }
    if (x < d7) {
      d7 = x;
    }
    if (y < d8) {
      d8 = y;
    }
    if (z < d9) {
      d9 = z;
    }
    paramVec3d.set(d4, d2, d6);
    paramVec3d = paramCanTransformVec3d.transform(paramVec3d, paramVec3d);
    if (x > d10) {
      d10 = x;
    }
    if (y > d11) {
      d11 = y;
    }
    if (z > d12) {
      d12 = z;
    }
    if (x < d7) {
      d7 = x;
    }
    if (y < d8) {
      d8 = y;
    }
    if (z < d9) {
      d9 = z;
    }
    paramVec3d.set(d1, d5, d3);
    paramVec3d = paramCanTransformVec3d.transform(paramVec3d, paramVec3d);
    if (x > d10) {
      d10 = x;
    }
    if (y > d11) {
      d11 = y;
    }
    if (z > d12) {
      d12 = z;
    }
    if (x < d7) {
      d7 = x;
    }
    if (y < d8) {
      d8 = y;
    }
    if (z < d9) {
      d9 = z;
    }
    paramVec3d.set(d4, d5, d3);
    paramVec3d = paramCanTransformVec3d.transform(paramVec3d, paramVec3d);
    if (x > d10) {
      d10 = x;
    }
    if (y > d11) {
      d11 = y;
    }
    if (z > d12) {
      d12 = z;
    }
    if (x < d7) {
      d7 = x;
    }
    if (y < d8) {
      d8 = y;
    }
    if (z < d9) {
      d9 = z;
    }
    paramVec3d.set(d1, d2, d3);
    paramVec3d = paramCanTransformVec3d.transform(paramVec3d, paramVec3d);
    if (x > d10) {
      d10 = x;
    }
    if (y > d11) {
      d11 = y;
    }
    if (z > d12) {
      d12 = z;
    }
    if (x < d7) {
      d7 = x;
    }
    if (y < d8) {
      d8 = y;
    }
    if (z < d9) {
      d9 = z;
    }
    paramVec3d.set(d4, d2, d3);
    paramVec3d = paramCanTransformVec3d.transform(paramVec3d, paramVec3d);
    if (x > d10) {
      d10 = x;
    }
    if (y > d11) {
      d11 = y;
    }
    if (z > d12) {
      d12 = z;
    }
    if (x < d7) {
      d7 = x;
    }
    if (y < d8) {
      d8 = y;
    }
    if (z < d9) {
      d9 = z;
    }
    return paramBaseBounds2.deriveWithNewBounds((float)d7, (float)d8, (float)d9, (float)d10, (float)d11, (float)d12);
  }
}

/* Location:
 * Qualified Name:     com.sun.javafx.geom.transform.TransformHelper
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.geom.transform;

import com.sun.javafx.geom.BaseBounds;
import com.sun.javafx.geom.Path2D;
import com.sun.javafx.geom.Point2D;
import com.sun.javafx.geom.Rectangle;
import com.sun.javafx.geom.Shape;
import com.sun.javafx.geom.Vec3d;

public class Translate2D
  extends BaseTransform
{
  private double mxt;
  private double myt;
  private static final long BASE_HASH;
  
  public static BaseTransform getInstance(double paramDouble1, double paramDouble2)
  {
    if ((paramDouble1 == 0.0D) && (paramDouble2 == 0.0D)) {
      return IDENTITY_TRANSFORM;
    }
    return new Translate2D(paramDouble1, paramDouble2);
  }
  
  public Translate2D(double paramDouble1, double paramDouble2)
  {
    mxt = paramDouble1;
    myt = paramDouble2;
  }
  
  public Translate2D(BaseTransform paramBaseTransform)
  {
    if (!paramBaseTransform.isTranslateOrIdentity()) {
      degreeError(BaseTransform.Degree.TRANSLATE_2D);
    }
    mxt = paramBaseTransform.getMxt();
    myt = paramBaseTransform.getMyt();
  }
  
  public BaseTransform.Degree getDegree()
  {
    return BaseTransform.Degree.TRANSLATE_2D;
  }
  
  public double getDeterminant()
  {
    return 1.0D;
  }
  
  public double getMxt()
  {
    return mxt;
  }
  
  public double getMyt()
  {
    return myt;
  }
  
  public int getType()
  {
    return (mxt == 0.0D) && (myt == 0.0D) ? 0 : 1;
  }
  
  public boolean isIdentity()
  {
    return (mxt == 0.0D) && (myt == 0.0D);
  }
  
  public boolean isTranslateOrIdentity()
  {
    return true;
  }
  
  public boolean is2D()
  {
    return true;
  }
  
  public Point2D transform(Point2D paramPoint2D1, Point2D paramPoint2D2)
  {
    if (paramPoint2D2 == null) {
      paramPoint2D2 = makePoint(paramPoint2D1, paramPoint2D2);
    }
    paramPoint2D2.setLocation((float)(x + mxt), (float)(y + myt));
    return paramPoint2D2;
  }
  
  public Point2D inverseTransform(Point2D paramPoint2D1, Point2D paramPoint2D2)
  {
    if (paramPoint2D2 == null) {
      paramPoint2D2 = makePoint(paramPoint2D1, paramPoint2D2);
    }
    paramPoint2D2.setLocation((float)(x - mxt), (float)(y - myt));
    return paramPoint2D2;
  }
  
  public Vec3d transform(Vec3d paramVec3d1, Vec3d paramVec3d2)
  {
    if (paramVec3d2 == null) {
      paramVec3d2 = new Vec3d();
    }
    x += mxt;
    y += myt;
    z = z;
    return paramVec3d2;
  }
  
  public void transform(float[] paramArrayOfFloat1, int paramInt1, float[] paramArrayOfFloat2, int paramInt2, int paramInt3)
  {
    float f1 = (float)mxt;
    float f2 = (float)myt;
    if (paramArrayOfFloat2 == paramArrayOfFloat1)
    {
      if ((paramInt2 > paramInt1) && (paramInt2 < paramInt1 + paramInt3 * 2))
      {
        System.arraycopy(paramArrayOfFloat1, paramInt1, paramArrayOfFloat2, paramInt2, paramInt3 * 2);
        paramInt1 = paramInt2;
      }
      if ((paramInt2 == paramInt1) && (f1 == 0.0F) && (f2 == 0.0F)) {
        return;
      }
    }
    for (int i = 0; i < paramInt3; i++)
    {
      paramArrayOfFloat1[(paramInt1++)] += f1;
      paramArrayOfFloat1[(paramInt1++)] += f2;
    }
  }
  
  public void transform(double[] paramArrayOfDouble1, int paramInt1, double[] paramArrayOfDouble2, int paramInt2, int paramInt3)
  {
    double d1 = mxt;
    double d2 = myt;
    if (paramArrayOfDouble2 == paramArrayOfDouble1)
    {
      if ((paramInt2 > paramInt1) && (paramInt2 < paramInt1 + paramInt3 * 2))
      {
        System.arraycopy(paramArrayOfDouble1, paramInt1, paramArrayOfDouble2, paramInt2, paramInt3 * 2);
        paramInt1 = paramInt2;
      }
      if ((paramInt2 == paramInt1) && (d1 == 0.0D) && (d2 == 0.0D)) {
        return;
      }
    }
    for (int i = 0; i < paramInt3; i++)
    {
      paramArrayOfDouble1[(paramInt1++)] += d1;
      paramArrayOfDouble1[(paramInt1++)] += d2;
    }
  }
  
  public void transform(float[] paramArrayOfFloat, int paramInt1, double[] paramArrayOfDouble, int paramInt2, int paramInt3)
  {
    double d1 = mxt;
    double d2 = myt;
    for (int i = 0; i < paramInt3; i++)
    {
      paramArrayOfDouble[(paramInt2++)] = (paramArrayOfFloat[(paramInt1++)] + d1);
      paramArrayOfDouble[(paramInt2++)] = (paramArrayOfFloat[(paramInt1++)] + d2);
    }
  }
  
  public void transform(double[] paramArrayOfDouble, int paramInt1, float[] paramArrayOfFloat, int paramInt2, int paramInt3)
  {
    double d1 = mxt;
    double d2 = myt;
    for (int i = 0; i < paramInt3; i++)
    {
      paramArrayOfFloat[(paramInt2++)] = ((float)(paramArrayOfDouble[(paramInt1++)] + d1));
      paramArrayOfFloat[(paramInt2++)] = ((float)(paramArrayOfDouble[(paramInt1++)] + d2));
    }
  }
  
  public void deltaTransform(float[] paramArrayOfFloat1, int paramInt1, float[] paramArrayOfFloat2, int paramInt2, int paramInt3)
  {
    if ((paramArrayOfFloat1 != paramArrayOfFloat2) || (paramInt1 != paramInt2)) {
      System.arraycopy(paramArrayOfFloat1, paramInt1, paramArrayOfFloat2, paramInt2, paramInt3 * 2);
    }
  }
  
  public void deltaTransform(double[] paramArrayOfDouble1, int paramInt1, double[] paramArrayOfDouble2, int paramInt2, int paramInt3)
  {
    if ((paramArrayOfDouble1 != paramArrayOfDouble2) || (paramInt1 != paramInt2)) {
      System.arraycopy(paramArrayOfDouble1, paramInt1, paramArrayOfDouble2, paramInt2, paramInt3 * 2);
    }
  }
  
  public void inverseTransform(float[] paramArrayOfFloat1, int paramInt1, float[] paramArrayOfFloat2, int paramInt2, int paramInt3)
  {
    float f1 = (float)mxt;
    float f2 = (float)myt;
    if (paramArrayOfFloat2 == paramArrayOfFloat1)
    {
      if ((paramInt2 > paramInt1) && (paramInt2 < paramInt1 + paramInt3 * 2))
      {
        System.arraycopy(paramArrayOfFloat1, paramInt1, paramArrayOfFloat2, paramInt2, paramInt3 * 2);
        paramInt1 = paramInt2;
      }
      if ((paramInt2 == paramInt1) && (f1 == 0.0F) && (f2 == 0.0F)) {
        return;
      }
    }
    for (int i = 0; i < paramInt3; i++)
    {
      paramArrayOfFloat1[(paramInt1++)] -= f1;
      paramArrayOfFloat1[(paramInt1++)] -= f2;
    }
  }
  
  public void inverseDeltaTransform(float[] paramArrayOfFloat1, int paramInt1, float[] paramArrayOfFloat2, int paramInt2, int paramInt3)
  {
    if ((paramArrayOfFloat1 != paramArrayOfFloat2) || (paramInt1 != paramInt2)) {
      System.arraycopy(paramArrayOfFloat1, paramInt1, paramArrayOfFloat2, paramInt2, paramInt3 * 2);
    }
  }
  
  public void inverseTransform(double[] paramArrayOfDouble1, int paramInt1, double[] paramArrayOfDouble2, int paramInt2, int paramInt3)
  {
    double d1 = mxt;
    double d2 = myt;
    if (paramArrayOfDouble2 == paramArrayOfDouble1)
    {
      if ((paramInt2 > paramInt1) && (paramInt2 < paramInt1 + paramInt3 * 2))
      {
        System.arraycopy(paramArrayOfDouble1, paramInt1, paramArrayOfDouble2, paramInt2, paramInt3 * 2);
        paramInt1 = paramInt2;
      }
      if ((paramInt2 == paramInt1) && (d1 == 0.0D) && (d2 == 0.0D)) {
        return;
      }
    }
    for (int i = 0; i < paramInt3; i++)
    {
      paramArrayOfDouble1[(paramInt1++)] -= d1;
      paramArrayOfDouble1[(paramInt1++)] -= d2;
    }
  }
  
  public BaseBounds transform(BaseBounds paramBaseBounds1, BaseBounds paramBaseBounds2)
  {
    float f1 = (float)(paramBaseBounds1.getMinX() + mxt);
    float f2 = (float)(paramBaseBounds1.getMinY() + myt);
    float f3 = paramBaseBounds1.getMinZ();
    float f4 = (float)(paramBaseBounds1.getMaxX() + mxt);
    float f5 = (float)(paramBaseBounds1.getMaxY() + myt);
    float f6 = paramBaseBounds1.getMaxZ();
    return paramBaseBounds2.deriveWithNewBounds(f1, f2, f3, f4, f5, f6);
  }
  
  public void transform(Rectangle paramRectangle1, Rectangle paramRectangle2)
  {
    transform(paramRectangle1, paramRectangle2, mxt, myt);
  }
  
  public BaseBounds inverseTransform(BaseBounds paramBaseBounds1, BaseBounds paramBaseBounds2)
  {
    float f1 = (float)(paramBaseBounds1.getMinX() - mxt);
    float f2 = (float)(paramBaseBounds1.getMinY() - myt);
    float f3 = paramBaseBounds1.getMinZ();
    float f4 = (float)(paramBaseBounds1.getMaxX() - mxt);
    float f5 = (float)(paramBaseBounds1.getMaxY() - myt);
    float f6 = paramBaseBounds1.getMaxZ();
    return paramBaseBounds2.deriveWithNewBounds(f1, f2, f3, f4, f5, f6);
  }
  
  public void inverseTransform(Rectangle paramRectangle1, Rectangle paramRectangle2)
  {
    transform(paramRectangle1, paramRectangle2, -mxt, -myt);
  }
  
  static void transform(Rectangle paramRectangle1, Rectangle paramRectangle2, double paramDouble1, double paramDouble2)
  {
    int i = (int)paramDouble1;
    int j = (int)paramDouble2;
    if ((i == paramDouble1) && (j == paramDouble2))
    {
      paramRectangle2.setBounds(paramRectangle1);
      paramRectangle2.translate(i, j);
    }
    else
    {
      double d1 = x + paramDouble1;
      double d2 = y + paramDouble2;
      double d3 = Math.ceil(d1 + width);
      double d4 = Math.ceil(d2 + height);
      d1 = Math.floor(d1);
      d2 = Math.floor(d2);
      paramRectangle2.setBounds((int)d1, (int)d2, (int)(d3 - d1), (int)(d4 - d2));
    }
  }
  
  public Shape createTransformedShape(Shape paramShape)
  {
    return new Path2D(paramShape, this);
  }
  
  public void setToIdentity()
  {
    mxt = (myt = 0.0D);
  }
  
  public void setTransform(BaseTransform paramBaseTransform)
  {
    if (!paramBaseTransform.isTranslateOrIdentity()) {
      degreeError(BaseTransform.Degree.TRANSLATE_2D);
    }
    mxt = paramBaseTransform.getMxt();
    myt = paramBaseTransform.getMyt();
  }
  
  public void invert()
  {
    mxt = (-mxt);
    myt = (-myt);
  }
  
  public void restoreTransform(double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4, double paramDouble5, double paramDouble6)
  {
    if ((paramDouble1 != 1.0D) || (paramDouble2 != 0.0D) || (paramDouble3 != 0.0D) || (paramDouble4 != 1.0D)) {
      degreeError(BaseTransform.Degree.TRANSLATE_2D);
    }
    mxt = paramDouble5;
    myt = paramDouble6;
  }
  
  public void restoreTransform(double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4, double paramDouble5, double paramDouble6, double paramDouble7, double paramDouble8, double paramDouble9, double paramDouble10, double paramDouble11, double paramDouble12)
  {
    if ((paramDouble1 != 1.0D) || (paramDouble2 != 0.0D) || (paramDouble3 != 0.0D) || (paramDouble5 != 0.0D) || (paramDouble6 != 1.0D) || (paramDouble7 != 0.0D) || (paramDouble9 != 0.0D) || (paramDouble10 != 0.0D) || (paramDouble11 != 1.0D) || (paramDouble12 != 0.0D)) {
      degreeError(BaseTransform.Degree.TRANSLATE_2D);
    }
    mxt = paramDouble4;
    myt = paramDouble8;
  }
  
  public BaseTransform deriveWithTranslation(double paramDouble1, double paramDouble2)
  {
    mxt += paramDouble1;
    myt += paramDouble2;
    return this;
  }
  
  public BaseTransform deriveWithPreTranslation(double paramDouble1, double paramDouble2)
  {
    mxt += paramDouble1;
    myt += paramDouble2;
    return this;
  }
  
  public BaseTransform deriveWithConcatenation(double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4, double paramDouble5, double paramDouble6)
  {
    if ((paramDouble1 == 1.0D) && (paramDouble2 == 0.0D) && (paramDouble3 == 0.0D) && (paramDouble4 == 1.0D))
    {
      mxt += paramDouble5;
      myt += paramDouble6;
      return this;
    }
    return new Affine2D(paramDouble1, paramDouble2, paramDouble3, paramDouble4, mxt + paramDouble5, myt + paramDouble6);
  }
  
  public BaseTransform deriveWithConcatenation(BaseTransform paramBaseTransform)
  {
    if (paramBaseTransform.isTranslateOrIdentity())
    {
      mxt += paramBaseTransform.getMxt();
      myt += paramBaseTransform.getMyt();
      return this;
    }
    if (paramBaseTransform.is2D()) {
      return getInstance(paramBaseTransform.getMxx(), paramBaseTransform.getMyx(), paramBaseTransform.getMxy(), paramBaseTransform.getMyy(), mxt + paramBaseTransform.getMxt(), myt + paramBaseTransform.getMyt());
    }
    Affine3D localAffine3D = new Affine3D(paramBaseTransform);
    localAffine3D.preTranslate(mxt, myt, 0.0D);
    return localAffine3D;
  }
  
  public BaseTransform deriveWithPreConcatenation(BaseTransform paramBaseTransform)
  {
    if (paramBaseTransform.isTranslateOrIdentity())
    {
      mxt += paramBaseTransform.getMxt();
      myt += paramBaseTransform.getMyt();
      return this;
    }
    if (paramBaseTransform.is2D())
    {
      localObject = new Affine2D(paramBaseTransform);
      ((Affine2D)localObject).translate(mxt, myt);
      return (BaseTransform)localObject;
    }
    Object localObject = new Affine3D(paramBaseTransform);
    ((Affine3D)localObject).translate(mxt, myt, 0.0D);
    return (BaseTransform)localObject;
  }
  
  public BaseTransform deriveWithNewTransform(BaseTransform paramBaseTransform)
  {
    if (paramBaseTransform.isTranslateOrIdentity())
    {
      mxt = paramBaseTransform.getMxt();
      myt = paramBaseTransform.getMyt();
      return this;
    }
    return getInstance(paramBaseTransform);
  }
  
  public BaseTransform createInverse()
  {
    if (isIdentity()) {
      return IDENTITY_TRANSFORM;
    }
    return new Translate2D(-mxt, -myt);
  }
  
  private static double _matround(double paramDouble)
  {
    return Math.rint(paramDouble * 1.0E15D) / 1.0E15D;
  }
  
  public String toString()
  {
    return "Translate2D[" + _matround(mxt) + ", " + _matround(myt) + "]";
  }
  
  public BaseTransform copy()
  {
    return new Translate2D(mxt, myt);
  }
  
  public boolean equals(Object paramObject)
  {
    if ((paramObject instanceof BaseTransform))
    {
      BaseTransform localBaseTransform = (BaseTransform)paramObject;
      return (localBaseTransform.isTranslateOrIdentity()) && (localBaseTransform.getMxt() == mxt) && (localBaseTransform.getMyt() == myt);
    }
    return false;
  }
  
  public int hashCode()
  {
    if (isIdentity()) {
      return 0;
    }
    long l = BASE_HASH;
    l = l * 31L + Double.doubleToLongBits(getMyt());
    l = l * 31L + Double.doubleToLongBits(getMxt());
    return (int)l ^ (int)(l >> 32);
  }
  
  static
  {
    long l = 0L;
    l = l * 31L + Double.doubleToLongBits(IDENTITY_TRANSFORM.getMzz());
    l = l * 31L + Double.doubleToLongBits(IDENTITY_TRANSFORM.getMzy());
    l = l * 31L + Double.doubleToLongBits(IDENTITY_TRANSFORM.getMzx());
    l = l * 31L + Double.doubleToLongBits(IDENTITY_TRANSFORM.getMyz());
    l = l * 31L + Double.doubleToLongBits(IDENTITY_TRANSFORM.getMxz());
    l = l * 31L + Double.doubleToLongBits(IDENTITY_TRANSFORM.getMyy());
    l = l * 31L + Double.doubleToLongBits(IDENTITY_TRANSFORM.getMyx());
    l = l * 31L + Double.doubleToLongBits(IDENTITY_TRANSFORM.getMxy());
    l = l * 31L + Double.doubleToLongBits(IDENTITY_TRANSFORM.getMxx());
    l = l * 31L + Double.doubleToLongBits(IDENTITY_TRANSFORM.getMzt());
    BASE_HASH = l;
  }
}

/* Location:
 * Qualified Name:     com.sun.javafx.geom.transform.Translate2D
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.iio;

public abstract interface ImageFormatDescription
{
  public abstract String getFormatName();
  
  public abstract String[] getExtensions();
  
  public abstract byte[][] getSignatures();
}

/* Location:
 * Qualified Name:     com.sun.javafx.iio.ImageFormatDescription
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.iio;

import java.nio.Buffer;
import java.nio.ByteBuffer;

public class ImageFrame
{
  private ImageStorage.ImageType imageType;
  private ByteBuffer imageData;
  private int width;
  private int height;
  private int stride;
  private float pixelScale;
  private byte[][] palette;
  private ImageMetadata metadata;
  
  public ImageFrame(ImageStorage.ImageType paramImageType, ByteBuffer paramByteBuffer, int paramInt1, int paramInt2, int paramInt3, byte[][] paramArrayOfByte, ImageMetadata paramImageMetadata)
  {
    this(paramImageType, paramByteBuffer, paramInt1, paramInt2, paramInt3, paramArrayOfByte, 1.0F, paramImageMetadata);
  }
  
  public ImageFrame(ImageStorage.ImageType paramImageType, ByteBuffer paramByteBuffer, int paramInt1, int paramInt2, int paramInt3, byte[][] paramArrayOfByte, float paramFloat, ImageMetadata paramImageMetadata)
  {
    imageType = paramImageType;
    imageData = paramByteBuffer;
    width = paramInt1;
    height = paramInt2;
    stride = paramInt3;
    palette = paramArrayOfByte;
    pixelScale = paramFloat;
    metadata = paramImageMetadata;
  }
  
  public ImageStorage.ImageType getImageType()
  {
    return imageType;
  }
  
  public Buffer getImageData()
  {
    return imageData;
  }
  
  public int getWidth()
  {
    return width;
  }
  
  public int getHeight()
  {
    return height;
  }
  
  public int getStride()
  {
    return stride;
  }
  
  public byte[][] getPalette()
  {
    return palette;
  }
  
  public void setPixelScale(float paramFloat)
  {
    pixelScale = paramFloat;
  }
  
  public float getPixelScale()
  {
    return pixelScale;
  }
  
  public ImageMetadata getMetadata()
  {
    return metadata;
  }
}

/* Location:
 * Qualified Name:     com.sun.javafx.iio.ImageFrame
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.iio;

public abstract interface ImageLoadListener
{
  public abstract void imageLoadProgress(ImageLoader paramImageLoader, float paramFloat);
  
  public abstract void imageLoadWarning(ImageLoader paramImageLoader, String paramString);
  
  public abstract void imageLoadMetaData(ImageLoader paramImageLoader, ImageMetadata paramImageMetadata);
}

/* Location:
 * Qualified Name:     com.sun.javafx.iio.ImageLoadListener
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.iio;

import java.io.IOException;

public abstract interface ImageLoader
{
  public abstract ImageFormatDescription getFormatDescription();
  
  public abstract void dispose();
  
  public abstract void addListener(ImageLoadListener paramImageLoadListener);
  
  public abstract void removeListener(ImageLoadListener paramImageLoadListener);
  
  public abstract ImageFrame load(int paramInt1, int paramInt2, int paramInt3, boolean paramBoolean1, boolean paramBoolean2)
    throws IOException;
}

/* Location:
 * Qualified Name:     com.sun.javafx.iio.ImageLoader
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.iio;

import java.io.IOException;
import java.io.InputStream;

public abstract interface ImageLoaderFactory
{
  public abstract ImageFormatDescription getFormatDescription();
  
  public abstract ImageLoader createImageLoader(InputStream paramInputStream)
    throws IOException;
}

/* Location:
 * Qualified Name:     com.sun.javafx.iio.ImageLoaderFactory
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.iio;

public class ImageMetadata
{
  public final Float gamma;
  public final Boolean blackIsZero;
  public final Integer backgroundIndex;
  public final Integer backgroundColor;
  public final Integer delayTime;
  public final Integer transparentIndex;
  public final Integer imageWidth;
  public final Integer imageHeight;
  public final Integer imageLeftPosition;
  public final Integer imageTopPosition;
  public final Integer disposalMethod;
  
  public ImageMetadata(Float paramFloat, Boolean paramBoolean, Integer paramInteger1, Integer paramInteger2, Integer paramInteger3, Integer paramInteger4, Integer paramInteger5, Integer paramInteger6, Integer paramInteger7, Integer paramInteger8, Integer paramInteger9)
  {
    gamma = paramFloat;
    blackIsZero = paramBoolean;
    backgroundIndex = paramInteger1;
    backgroundColor = paramInteger2;
    transparentIndex = paramInteger3;
    delayTime = paramInteger4;
    imageWidth = paramInteger5;
    imageHeight = paramInteger6;
    imageLeftPosition = paramInteger7;
    imageTopPosition = paramInteger8;
    disposalMethod = paramInteger9;
  }
  
  public String toString()
  {
    StringBuffer localStringBuffer = new StringBuffer("[" + getClass().getName());
    if (gamma != null) {
      localStringBuffer.append(" gamma: " + gamma);
    }
    if (blackIsZero != null) {
      localStringBuffer.append(" blackIsZero: " + blackIsZero);
    }
    if (backgroundIndex != null) {
      localStringBuffer.append(" backgroundIndex: " + backgroundIndex);
    }
    if (backgroundColor != null) {
      localStringBuffer.append(" backgroundColor: " + backgroundColor);
    }
    if (delayTime != null) {
      localStringBuffer.append(" delayTime: " + delayTime);
    }
    if (transparentIndex != null) {
      localStringBuffer.append(" transparentIndex: " + transparentIndex);
    }
    if (imageWidth != null) {
      localStringBuffer.append(" imageWidth: " + imageWidth);
    }
    if (imageHeight != null) {
      localStringBuffer.append(" imageHeight: " + imageHeight);
    }
    if (imageLeftPosition != null) {
      localStringBuffer.append(" imageLeftPosition: " + imageLeftPosition);
    }
    if (imageTopPosition != null) {
      localStringBuffer.append(" imageTopPosition: " + imageTopPosition);
    }
    if (disposalMethod != null) {
      localStringBuffer.append(" disposalMethod: " + disposalMethod);
    }
    localStringBuffer.append("]");
    return localStringBuffer.toString();
  }
}

/* Location:
 * Qualified Name:     com.sun.javafx.iio.ImageMetadata
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.iio;

class ImageStorage$1 {}

/* Location:
 * Qualified Name:     com.sun.javafx.iio.ImageStorage.1
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.iio;

public enum ImageStorage$ImageType
{
  GRAY,  GRAY_ALPHA,  GRAY_ALPHA_PRE,  PALETTE,  PALETTE_ALPHA,  PALETTE_ALPHA_PRE,  PALETTE_TRANS,  RGB,  RGBA,  RGBA_PRE;
  
  private ImageStorage$ImageType() {}
}

/* Location:
 * Qualified Name:     com.sun.javafx.iio.ImageStorage.ImageType
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.iio;

import com.sun.javafx.iio.bmp.BMPImageLoaderFactory;
import com.sun.javafx.iio.common.ImageTools;
import com.sun.javafx.iio.gif.GIFImageLoaderFactory;
import com.sun.javafx.iio.jpeg.JPEGImageLoaderFactory;
import com.sun.javafx.iio.png.PNGImageLoaderFactory;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class ImageStorage
{
  private static HashMap<byte[], ImageLoaderFactory> loaderFactoriesBySignature;
  private static int maxSignatureLength = 0;
  private static ImageLoaderFactory[] loaderFactories = { GIFImageLoaderFactory.getInstance(), JPEGImageLoaderFactory.getInstance(), PNGImageLoaderFactory.getInstance(), BMPImageLoaderFactory.getInstance() };
  
  public static ImageFormatDescription[] getSupportedDescriptions()
  {
    ImageFormatDescription[] arrayOfImageFormatDescription = new ImageFormatDescription[loaderFactories.length];
    for (int i = 0; i < loaderFactories.length; i++) {
      arrayOfImageFormatDescription[i] = loaderFactories[i].getFormatDescription();
    }
    return arrayOfImageFormatDescription;
  }
  
  public static int getNumBands(ImageType paramImageType)
  {
    int i = -1;
    switch (paramImageType)
    {
    case GRAY: 
    case PALETTE: 
    case PALETTE_ALPHA: 
    case PALETTE_ALPHA_PRE: 
    case PALETTE_TRANS: 
      i = 1;
      break;
    case GRAY_ALPHA: 
    case GRAY_ALPHA_PRE: 
      i = 2;
      break;
    case RGB: 
      i = 3;
      break;
    case RGBA: 
    case RGBA_PRE: 
      i = 4;
      break;
    default: 
      throw new IllegalArgumentException("Unknown ImageType " + paramImageType);
    }
    return i;
  }
  
  public static void addImageLoaderFactory(ImageLoaderFactory paramImageLoaderFactory)
  {
    ImageFormatDescription localImageFormatDescription = paramImageLoaderFactory.getFormatDescription();
    byte[][] arrayOfByte = localImageFormatDescription.getSignatures();
    for (int i = 0; i < arrayOfByte.length; i++) {
      loaderFactoriesBySignature.put(arrayOfByte[i], paramImageLoaderFactory);
    }
  }
  
  public static ImageFrame[] loadAll(InputStream paramInputStream, ImageLoadListener paramImageLoadListener, int paramInt1, int paramInt2, boolean paramBoolean1, float paramFloat, boolean paramBoolean2)
    throws ImageStorageException
  {
    ImageLoader localImageLoader = null;
    try
    {
      localImageLoader = getLoaderBySignature(paramInputStream, paramImageLoadListener);
    }
    catch (IOException localIOException)
    {
      throw new ImageStorageException(localIOException.getMessage(), localIOException);
    }
    ImageFrame[] arrayOfImageFrame = null;
    if (localImageLoader != null) {
      arrayOfImageFrame = loadAll(localImageLoader, paramInt1, paramInt2, paramBoolean1, paramFloat, paramBoolean2);
    }
    return arrayOfImageFrame;
  }
  
  public static ImageFrame[] loadAll(String paramString, ImageLoadListener paramImageLoadListener, int paramInt1, int paramInt2, boolean paramBoolean1, float paramFloat, boolean paramBoolean2)
    throws ImageStorageException
  {
    arrayOfImageFrame = null;
    InputStream localInputStream = null;
    ImageLoader localImageLoader = null;
    try
    {
      try
      {
        if (paramFloat > 1.9F)
        {
          StringBuilder localStringBuilder = new StringBuilder();
          int i = paramString.lastIndexOf(".");
          localStringBuilder.append(paramString.substring(0, i));
          localStringBuilder.append("@2x");
          localStringBuilder.append(paramString.substring(i));
          try
          {
            localInputStream = ImageTools.createInputStream(localStringBuilder.toString());
          }
          catch (IOException localIOException3) {}
        }
        if (localInputStream == null)
        {
          localInputStream = ImageTools.createInputStream(paramString);
          paramFloat = 1.0F;
        }
        localImageLoader = getLoaderBySignature(localInputStream, paramImageLoadListener);
      }
      catch (IOException localIOException1)
      {
        throw new ImageStorageException(localIOException1.getMessage(), localIOException1);
      }
      if (localImageLoader != null) {
        arrayOfImageFrame = loadAll(localImageLoader, paramInt1, paramInt2, paramBoolean1, paramFloat, paramBoolean2);
      }
      return arrayOfImageFrame;
    }
    finally
    {
      try
      {
        if (localInputStream != null) {
          localInputStream.close();
        }
      }
      
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2017. Infinite Loop Ltd