Java PathTransition类代码示例

import javafx.animation.PathTransition; //导入依赖的package包/类
private void animate(Circle particle, Path path) {
    Random randGen = new Random();

    PathTransition pathTransition = new PathTransition(Duration.seconds(path.getElements().size() * (randGen.nextInt(30) + 30)), path, particle);
    pathTransition.setInterpolator(Interpolator.EASE_OUT);

    ScaleTransition scaleTransition = new ScaleTransition(Duration.seconds(3f), particle);
    scaleTransition.setToX(10f);
    scaleTransition.setToY(10f);
    scaleTransition.setInterpolator(Interpolator.EASE_OUT);

    FadeTransition fadeTransition = new FadeTransition(Duration.seconds(6f), particle);
    fadeTransition.setToValue(0.7);
    fadeTransition.setInterpolator(Interpolator.EASE_OUT);

    pathTransition.play();
    scaleTransition.play();
    fadeTransition.play();
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
public void applyTransition(Node node) {
    PathTransition pathTransition = new PathTransition();
    timeline = pathTransition;

    path = (Path) drawPath(140.0, 140.0, 0);
    path.setStrokeWidth(2);
    path.setStroke(Color.RED);

    path.setFill(Color.TRANSPARENT);

    pathTransition.setDuration(Duration.millis(motionDuration));
    pathTransition.setNode(node);
    //pathTransition.setPath(AnimationPath.createFromPath(path));
    pathTransition.setPath(path);
    pathTransition.setOrientation(OrientationType.ORTHOGONAL_TO_TANGENT);
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
/**
 * Reanimates the data, used when resizing occurs
 */
void reanimateData() {
	setUpAnimationPath();
	if (!animating)
		return;

	for(PathTransition p : transitions){
		p.stop();
		p.setPath(path);
		p.playFrom(new Duration(progressed));
	}

	synchronized (this) {
		progressed++;
	}
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
/**
 * Generate the path transition.
 * 
 * @param shape Shape to travel along path.
 * @param path Path to be traveled upon.
 * @param duration Duration of single animation.
 * @param delay Delay before beginning first animation.
 * @param orientation Orientation of shape during animation.
 * @return PathTransition.
 */
private PathTransition generatePathTransition(
   final Shape shape, final Path path,
   final Duration duration, final Duration delay,
   final OrientationType orientation)
{
   final PathTransition pathTransition = new PathTransition();
   pathTransition.setDuration(duration);
   pathTransition.setDelay(delay);
   pathTransition.setPath(path);
   pathTransition.setNode(shape);
   pathTransition.setOrientation(orientation);
   pathTransition.setCycleCount(Timeline.INDEFINITE);
   pathTransition.setAutoReverse(true);
   return pathTransition;
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
/**
 * Method to move a pawn along some rooms
 * @param role the role corresponding to the pawn
 * @param rooms the names of the rooms on the pawns way
 */
public void movePawn(Role role, String... rooms) {
    Pawn pawn = null;
    for (Pawn p : pawns) {
        if (p.getPlayer().getRole() == role) {
            pawn = p;
        }
    }
    if (pawn != null && rooms.length > 0) {
        PathTransition[] transitions = new PathTransition[rooms.length];
        int i = 0;
        for (String name : rooms) {
            transitions[i++] = movePawn(pawn, this.rooms.get(name));
        }
        for (i = 1; i < transitions.length; ++i) {
            final int j = i;
            transitions[i-1].setOnFinished(event -> transitions[j].play());
        }
        transitions[transitions.length-1].setOnFinished(event -> view.fireMovePawnFinished());
        transitions[0].play();
    }
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
/**
 * Method to display the movement of a card to a Deck
 * @param card the card to move
 */
private PathTransition moveToDeck(Card card) {
    StackPane deck = ownerToDeck(card.getOwner());
    Path path = new Path(new MoveTo(card.localToParent(0,0).getX() + card.getWidth()/2, card.localToParent(0,0).getY() + card.getHeight()/2),
            new LineTo(deck.localToParent(deck.getWidth()/2.,deck.getHeight()/2.).getX(), deck.localToParent(deck.getWidth()/2.,deck.getHeight()/2.).getY()));

    boolean horizontal = card.getOwner() == Owner.PROJECT_DECK || card.getOwner() == Owner.PROJECT_DISCARD;

    card.toFront();
    if (horizontal) {
        RotateTransition rotateTransition = new RotateTransition(Duration.millis(500), card);
        rotateTransition.setByAngle(-90);
        rotateTransition.play();
    }

    ScaleTransition scaleTransition = new ScaleTransition(Duration.millis(500), card);
    scaleTransition.setToX(horizontal ? deck.getScaleY() : deck.getScaleX());
    scaleTransition.setToY(horizontal ? deck.getScaleX() : deck.getScaleY());
    scaleTransition.play();

    card.setClickable(false, view);

    return new PathTransition(Duration.seconds(.5),path,card);
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
/**
 * Animates card movements.
 *
 * @param card     The card view to animate.
 * @param sourceX  Source X coordinate of the card view.
 * @param sourceY  Source Y coordinate of the card view.
 * @param targetX  Destination X coordinate of the card view.
 * @param targetY  Destination Y coordinate of the card view.
 * @param duration The duration of the animation.
 * @param doAfter  The action to perform after the animation has been completed.
 */
private void animateCardMovement(
    CardView card, double sourceX, double sourceY,
    double targetX, double targetY, Duration duration,
    EventHandler<ActionEvent> doAfter) {

  Path path = new Path();
  path.getElements().add(new MoveToAbs(card, sourceX, sourceY));
  path.getElements().add(new LineToAbs(card, targetX, targetY));

  PathTransition pathTransition =
      new PathTransition(duration, path, card);
  pathTransition.setInterpolator(Interpolator.EASE_IN);
  pathTransition.setOnFinished(doAfter);

  Timeline blurReset = new Timeline();
  KeyValue bx = new KeyValue(card.getDropShadow().offsetXProperty(), 0, Interpolator.EASE_IN);
  KeyValue by = new KeyValue(card.getDropShadow().offsetYProperty(), 0, Interpolator.EASE_IN);
  KeyValue br = new KeyValue(card.getDropShadow().radiusProperty(), 2, Interpolator.EASE_IN);
  KeyFrame bKeyFrame = new KeyFrame(duration, bx, by, br);
  blurReset.getKeyFrames().add(bKeyFrame);

  ParallelTransition pt = new ParallelTransition(card, pathTransition, blurReset);
  pt.play();
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
public AnimationTile(Pane pane, TraducteurBoard trad){
    hex = new Hexagon(); 
    polygon = new Polygon();
    calculPolygon();        
    pathAnimation = new PathTransition();
    if(OptionManager.isAnimationsEnable())
        pathAnimation.setDuration(Duration.seconds(1));
    else
        pathAnimation.setDuration(Duration.seconds(0));
    pathAnimation.setNode(polygon);
    panCanvas = pane;
    traductor = trad;
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
private static void slice(Node node, double layoutFromX, double layoutFromY, double layoutToX, double layoutToY,
                          double opacity, EventHandler<ActionEvent> handler) {
    FadeTransition fadeTransition = new FadeTransition(Duration.millis(200), node);
    fadeTransition.setFromValue(opacity);
    fadeTransition.setToValue(1D - opacity);
    Path path = new Path();
    path.getElements().add(new MoveTo(node.getLayoutX() + layoutToX, node.getLayoutY() + layoutToY));
    node.setLayoutX(node.getLayoutX() + layoutFromX);
    node.setLayoutY(node.getLayoutY() + layoutFromY);
    PathTransition pathTransition = new PathTransition(Duration.millis(200), path, node);
    ParallelTransition parallelTransition = new ParallelTransition(fadeTransition, pathTransition);
    parallelTransition.setOnFinished(handler);
    parallelTransition.play();
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
private void toMove(){
    for (Line line : curLines) {
        Circle circle = new Circle(line.getStartX(), line.getStartY(), 7, Color.ORANGE);

        Path curPath = new Path();
        curPath.getElements().add(new MoveTo(line.getStartX(),line.getStartY()));
        curPath.getElements().add(new CubicCurveTo(0.5 * (line.getStartX() + line.getEndX()),
                0.5 * (line.getEndY() + line.getStartY()), 0.3*line.getStartX()+0.7*line.getEndX(),
                0.3*line.getStartY()+0.7*line.getEndY(), line.getEndX(), line.getEndY()));

        PathTransition curPathTransition = new PathTransition();
        curPathTransition.setDuration(Duration.millis(line.getBaselineOffset() / (down_canvas.getPrefWidth() / 2) * 30000));
        curPathTransition.setPath(curPath);
        curPathTransition.setNode(circle);
        curPathTransition.setOrientation(PathTransition.OrientationType.ORTHOGONAL_TO_TANGENT);
        curPathTransition.setCycleCount(Timeline.INDEFINITE);
        curPathTransition.setAutoReverse(false);
        curPathTransition.play();

        down_canvas.getChildren().addAll(circle,curPath);
        if (curLines == downLines)
            downCircles.add(circle);
        else
            mergeCircles.add(circle);

    }
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
private Animation makeAnimation (Node agent, int x, int y, int z) {
    // create something to follow
    Path path = new Path();
    path.getElements().addAll(new MoveTo(x, y), new VLineTo(z));
    // create an animation where the shape follows a path
    PathTransition pt = new PathTransition(Duration.millis(4000), path, agent);

    // put them together in order
    return new SequentialTransition(agent, pt);
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
@Override
protected void initUI() {
    Text text = getUIFactory().newText("Level 1", Color.WHITE, 48);
    getGameScene().addUINode(text);

    QuadCurve curve = new QuadCurve(-100, 0, getWidth() / 2, getHeight(), getWidth() + 100, 0);

    PathTransition transition = new PathTransition(Duration.seconds(4), curve, text);
    transition.setOnFinished(e -> {
        getGameScene().removeUINode(text);
        getBallControl().release();
    });
    transition.play();
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
/**
 * Animates data along the wire
 * @param animTime The time for the animation to complete in
    */
public void animateData(double animTime) {
       final Wire self = this;
	Platform.runLater(() -> {
		animating = true;
		PathTransition pathTransition = new PathTransition();
		time = animTime;

		transitions.add(pathTransition);

		pathTransition.setDuration(Duration.millis(time));
		Circle data = new Circle(0, 0, 7.5);
		data.getStyleClass().addAll("cpu-data");
		pathTransition.setNode(data);
		pathTransition.setPath(path);
		pathTransition.setOrientation(PathTransition.OrientationType.ORTHOGONAL_TO_TANGENT);
		pathTransition.setCycleCount(1);
		pathTransition.setAutoReverse(false);

		data.setCache(true);

		toFront();

		getChildren().add(data);
		pathTransition.play();

		pathTransition.setOnFinished(event -> {
			getChildren().remove(data);
			transitions.remove(pathTransition);
		});

		synchronized (self) {
			progressed++;
		}
	});
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
/**
 * Apply animation.
 *  
 * @param group Group to which animation is to be applied.
 */
private void applyAnimation(final Group group)
{
   final Path path = generateCurvyPath();
   group.getChildren().add(path);
   final Shape rmoug = generateTitleText();
   group.getChildren().add(rmoug);
   final Shape td = generateDaysText();
   group.getChildren().add(td);
   final Shape denver = generateLocationText();
   group.getChildren().add(denver);
   final PathTransition rmougTransition =
      generatePathTransition(
         rmoug, path, Duration.seconds(8.0), Duration.seconds(0.5),
         OrientationType.NONE);
   final PathTransition tdTransition =
      generatePathTransition(
         td, path, Duration.seconds(5.5), Duration.seconds(0.1),
         OrientationType.NONE);
   final PathTransition denverTransition =
      generatePathTransition(
         denver, path, Duration.seconds(30), Duration.seconds(3),
         OrientationType.ORTHOGONAL_TO_TANGENT);
   final ParallelTransition parallelTransition =
      new ParallelTransition(rmougTransition, tdTransition, denverTransition);
   parallelTransition.play(); 
}
 

import javafx.animation.PathTransition; //导入依赖的package包/类
/**
 * Method to increase of 1 unit the Outbreaks Gauge
 */
public void increase(View view) {
    if (lvl < 9) {
        double column1 = 42, column2 = column1 + 60;
        Path path = new Path(new MoveTo(lvl%2 == 0 ? column2 : column1, 50 + (lvl-1)*35), new LineTo(lvl%2 == 0 ? column1 : column2, 50 + lvl*35));
        PathTransition pathTransition = new PathTransition(Duration.millis(1000),path,actual);
        pathTransition.setOnFinished(event -> view.fireOutbreakFinished());
        pathTransition.play();
        lvl++;
    }

}