jfxrt

erInterpolationInterval(KeyValue paramKeyValue, double paramDouble)
    {
      super(paramKeyValue.getInterpolator());
      assert (((paramKeyValue.getTarget() instanceof WritableIntegerValue)) && ((paramKeyValue.getEndValue() instanceof Number)));
      target = ((WritableIntegerValue)paramKeyValue.getTarget());
      rightValue = ((Number)paramKeyValue.getEndValue()).intValue();
      leftValue = target.get();
    }
    
    public void interpolate(double paramDouble)
    {
      int i = rightInterpolator.interpolate(leftValue, rightValue, paramDouble);
      target.set(i);
    }
    
    public void recalculateStartValue()
    {
      leftValue = target.get();
    }
  }
  
  private static class LongInterpolationInterval
    extends InterpolationInterval
  {
    private final WritableLongValue target;
    private long leftValue;
    private final long rightValue;
    
    private LongInterpolationInterval(KeyValue paramKeyValue, double paramDouble, Object paramObject)
    {
      super(paramKeyValue.getInterpolator());
      assert (((paramKeyValue.getTarget() instanceof WritableLongValue)) && ((paramKeyValue.getEndValue() instanceof Number)) && ((paramObject instanceof Number)));
      target = ((WritableLongValue)paramKeyValue.getTarget());
      rightValue = ((Number)paramKeyValue.getEndValue()).longValue();
      leftValue = ((Number)paramObject).longValue();
    }
    
    private LongInterpolationInterval(KeyValue paramKeyValue, double paramDouble)
    {
      super(paramKeyValue.getInterpolator());
      assert (((paramKeyValue.getTarget() instanceof WritableLongValue)) && ((paramKeyValue.getEndValue() instanceof Number)));
      target = ((WritableLongValue)paramKeyValue.getTarget());
      rightValue = ((Number)paramKeyValue.getEndValue()).longValue();
      leftValue = target.get();
    }
    
    public void interpolate(double paramDouble)
    {
      long l = rightInterpolator.interpolate(leftValue, rightValue, paramDouble);
      target.set(l);
    }
    
    public void recalculateStartValue()
    {
      leftValue = target.get();
    }
  }
  
  private static class ObjectInterpolationInterval
    extends InterpolationInterval
  {
    private final WritableValue target;
    private Object leftValue;
    private final Object rightValue;
    
    private ObjectInterpolationInterval(KeyValue paramKeyValue, double paramDouble, Object paramObject)
    {
      super(paramKeyValue.getInterpolator());
      target = paramKeyValue.getTarget();
      rightValue = paramKeyValue.getEndValue();
      leftValue = paramObject;
    }
    
    private ObjectInterpolationInterval(KeyValue paramKeyValue, double paramDouble)
    {
      super(paramKeyValue.getInterpolator());
      target = paramKeyValue.getTarget();
      rightValue = paramKeyValue.getEndValue();
      leftValue = target.getValue();
    }
    
    public void interpolate(double paramDouble)
    {
      Object localObject = rightInterpolator.interpolate(leftValue, rightValue, paramDouble);
      target.setValue(localObject);
    }
    
    public void recalculateStartValue()
    {
      leftValue = target.getValue();
    }
  }
  
  private static class TangentDoubleInterpolationInterval
    extends InterpolationInterval.TangentInterpolationInterval
  {
    private final WritableDoubleValue target;
    
    private TangentDoubleInterpolationInterval(KeyValue paramKeyValue1, double paramDouble1, KeyValue paramKeyValue2, double paramDouble2)
    {
      super(paramDouble1, paramKeyValue2, paramDouble2, null);
      assert ((paramKeyValue1.getTarget() instanceof WritableDoubleValue));
      target = ((WritableDoubleValue)paramKeyValue1.getTarget());
    }
    
    private TangentDoubleInterpolationInterval(KeyValue paramKeyValue, double paramDouble)
    {
      super(paramDouble, null);
      assert ((paramKeyValue.getTarget() instanceof WritableDoubleValue));
      target = ((WritableDoubleValue)paramKeyValue.getTarget());
      recalculateStartValue(target.get());
    }
    
    public void interpolate(double paramDouble)
    {
      target.set(calculate(paramDouble));
    }
    
    public void recalculateStartValue()
    {
      recalculateStartValue(target.get());
    }
  }
  
  private static class TangentFloatInterpolationInterval
    extends InterpolationInterval.TangentInterpolationInterval
  {
    private final WritableFloatValue target;
    
    private TangentFloatInterpolationInterval(KeyValue paramKeyValue1, double paramDouble1, KeyValue paramKeyValue2, double paramDouble2)
    {
      super(paramDouble1, paramKeyValue2, paramDouble2, null);
      assert ((paramKeyValue1.getTarget() instanceof WritableFloatValue));
      target = ((WritableFloatValue)paramKeyValue1.getTarget());
    }
    
    private TangentFloatInterpolationInterval(KeyValue paramKeyValue, double paramDouble)
    {
      super(paramDouble, null);
      assert ((paramKeyValue.getTarget() instanceof WritableFloatValue));
      target = ((WritableFloatValue)paramKeyValue.getTarget());
      recalculateStartValue(target.get());
    }
    
    public void interpolate(double paramDouble)
    {
      target.set((float)calculate(paramDouble));
    }
    
    public void recalculateStartValue()
    {
      recalculateStartValue(target.get());
    }
  }
  
  private static class TangentIntegerInterpolationInterval
    extends InterpolationInterval.TangentInterpolationInterval
  {
    private final WritableIntegerValue target;
    
    private TangentIntegerInterpolationInterval(KeyValue paramKeyValue1, double paramDouble1, KeyValue paramKeyValue2, double paramDouble2)
    {
      super(paramDouble1, paramKeyValue2, paramDouble2, null);
      assert ((paramKeyValue1.getTarget() instanceof WritableIntegerValue));
      target = ((WritableIntegerValue)paramKeyValue1.getTarget());
    }
    
    private TangentIntegerInterpolationInterval(KeyValue paramKeyValue, double paramDouble)
    {
      super(paramDouble, null);
      assert ((paramKeyValue.getTarget() instanceof WritableIntegerValue));
      target = ((WritableIntegerValue)paramKeyValue.getTarget());
      recalculateStartValue(target.get());
    }
    
    public void interpolate(double paramDouble)
    {
      target.set((int)Math.round(calculate(paramDouble)));
    }
    
    public void recalculateStartValue()
    {
      recalculateStartValue(target.get());
    }
  }
  
  private static abstract class TangentInterpolationInterval
    extends InterpolationInterval
  {
    private final double duration;
    private final double p2;
    protected final double p3;
    private final NumberTangentInterpolator leftInterpolator;
    protected double p0;
    private double p1;
    
    private TangentInterpolationInterval(KeyValue paramKeyValue1, double paramDouble1, KeyValue paramKeyValue2, double paramDouble2)
    {
      super(paramKeyValue1.getInterpolator());
      assert (((paramKeyValue1.getEndValue() instanceof Number)) && ((paramKeyValue2.getEndValue() instanceof Number)));
      duration = paramDouble2;
      Interpolator localInterpolator = paramKeyValue2.getInterpolator();
      leftInterpolator = ((localInterpolator instanceof NumberTangentInterpolator) ? (NumberTangentInterpolator)localInterpolator : null);
      recalculateStartValue(((Number)paramKeyValue2.getEndValue()).doubleValue());
      Object localObject = (rightInterpolator instanceof NumberTangentInterpolator) ? (NumberTangentInterpolator)rightInterpolator : null;
      p3 = ((Number)paramKeyValue1.getEndValue()).doubleValue();
      double d = localObject == null ? 0.0D : (((NumberTangentInterpolator)localObject).getInValue() - p3) * paramDouble2 / ((NumberTangentInterpolator)localObject).getInMillis() / 3.0D;
      p2 = (p3 + d);
    }
    
    private TangentInterpolationInterval(KeyValue paramKeyValue, double paramDouble)
    {
      super(paramKeyValue.getInterpolator());
      assert ((paramKeyValue.getEndValue() instanceof Number));
      duration = paramDouble;
      leftInterpolator = null;
      Object localObject = (rightInterpolator instanceof NumberTangentInterpolator) ? (NumberTangentInterpolator)rightInterpolator : null;
      p3 = ((Number)paramKeyValue.getEndValue()).doubleValue();
      double d = localObject == null ? 0.0D : (((NumberTangentInterpolator)localObject).getInValue() - p3) * duration / ((NumberTangentInterpolator)localObject).getInMillis() / 3.0D;
      p2 = (p3 + d);
    }
    
    protected double calculate(double paramDouble)
    {
      double d1 = 1.0D - paramDouble;
      double d2 = paramDouble * paramDouble;
      double d3 = d1 * d1;
      return d3 * d1 * p0 + 3.0D * d3 * paramDouble * p1 + 3.0D * d1 * d2 * p2 + d2 * paramDouble * p3;
    }
    
    protected final void recalculateStartValue(double paramDouble)
    {
      p0 = paramDouble;
      double d = leftInterpolator == null ? 0.0D : (leftInterpolator.getOutValue() - p0) * duration / leftInterpolator.getOutMillis() / 3.0D;
      p1 = (p0 + d);
    }
  }
  
  private static class TangentLongInterpolationInterval
    extends InterpolationInterval.TangentInterpolationInterval
  {
    private final WritableLongValue target;
    
    private TangentLongInterpolationInterval(KeyValue paramKeyValue1, double paramDouble1, KeyValue paramKeyValue2, double paramDouble2)
    {
      super(paramDouble1, paramKeyValue2, paramDouble2, null);
      assert ((paramKeyValue1.getTarget() instanceof WritableLongValue));
      target = ((WritableLongValue)paramKeyValue1.getTarget());
    }
    
    private TangentLongInterpolationInterval(KeyValue paramKeyValue, double paramDouble)
    {
      super(paramDouble, null);
      assert ((paramKeyValue.getTarget() instanceof WritableLongValue));
      target = ((WritableLongValue)paramKeyValue.getTarget());
      recalculateStartValue(target.get());
    }
    
    public void interpolate(double paramDouble)
    {
      target.set(Math.round(calculate(paramDouble)));
    }
    
    public void recalculateStartValue()
    {
      recalculateStartValue(target.get());
    }
  }
}

/* Location:
 * Qualified Name:     com.sun.scenario.animation.shared.InterpolationInterval
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.animation.shared;

public abstract interface PulseReceiver
{
  public abstract void timePulse(long paramLong);
}

/* Location:
 * Qualified Name:     com.sun.scenario.animation.shared.PulseReceiver
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.animation.shared;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javafx.animation.KeyFrame;
import javafx.animation.KeyValue;
import javafx.beans.value.WritableValue;
import javafx.util.Duration;

class SimpleClipInterpolator
  extends ClipInterpolator
{
  private static final KeyFrame ZERO_FRAME = new KeyFrame(Duration.ZERO, new KeyValue[0]);
  private KeyFrame startKeyFrame;
  private KeyFrame endKeyFrame;
  private InterpolationInterval[] interval;
  private int undefinedStartValueCount;
  private double millis;
  private boolean invalid = true;
  
  SimpleClipInterpolator(KeyFrame paramKeyFrame1, KeyFrame paramKeyFrame2)
  {
    startKeyFrame = paramKeyFrame1;
    endKeyFrame = paramKeyFrame2;
  }
  
  SimpleClipInterpolator(KeyFrame paramKeyFrame)
  {
    startKeyFrame = ZERO_FRAME;
    endKeyFrame = paramKeyFrame;
  }
  
  ClipInterpolator setKeyFrames(KeyFrame[] paramArrayOfKeyFrame)
  {
    if (ClipInterpolator.getRealKeyFrameCount(paramArrayOfKeyFrame) != 2) {
      return ClipInterpolator.create(paramArrayOfKeyFrame);
    }
    if (paramArrayOfKeyFrame.length == 1)
    {
      startKeyFrame = ZERO_FRAME;
      endKeyFrame = paramArrayOfKeyFrame[0];
    }
    else
    {
      startKeyFrame = paramArrayOfKeyFrame[0];
      endKeyFrame = paramArrayOfKeyFrame[1];
    }
    invalid = true;
    return this;
  }
  
  void validate(boolean paramBoolean)
  {
    int j;
    if (invalid)
    {
      millis = endKeyFrame.getTime().toMillis();
      HashMap localHashMap = new HashMap();
      Iterator localIterator1 = endKeyFrame.getValues().iterator();
      while (localIterator1.hasNext())
      {
        KeyValue localKeyValue1 = (KeyValue)localIterator1.next();
        localHashMap.put(localKeyValue1.getTarget(), localKeyValue1);
      }
      j = localHashMap.size();
      interval = new InterpolationInterval[j];
      int k = 0;
      Iterator localIterator2 = startKeyFrame.getValues().iterator();
      KeyValue localKeyValue2;
      while (localIterator2.hasNext())
      {
        localKeyValue2 = (KeyValue)localIterator2.next();
        WritableValue localWritableValue = localKeyValue2.getTarget();
        KeyValue localKeyValue3 = (KeyValue)localHashMap.get(localWritableValue);
        if (localKeyValue3 != null)
        {
          interval[(k++)] = InterpolationInterval.create(localKeyValue3, millis, localKeyValue2, millis);
          localHashMap.remove(localWritableValue);
        }
      }
      undefinedStartValueCount = localHashMap.values().size();
      localIterator2 = localHashMap.values().iterator();
      while (localIterator2.hasNext())
      {
        localKeyValue2 = (KeyValue)localIterator2.next();
        interval[(k++)] = InterpolationInterval.create(localKeyValue2, millis);
      }
      invalid = false;
    }
    else if (paramBoolean)
    {
      int i = interval.length;
      for (j = i - undefinedStartValueCount; j < i; j++) {
        interval[j].recalculateStartValue();
      }
    }
  }
  
  void interpolate(double paramDouble)
  {
    double d = paramDouble / millis;
    int i = interval.length;
    for (int j = 0; j < i; j++) {
      interval[j].interpolate(d);
    }
  }
}

/* Location:
 * Qualified Name:     com.sun.scenario.animation.shared.SimpleClipInterpolator
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.animation.shared;

import javafx.animation.Animation;
import javafx.animation.Animation.Status;
import javafx.util.Duration;

public class SingleLoopClipEnvelope
  extends ClipEnvelope
{
  private int cycleCount;
  
  public void setRate(double paramDouble)
  {
    Animation.Status localStatus = animation.getStatus();
    if (localStatus != Animation.Status.STOPPED)
    {
      if (localStatus == Animation.Status.RUNNING) {
        setCurrentRate(Math.abs(currentRate - rate) < 1.0E-12D ? paramDouble : -paramDouble);
      }
      deltaTicks = (ticks - Math.round((ticks - deltaTicks) * paramDouble / rate));
      abortCurrentPulse();
    }
    rate = paramDouble;
  }
  
  public void setAutoReverse(boolean paramBoolean) {}
  
  protected double calculateCurrentRate()
  {
    return rate;
  }
  
  protected SingleLoopClipEnvelope(Animation paramAnimation)
  {
    super(paramAnimation);
    if (paramAnimation != null) {
      cycleCount = paramAnimation.getCycleCount();
    }
  }
  
  public boolean wasSynched()
  {
    return (super.wasSynched()) && (cycleCount != 0);
  }
  
  public ClipEnvelope setCycleDuration(Duration paramDuration)
  {
    if ((cycleCount != 1) && (!paramDuration.isIndefinite())) {
      return ClipEnvelopeFactory.create(animation);
    }
    updateCycleTicks(paramDuration);
    return this;
  }
  
  public ClipEnvelope setCycleCount(int paramInt)
  {
    if ((paramInt != 1) && (cycleTicks != Long.MAX_VALUE)) {
      return ClipEnvelopeFactory.create(animation);
    }
    cycleCount = paramInt;
    return this;
  }
  
  public void timePulse(long paramLong)
  {
    if (cycleTicks == 0L) {
      return;
    }
    aborted = false;
    inTimePulse = true;
    try
    {
      ticks = ClipEnvelope.checkBounds(deltaTicks + Math.round(paramLong * currentRate), cycleTicks);
      animation.impl_playTo(ticks, cycleTicks);
      int i = ticks == 0L ? 1 : currentRate > 0.0D ? 0 : ticks == cycleTicks ? 1 : 0;
      if ((i != 0) && (!aborted)) {
        animation.impl_finished();
      }
    }
    finally
    {
      inTimePulse = false;
    }
  }
  
  public void jumpTo(long paramLong)
  {
    if (cycleTicks == 0L) {
      return;
    }
    long l = ClipEnvelope.checkBounds(paramLong, cycleTicks);
    deltaTicks += l - ticks;
    ticks = l;
    animation.impl_jumpTo(l, cycleTicks);
    abortCurrentPulse();
  }
}

/* Location:
 * Qualified Name:     com.sun.scenario.animation.shared.SingleLoopClipEnvelope
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.animation.shared;

import javafx.animation.Animation.Status;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.util.Duration;

public class TimelineClipCore
{
  private static final int UNDEFINED_KEYFRAME = -1;
  private static final double EPSILON = 1.0E-12D;
  Timeline timeline;
  private KeyFrame[] keyFrames = new KeyFrame[0];
  private ClipInterpolator clipInterpolator;
  private boolean aborted = false;
  private int lastKF = -1;
  private double curTime = 0.0D;
  
  public TimelineClipCore(Timeline paramTimeline)
  {
    timeline = paramTimeline;
    clipInterpolator = ClipInterpolator.create(keyFrames);
  }
  
  public void setKeyFrames(KeyFrame[] paramArrayOfKeyFrame)
  {
    keyFrames = paramArrayOfKeyFrame;
    clipInterpolator = clipInterpolator.setKeyFrames(paramArrayOfKeyFrame);
  }
  
  public void notifyCurrentRateChanged()
  {
    if (timeline.getStatus() != Animation.Status.RUNNING) {
      clearLastKeyFrame();
    }
  }
  
  public void abort()
  {
    aborted = true;
  }
  
  private void clearLastKeyFrame()
  {
    lastKF = -1;
  }
  
  public void jumpTo(long paramLong)
  {
    double d = paramLong / 6.0D;
    lastKF = -1;
    curTime = d;
    if (timeline.getStatus() != Animation.Status.STOPPED) {
      clipInterpolator.interpolate(d);
    }
  }
  
  public void start(boolean paramBoolean)
  {
    clearLastKeyFrame();
    clipInterpolator.validate(paramBoolean);
    if (curTime > 0.0D) {
      clipInterpolator.interpolate(curTime);
    }
  }
  
  public void playTo(long paramLong)
  {
    double d1 = paramLong / 6.0D;
    aborted = false;
    int i = curTime <= d1 ? 1 : 0;
    int j;
    int k;
    if (i != 0)
    {
      j = keyFrames[lastKF].getTime().toMillis() <= curTime ? lastKF + 1 : lastKF == -1 ? 0 : lastKF;
      k = keyFrames.length;
      for (int m = j; m < k; m++)
      {
        double d3 = keyFrames[m].getTime().toMillis();
        if (d3 > d1)
        {
          lastKF = (m - 1);
        }
        else if (d3 >= curTime)
        {
          visitKeyFrame(m, d3);
          if (aborted) {
            break;
          }
        }
      }
    }
    else
    {
      j = keyFrames[lastKF].getTime().toMillis() >= curTime ? lastKF - 1 : lastKF == -1 ? keyFrames.length - 1 : lastKF;
      for (k = j; k >= 0; k--)
      {
        double d2 = keyFrames[k].getTime().toMillis();
        if (d2 < d1)
        {
          lastKF = (k + 1);
        }
        else if (d2 <= curTime)
        {
          visitKeyFrame(k, d2);
          if (aborted) {
            break;
          }
        }
      }
    }
    if ((!aborted) && ((lastKF == -1) || (Math.abs(keyFrames[lastKF].getTime().toMillis() - d1) > 1.0E-12D) || (keyFrames[lastKF].getOnFinished() == null)))
    {
      setTime(d1);
      clipInterpolator.interpolate(d1);
    }
  }
  
  private void setTime(double paramDouble)
  {
    curTime = paramDouble;
    timeline.impl_setCurrentTicks(Math.round(6.0D * paramDouble));
  }
  
  private void visitKeyFrame(int paramInt, double paramDouble)
  {
    if (paramInt != lastKF)
    {
      lastKF = paramInt;
      KeyFrame localKeyFrame = keyFrames[paramInt];
      EventHandler localEventHandler = localKeyFrame.getOnFinished();
      if (localEventHandler != null)
      {
        setTime(paramDouble);
        clipInterpolator.interpolate(paramDouble);
        try
        {
          localEventHandler.handle(new ActionEvent(localKeyFrame, null));
        }
        catch (Throwable localThrowable)
        {
          localThrowable.printStackTrace();
        }
      }
    }
  }
}

/* Location:
 * Qualified Name:     com.sun.scenario.animation.shared.TimelineClipCore
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.effect;

public enum AbstractShadow$ShadowMode
{
  ONE_PASS_BOX,  TWO_PASS_BOX,  THREE_PASS_BOX,  GAUSSIAN;
  
  private AbstractShadow$ShadowMode() {}
}

/* Location:
 * Qualified Name:     com.sun.scenario.effect.AbstractShadow.ShadowMode
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.effect;

public abstract class AbstractShadow
  extends CoreEffect
{
  public AbstractShadow(Effect paramEffect)
  {
    super(paramEffect);
  }
  
  public abstract ShadowMode getMode();
  
  public abstract AbstractShadow implFor(ShadowMode paramShadowMode);
  
  public abstract float getGaussianRadius();
  
  public abstract void setGaussianRadius(float paramFloat);
  
  public abstract float getGaussianWidth();
  
  public abstract void setGaussianWidth(float paramFloat);
  
  public abstract float getGaussianHeight();
  
  public abstract void setGaussianHeight(float paramFloat);
  
  public abstract float getSpread();
  
  public abstract void setSpread(float paramFloat);
  
  public abstract Color4f getColor();
  
  public abstract void setColor(Color4f paramColor4f);
  
  public abstract Effect getInput();
  
  public abstract void setInput(Effect paramEffect);
  
  public static enum ShadowMode
  {
    ONE_PASS_BOX,  TWO_PASS_BOX,  THREE_PASS_BOX,  GAUSSIAN;
    
    private ShadowMode() {}
  }
}

/* Location:
 * Qualified Name:     com.sun.scenario.effect.AbstractShadow
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.effect;

public enum Blend$Mode
{
  SRC_OVER,  SRC_IN,  SRC_OUT,  SRC_ATOP,  ADD,  MULTIPLY,  SCREEN,  OVERLAY,  DARKEN,  LIGHTEN,  COLOR_DODGE,  COLOR_BURN,  HARD_LIGHT,  SOFT_LIGHT,  DIFFERENCE,  EXCLUSION,  RED,  GREEN,  BLUE;
  
  private Blend$Mode() {}
}

/* Location:
 * Qualified Name:     com.sun.scenario.effect.Blend.Mode
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.effect;

import com.sun.javafx.geom.Point2D;
import com.sun.javafx.geom.Rectangle;
import com.sun.javafx.geom.transform.BaseTransform;
import java.util.List;

public class Blend
  extends CoreEffect
{
  private Mode mode;
  private float opacity;
  
  public Blend(Mode paramMode, Effect paramEffect1, Effect paramEffect2)
  {
    super(paramEffect1, paramEffect2);
    setMode(paramMode);
    setOpacity(1.0F);
  }
  
  public final Effect getBottomInput()
  {
    return (Effect)getInputs().get(0);
  }
  
  public void setBottomInput(Effect paramEffect)
  {
    setInput(0, paramEffect);
  }
  
  public final Effect getTopInput()
  {
    return (Effect)getInputs().get(1);
  }
  
  public void setTopInput(Effect paramEffect)
  {
    setInput(1, paramEffect);
  }
  
  public Mode getMode()
  {
    return mode;
  }
  
  public void setMode(Mode paramMode)
  {
    if (paramMode == null) {
      throw new IllegalArgumentException("Mode must be non-null");
    }
    Mode localMode = mode;
    mode = paramMode;
    updatePeerKey("Blend_" + paramMode.name());
    firePropertyChange("mode", localMode, paramMode);
  }
  
  public float getOpacity()
  {
    return opacity;
  }
  
  public void setOpacity(float paramFloat)
  {
    if ((paramFloat < 0.0F) || (paramFloat > 1.0F)) {
      throw new IllegalArgumentException("Opacity must be in the range [0,1]");
    }
    float f = opacity;
    opacity = paramFloat;
    firePropertyChange("opacity", Float.valueOf(f), Float.valueOf(paramFloat));
  }
  
  public Point2D transform(Point2D paramPoint2D, Effect paramEffect)
  {
    return getDefaultedInput(1, paramEffect).transform(paramPoint2D, paramEffect);
  }
  
  public Point2D untransform(Point2D paramPoint2D, Effect paramEffect)
  {
    return getDefaultedInput(1, paramEffect).untransform(paramPoint2D, paramEffect);
  }
  
  protected Rectangle getInputClip(int paramInt, BaseTransform paramBaseTransform, Rectangle paramRectangle)
  {
    return paramRectangle;
  }
  
  public static enum Mode
  {
    SRC_OVER,  SRC_IN,  SRC_OUT,  SRC_ATOP,  ADD,  MULTIPLY,  SCREEN,  OVERLAY,  DARKEN,  LIGHTEN,  COLOR_DODGE,  COLOR_BURN,  HARD_LIGHT,  SOFT_LIGHT,  DIFFERENCE,  EXCLUSION,  RED,  GREEN,  BLUE;
    
    private Mode() {}
  }
}

/* Location:
 * Qualified Name:     com.sun.scenario.effect.Blend
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.effect;

import com.sun.javafx.geom.Point2D;
import java.util.List;

public class Bloom
  extends DelegateEffect
{
  private final Brightpass brightpass;
  private final GaussianBlur blur;
  private final Blend blend;
  
  public Bloom()
  {
    this(DefaultInput);
  }
  
  public Bloom(Effect paramEffect)
  {
    super(paramEffect);
    brightpass = new Brightpass(paramEffect);
    blur = new GaussianBlur(10.0F, brightpass);
    Crop localCrop = new Crop(blur, paramEffect);
    blend = new Blend(Blend.Mode.ADD, paramEffect, localCrop);
  }
  
  protected Effect getDelegate()
  {
    return blend;
  }
  
  public final Effect getInput()
  {
    return (Effect)getInputs().get(0);
  }
  
  public void setInput(Effect paramEffect)
  {
    setInput(0, paramEffect);
    brightpass.setInput(paramEffect);
    blend.setBottomInput(paramEffect);
  }
  
  public float getThreshold()
  {
    return brightpass.getThreshold();
  }
  
  public void setThreshold(float paramFloat)
  {
    float f = brightpass.getThreshold();
    brightpass.setThreshold(paramFloat);
    firePropertyChange("threshold", Float.valueOf(f), Float.valueOf(paramFloat));
  }
  
  public Point2D transform(Point2D paramPoint2D, Effect paramEffect)
  {
    return getDefaultedInput(0, paramEffect).transform(paramPoint2D, paramEffect);
  }
  
  public Point2D untransform(Point2D paramPoint2D, Effect paramEffect)
  {
    return getDefaultedInput(0, paramEffect).untransform(paramPoint2D, paramEffect);
  }
}

/* Location:
 * Qualified Name:     com.sun.scenario.effect.Bloom
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.effect;

import com.sun.javafx.geom.BaseBounds;
import com.sun.javafx.geom.RectBounds;
import com.sun.javafx.geom.Rectangle;
import com.sun.javafx.geom.transform.BaseTransform;
import com.sun.scenario.effect.impl.Renderer;
import com.sun.scenario.effect.impl.state.BoxBlurState;
import java.util.List;

public class BoxBlur
  extends CoreEffect
{
  private final BoxBlurState state = new BoxBlurState();
  
  public BoxBlur()
  {
    this(1, 1);
  }
  
  public BoxBlur(int paramInt1, int paramInt2)
  {
    this(paramInt1, paramInt2, 1, DefaultInput);
  }
  
  public BoxBlur(int paramInt1, int paramInt2, int paramInt3)
  {
    this(paramInt1, paramInt2, paramInt3, DefaultInput);
  }
  
  public BoxBlur(int paramInt1, int paramInt2, int paramInt3, Effect paramEffect)
  {
    super(paramEffect);
    setHorizontalSize(paramInt1);
    setVerticalSize(paramInt2);
    setPasses(paramInt3);
  }
  
  Object getState()
  {
    return state;
  }
  
  public final Effect getInput()
  {
    return (Effect)getInputs().get(0);
  }
  
  public void setInput(Effect paramEffect)
  {
    setInput(0, paramEffect);
  }
  
  public int getHorizontalSize()
  {
    return state.getHsize();
  }
  
  public void setHorizontalSize(int paramInt)
  {
    int i = state.getHsize();
    state.setHsize(paramInt);
    firePropertyChange("hsize", Integer.valueOf(i), Integer.valueOf(paramInt));
  }
  
  public int getVerticalSize()
  {
    return state.getVsize();
  }
  
  public void setVerticalSize(int paramInt)
  {
    int i = state.getVsize();
    state.setVsize(paramInt);
    firePropertyChange("vsize", Integer.valueOf(i), Integer.valueOf(paramInt));
  }
  
  public int getPasses()
  {
    return state.getBlurPasses();
  }
  
  public void setPasses(int paramInt)
  {
    int i = state.getBlurPasses();
    state.setBlurPasses(paramInt);
    firePropertyChange("passes", Integer.valueOf(i), Integer.valueOf(paramInt));
  }
  
  public Effect.AccelType getAccelType(FilterContext paramFilterContext)
  {
    return Renderer.getRenderer(paramFilterContext).getAccelType();
  }
  
  public BaseBounds getBounds(BaseTransform paramBaseTransform, Effect paramEffect)
  {
    BaseBounds localBaseBounds = super.getBounds(null, paramEffect);
    int i = state.getKernelSize(0) / 2;
    int j = state.getKernelSize(1) / 2;
    RectBounds localRectBounds = new RectBounds(localBaseBounds.getMinX(), localBaseBounds.getMinY(), localBaseBounds.getMaxX(), localBaseBounds.getMaxY());
    localRectBounds.grow(i, j);
    return transformBounds(paramBaseTransform, localRectBounds);
  }
  
  public Rectangle getResultBounds(BaseTransform paramBaseTransform, Rectangle paramRectangle, ImageData... paramVarArgs)
  {
    Rectangle localRectangle = paramVarArgs[0].getTransformedBounds(null);
    localRectangle = state.getResultBounds(localRectangle, 0);
    localRectangle = state.getResultBounds(localRectangle, 1);
    localRectangle.intersectWith(paramRectangle);
    return localRectangle;
  }
  
  public ImageData filterImageDatas(FilterContext paramFilterContext, BaseTransform paramBaseTransform, Rectangle paramRectangle, ImageData... paramVarArgs)
  {
    return state.filterImageDatas(this, paramFilterContext, paramBaseTransform, paramRectangle, paramVarArgs);
  }
  
  public boolean operatesInUserSpace()
  {
    return true;
  }
  
  protected Rectangle getInputClip(int paramInt, BaseTransform paramBaseTransform, Rectangle paramRectangle)
  {
    if (paramRectangle != null)
    {
      int i = state.getKernelSize(0) / 2;
      int j = state.getKernelSize(1) / 2;
      if ((i | j) != 0)
      {
        paramRectangle = new Rectangle(paramRectangle);
        paramRectangle.grow(i, j);
      }
    }
    return paramRectangle;
  }
}

/* Location:
 * Qualified Name:     com.sun.scenario.effect.BoxBlur
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.effect;

class BoxShadow$1 {}

/* Location:
 * Qualified Name:     com.sun.scenario.effect.BoxShadow.1
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.effect;

import com.sun.javafx.geom.BaseBounds;
import com.sun.javafx.geom.RectBounds;
import com.sun.javafx.geom.Rectangle;
import com.sun.javafx.geom.transform.BaseTransform;
import com.sun.scenario.effect.impl.Renderer;
import com.sun.scenario.effect.impl.state.BoxShadowState;
import java.util.List;

public class BoxShadow
  extends AbstractShadow
{
  private final BoxShadowState state = new BoxShadowState();
  
  public BoxShadow()
  {
    this(1, 1);
  }
  
  public BoxShadow(int paramInt1, int paramInt2)
  {
    this(paramInt1, paramInt2, 1, DefaultInput);
  }
  
  public BoxShadow(int paramInt1, int paramInt2, int paramInt3)
  {
    this(paramInt1, paramInt2, paramInt3, DefaultInput);
  }
  
  public BoxShadow(int paramInt1, int paramInt2, int paramInt3, Effect paramEffect)
  {
    super(paramEffect);
    setHorizontalSize(paramInt1);
    setVerticalSize(paramInt2);
    setPasses(paramInt3);
    setColor(Color4f.BLACK);
    setSpread(0.0F);
  }
  
  Object getState()
  {
    return state;
  }
  
  public final Effect getInput()
  {
    return (Effect)getInputs().get(0);
  }
  
  public void setInput(Effect paramEffect)
  {
    setInput(0, paramEffect);
  }
  
  public int getHorizontalSize()
  {
    return state.getHsize();
  }
  
  public void setHorizontalSize(int paramInt)
  {
    int i = state.getHsize();
    state.setHsize(paramInt);
    firePropertyChange("hsize", Integer.valueOf(i), Integer.valueOf(paramInt));
  }
  
  public int getVerticalSize()
  {
    return state.getVsize();
  }
  
  public void setVerticalSize(int paramInt)
  {
    int i = state.getVsize();
    state.setVsize(paramInt);
    firePropertyChange("vsize", Integer.valueOf(i), Integer.valueOf(paramInt));
  }
  
  public int getPasses()
  {
    return state.getBlurPasses();
  }
  
  public void setPasses(int paramInt)
  {
    int i = state.getBlurPasses();
    state.setBlurPasses(paramInt);
    firePropertyChange("passes", Integer.valueOf(i), Integer.valueOf(paramInt));
  }
  
  public Color4f getColor()
  {
    return state.getShadowColor();
  }
  
  public void setColor(Color4f paramColor4f)
  {
    Color4f localColor4f = state.getShadowColor();
    state.setShadowColor(paramColor4f);
    firePropertyChange("color", localColor4f, paramColor4f);
  }
  
  public float getSpread()
  {
    return state.getSpread();
  }
  
  public void setSpread(float paramFloat)
  {
    float f = state.getSpread();
    state.setSpread(paramFloat);
    firePropertyChange("spread", Float.valueOf(f), Float.valueOf(paramFloat));
  }
  
  public float getGaussianRadius()
  {
    float f = (getHorizontalSize() + getVerticalSize()) / 2.0F;
    f *= 3.0F;
    return f < 1.0F ? 0.0F : (f - 1.0F) / 2.0F;
  }
  
  public float getGaussianWidth()
  {
    return getHorizontalSize() * 3.0F;
  }
  
  public float getGaussianHeight()
  {
    return getVerticalSize() * 3.0F;
  }
  
  public void setGaussianRadius(float paramFloat)
  {
    float f = paramFloat * 2.0F + 1.0F;
    setGaussianWidth(f);
    setGaussianHeight(f);
  }
  
  public void setGaussianWidth(float paramFloat)
  {
    paramFloat /= 3.0F;
    setHorizontalSize(Math.round(paramFloat));
  }
  
  public void setGaussianHeight(float paramFloat)
  {
    paramFloat /= 3.0F;
    setVerticalSize(Math.round(paramFloat));
  }
  
  public AbstractShadow.ShadowMode getMode()
  {
    switch (getPasses())
    {
    case 1: 
      return AbstractShadow.ShadowMode.ONE_PASS_BOX;
    case 2: 
      return AbstractShadow.ShadowMode.TWO_PASS_BOX;
    }
    return AbstractShadow.ShadowMode.THREE_PASS_BOX;
  }
  
  public AbstractShadow implFor(AbstractShadow.ShadowMode paramShadowMode)
  {
    switch (paramShadowMode)
    {
    case GAUSSIAN: 
      GaussianShadow localGaussianShadow = new GaussianShadow();
      localGaussianShadow.setInput(getInput());
      localGaussianShadow.setGaussianWidth(getGaussianWidth());
      localGaussianShadow.setGaussianHeight(getGaussianHeight());
      localGaussianShadow.setColor(getColor());
      localGaussianShadow.setSpread(getSpread());
      return localGaussianShadow;
    case ONE_PASS_BOX: 
      setPasses(1);
      break;
    case TWO_PASS_BOX: 
      setPasses(2);
      break;
    case THREE_PASS_BOX: 
      setPasses(3);
    }
    return this;
  }
  
  public Effect.AccelType getAccelType(FilterContext paramFilterContext)
  {
    return Renderer.getRenderer(paramFilterContext).getAccelType();
  }
  
  public BaseBounds getBounds(BaseTransform paramBaseTransform, Effect paramEffect)
  {
    BaseBounds localBaseBounds = super.getBounds(null, paramEffect);
    int i = state.getKernelSize(0) / 2;
    int j = state.getKernelSize(1) / 2;
    RectBounds localRectBounds = new RectBounds(localBaseBounds.getMinX(), localBaseBounds.getMinY(), localBaseBounds.getMaxX(), localBaseBounds.getMaxY());
    localRectBounds.grow(i, j);
    return transformBounds(paramBaseTransform, localRectBounds);
  }
  
  public Rectangle getResultBounds(BaseTransform paramBaseTransform, Rectangle paramRectangle, ImageData... paramVarArgs)
  {
    Rectangle localRectangle = paramVarArgs[0].getUntransformedBounds();
    localRectangle = state.getResultBounds(localRectangle, 0);
    localRectangle = state.getResultBounds(localRectangle, 1);
    localRectangle.intersectWith(paramRectangle);
    return localRectangle;
  }
  
  public ImageData filterImageDatas(FilterContext paramFilterContext, BaseTransform paramBaseTransform, Rectangle paramRectangle, ImageData... paramVarArgs)
  {
    return state.filterImageDatas(this, paramFilterContext, paramBaseTransform, paramRectangle, paramVarArgs);
  }
  
  public boolean operatesInUserSpace()
  {
    return true;
  }
  
  protected Rectangle getInputClip(int paramInt, BaseTransform paramBaseTransform, Rectangle paramRectangle)
  {
    if (paramRectangle != null)
    {
      int i = state.getKernelSize(0) / 2;
      int j = state.getKernelSize(1) / 2;
      if ((i | j) != 0)
      {
        paramRectangle = new Rectangle(paramRectangle);
        paramRectangle.grow(i, j);
      }
    }
    return paramRectangle;
  }
}

/* Location:
 * Qualified Name:     com.sun.scenario.effect.BoxShadow
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.effect;

import com.sun.javafx.geom.Rectangle;
import com.sun.javafx.geom.transform.BaseTransform;
import java.util.List;

public class Brightpass
  extends CoreEffect
{
  private float threshold;
  
  public Brightpass()
  {
    this(DefaultInput);
  }
  
  public Brightpass(Effect paramEffect)
  {
    super(paramEffect);
    setThreshold(0.3F);
    updatePeerKey("Brightpass");
  }
  
  public final Effect getInput()
  {
    return (Effect)getInputs().get(0);
  }
  
  public void setInput(Effect paramEffect)
  {
    setInput(0, paramEffect);
  }
  
  public float getThreshold()
  {
    return threshold;
  }
  
  public void setThreshold(float paramFloat)
  {
    if ((paramFloat < 0.0F) || (paramFloat > 1.0F)) {
      throw new IllegalArgumentException("Threshold must be in the range [0,1]");
    }
    float f = threshold;
    threshold = paramFloat;
    firePropertyChange("threshold", Float.valueOf(f), Float.valueOf(paramFloat));
  }
  
  protected Rectangle getInputClip(int paramInt, BaseTransform paramBaseTransform, Rectangle paramRectangle)
  {
    return paramRectangle;
  }
}

/* Location:
 * Qualified Name:     com.sun.scenario.effect.Brightpass
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.effect;

public final class Color4f
{
  public static final Color4f BLACK = new Color4f(0.0F, 0.0F, 0.0F, 1.0F);
  public static final Color4f WHITE = new Color4f(1.0F, 1.0F, 1.0F, 1.0F);
  private final float r;
  private final float g;
  private final float b;
  private final float a;
  
  public Color4f(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    r = paramFloat1;
    g = paramFloat2;
    b = paramFloat3;
    a = paramFloat4;
  }
  
  public float getRed()
  {
    return r;
  }
  
  public float getGreen()
  {
    return g;
  }
  
  public float getBlue()
  {
    return b;
  }
  
  public float getAlpha()
  {
    return a;
  }
  
  public float[] getPremultipliedRGBComponents()
  {
    float[] arrayOfFloat = new float[4];
    arrayOfFloat[0] = (r * a);
    arrayOfFloat[1] = (g * a);
    arrayOfFloat[2] = (b * a);
    arrayOfFloat[3] = a;
    return arrayOfFloat;
  }
}

/* Location:
 * Qualified Name:     com.sun.scenario.effect.Color4f
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.scenario.effect;

import com.sun.javafx.geom.Rectangle;
import com.sun.javafx.geom.transform.BaseTransform;
import java.util.List;

public class ColorAdjust
  extends CoreEffect
{
  private float hue = 0.0F;
  private float saturation = 0.0F;
  private float brightness = 0.0F;
  private float contrast = 0.0F;
  
  public ColorAdjust()
  {
    this(DefaultInput);
  }
  
  public ColorAdjust(Effect paramEffect)
  {
    super(paramEffect);
    updatePeerKey("ColorAdjust");
  }
  
  public final Effect getInput()
  {
    return (Effect)getInputs().get(0);
  }
  
  public void setInput(Effect paramEffect)
  {
    setInput(0, paramEffect);
  }
  
  public float getHue()
  {
    return hue;
  }
  
  public void setHue(float paramFloat)
  {
    if ((paramFloat < -1.0F) || (paramFloat > 1.0F)) {
      throw new IllegalArgumentException("Hue must be in the range [-1, 1]");
    }
    float f = hue;
    hue = paramFloat;
    firePropertyChange("hue", Float.valueOf(f), Float.valueOf(paramFloat));
  }
  
  p
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