动画化按钮移动实际上并不是最困难的问题,最困难的问题是试图将数据移动到可以管理的位置以及如何将源组件与目标连接起来.

首先,您需要一种可以跨容器边界移动组件的方法.虽然可能有几种方法可以做到这一点,但最简单的方法可能是使用框架的玻璃窗格

public class AnimationPane extends JPanel {

public AnimationPane() {

setOpaque(false);

setLayout(null);

}

}

这没什么特别的,它只是一个JPanel,它是透明的,没有布局管理器,通常不建议这样做,但是在这种情况下,我们将控制一切.

现在,我们需要某种方式来动画化运动.

public enum Animator {

INSTANCE;

private List animatables;

private Timer timer;

private Animator() {

animatables = new ArrayList<>(25);

timer = new Timer(40, new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

IAnimatable[] anins = animatables.toArray(new IAnimatable[animatables.size()]);

for (IAnimatable animatable : anins) {

animatable.update();

}

}

});

timer.start();

}

public void addAnimatable(IAnimatable animatable) {

animatables.add(animatable);

}

public void removeAnimatable(IAnimatable animatable) {

animatables.remove(animatable);

}

}

public interface IAnimatable {

public void update();

}

public interface IMoveAnimatable extends IAnimatable{

public JComponent getSourceComponent();

public IImportable getImportable();

}

因此,Animator是核心的“引擎”,它基本上是一个Swing Timer,它仅对其可能管理的任何IAnimatable调用更新.这种方法的目的是可以运行许多动画,但是由于只有一个更新/计时器点,因此不会(极大地)降低系统性能.

IAnimatable接口仅定义提供动画功能的基本协定.

我们需要定义某种合同,定义对象可以参与动画过程并接收信息,也就是“目标”

public interface IImportable {

public JComponent getView();

public void importValue(String value);

}

public abstract class AbstractImportable extends JPanel implements IImportable {

@Override

public JComponent getView() {

return this;

}

}

现在我想到,我们可以利用预先存在的Transferable API,这将使您还可以实现拖放(甚至复制/剪切和粘贴),这将用于定义查找机制,将给定的数据类型与基于DataFlavor的潜在目标进行匹配…但是我将留给您调查这可能如何工作…

核心机制基本上是从其当前容器中删除源组件,将其添加到AnimationPane中,然后在AnimationPane中移动源组件,然后将数据导入到目标中…

问题是,您需要将组件的位置从其当前上下文转换为AnimationPane.

组件位置是相对于其父级上下文的.使用SwingUtilities.convertPoint(Component,Point,Component)相对容易

相对于AnimationPane,我们计算源组件的起点和目标点.然后,在每次调用更新时,我们都会计算动画的进度.我们不使用“增量”运动,而是计算开始时间与预定义的持续时间(在这种情况下为1秒)之间的差异,这通常会产生更灵活的动画

public class DefaultAnimatable implements IMoveAnimatable {

public static final double PLAY_TIME = 1000d;

private Long startTime;

private JComponent sourceComponent;

private IImportable importable;

private JComponent animationSurface;

private Point originPoint, destinationPoint;

private String value;

public DefaultAnimatable(JComponent animationSurface, JComponent sourceComponent, IImportable importable, String value) {

this.sourceComponent = sourceComponent;

this.importable = importable;

this.animationSurface = animationSurface;

this.value = value;

}

public String getValue() {

return value;

}

public JComponent getAnimationSurface() {

return animationSurface;

}

@Override

public JComponent getSourceComponent() {

return sourceComponent;

}

@Override

public IImportable getImportable() {

return importable;

}

@Override

public void update() {

if (startTime == null) {

System.out.println("Start");

IImportable importable = getImportable();

JComponent target = importable.getView();

originPoint = SwingUtilities.convertPoint(getSourceComponent().getParent(), getSourceComponent().getLocation(), getAnimationSurface());

destinationPoint = SwingUtilities.convertPoint(target.getParent(), target.getLocation(), getAnimationSurface());

destinationPoint.x = destinationPoint.x + ((target.getWidth() - getSourceComponent().getWidth()) / 2);

destinationPoint.y = destinationPoint.y + ((target.getHeight() - getSourceComponent().getHeight()) / 2);

Container parent = getSourceComponent().getParent();

getAnimationSurface().add(getSourceComponent());

getSourceComponent().setLocation(originPoint);

parent.invalidate();

parent.validate();

parent.repaint();

startTime = System.currentTimeMillis();

}

long duration = System.currentTimeMillis() - startTime;

double progress = Math.min(duration / PLAY_TIME, 1d);

Point location = new Point();

location.x = progress(originPoint.x, destinationPoint.x, progress);

location.y = progress(originPoint.y, destinationPoint.y, progress);

getSourceComponent().setLocation(location);

getAnimationSurface().repaint();

if (progress == 1d) {

getAnimationSurface().remove(getSourceComponent());

Animator.INSTANCE.removeAnimatable(this);

animationCompleted();

}

}

public int progress(int startValue, int endValue, double fraction) {

int value = 0;

int distance = endValue - startValue;

value = (int) Math.round((double) distance * fraction);

value += startValue;

return value;

}

protected void animationCompleted() {

getImportable().importValue(getValue());

}

}

好的,现在这会产生一个线性动画,这非常无聊,现在,如果您有足够的时间,则可以创建类似于this的地役权,或者只使用其中一个动画框架…

现在,我们需要将其放在一起…

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Container;

import java.awt.Dimension;

import java.awt.EventQueue;

import java.awt.GridBagLayout;

import java.awt.GridLayout;

import java.awt.Point;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.ArrayList;

import java.util.List;

import javax.swing.JButton;

import javax.swing.JComponent;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.SwingUtilities;

import javax.swing.Timer;

import javax.swing.UIManager;

import javax.swing.UnsupportedLookAndFeelException;

import javax.swing.border.LineBorder;

public class AnimationTest {

public static void main(String[] args) {

new AnimationTest();

}

public AnimationTest() {

EventQueue.invokeLater(new Runnable() {

@Override

public void run() {

try {

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

} catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {

ex.printStackTrace();

}

AnimationPane animationPane = new AnimationPane();

LeftPane leftPane = new LeftPane(animationPane);

RightPane rightPane = new RightPane();

leftPane.setImportabale(rightPane);

rightPane.setImportabale(leftPane);

JFrame frame = new JFrame("Testing");

frame.setLayout(new GridLayout(1, 2));

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.add(leftPane, BorderLayout.WEST);

frame.add(rightPane, BorderLayout.WEST);

frame.setGlassPane(animationPane);

animationPane.setVisible(true);

frame.pack();

frame.setLocationRelativeTo(null);

frame.setVisible(true);

}

});

}

public class RightPane extends AbstractImportable {

private IImportable source;

private JButton imported;

private String importedValue;

public RightPane() {

setLayout(new GridBagLayout());

setBorder(new LineBorder(Color.DARK_GRAY));

}

public void setImportabale(IImportable source) {

this.source = source;

}

@Override

public void importValue(String value) {

if (imported != null) {

// May re-animate the movement back...

remove(imported);

}

importedValue = value;

imported = new JButton(">> " + value + "<

add(imported);

revalidate();

repaint();

}

@Override

public Dimension getPreferredSize() {

return new Dimension(200, 200);

}

}

public class LeftPane extends AbstractImportable {

private IImportable importable;

public LeftPane(AnimationPane animationPane) {

setLayout(new GridBagLayout());

JButton btn = new JButton("Lefty");

btn.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

DefaultAnimatable animatable = new DefaultAnimatable(animationPane, btn, importable, "Lefty");

Animator.INSTANCE.addAnimatable(animatable);

}

});

add(btn);

setBorder(new LineBorder(Color.DARK_GRAY));

}

public void setImportabale(IImportable target) {

this.importable = target;

}

@Override

public void importValue(String value) {

}

@Override

public Dimension getPreferredSize() {

return new Dimension(200, 200);

}

}

}