在Java中，是否可以使菜单中的某些项目以500毫秒的开始延迟淡入？

我有一个包含16个JMenuItems的JMenu，其中3个要提前显示，其余13个要以500毫秒的延迟淡入。有没有办法用Java制作这个动画

启动计时器以触发淡入事件

启动计时器以触发淡入事件

这并不像听起来那么容易

基本上，我最初认为“我将在菜单项添加到的弹出菜单上附加一个弹出监听器”……但显然这不太管用。菜单弹出窗口是根据需要动态生成的。有道理，但这仍然是一种痛苦

因此，我发现，如果我等待

addNotify

，我可以简单地启动动画引擎

动画引擎是一个简单的概念。它有一个

javax.swing.Timer

，它以固定的间隔滴答作响。结合开始时间和持续时间，我们可以计算动画的进度，并根据需要生成

alpha

值

剩下的唯一一件事就是通知所有感兴趣的人动画已经改变了，瞧

import java.awt.AlphaComposite;
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.event.PopupMenuEvent;
import javax.swing.event.PopupMenuListener;

public class FadeMenu {

    private AnimationEngine engine;

    public static void main(String[] args) {
        new FadeMenu();
    }

    public FadeMenu() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                }

                engine = new AnimationEngine();

                JMenuBar mb = new JMenuBar();
                JMenu flip = new JMenu("Flip");

                flip.add("Static 1");
                flip.add("Static 2");
                flip.add("Static 3");

                flip.add(new FadeMenuItem("Fade 1"));
                flip.add(new FadeMenuItem("Fade 2"));
                flip.add(new FadeMenuItem("Fade 3"));
                flip.add(new FadeMenuItem("Fade 4"));

                mb.add(flip);

                JFrame frame = new JFrame("Testing");
                frame.setJMenuBar(mb);
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        public TestPane() {
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(200, 200);
        }
    }

    public class FadeMenuItem extends JMenuItem {

        public FadeMenuItem(String text) {
            super(text);
            engine.addTimingListener(new TimingListener() {
                @Override
                public void timingEvent() {
                    repaint();
                }
            });
        }

        @Override
        protected void paintComponent(Graphics g) {
            Graphics2D g2d = (Graphics2D) g.create();
            g2d.setComposite(AlphaComposite.SrcOver.derive(engine.getAlpha()));
            super.paintComponent(g2d);
            g2d.dispose();
        }

        @Override
        public void removeNotify() {
            Container parent = getParent();
            if (parent instanceof JPopupMenu) {
                JPopupMenu menu = (JPopupMenu) parent;
                engine.stop();
            }
            super.removeNotify(); 
        }

        @Override
        public void addNotify() {
            super.addNotify();
            Container parent = getParent();
            if (parent instanceof JPopupMenu) {
                JPopupMenu menu = (JPopupMenu) parent;
                engine.restart();
            }
        }
    }

    public interface TimingListener {

        public void timingEvent();
    }

    public class AnimationEngine {

        private Timer fade;
        private float alpha;
        private long startTime;
        private long duration = 1000;
        private List<TimingListener> listeners;

        public AnimationEngine() {
            listeners = new ArrayList<>(5);
            fade = new Timer(40, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    long elapsed = System.currentTimeMillis() - startTime;
                    if (elapsed >= duration) {
                        ((Timer) e.getSource()).stop();
                        alpha = 1f;
                    } else {
                        alpha = (float) elapsed / (float) duration;
                    }
                    fireTimingEvent();
                }
            });
            fade.setRepeats(true);
            fade.setCoalesce(true);
            fade.setInitialDelay(500);
        }

        public void addTimingListener(TimingListener listener) {
            listeners.add(listener);
        }

        public void removeTimingListener(TimingListener listener) {
            listeners.add(listener);
        }

        protected void fireTimingEvent() {
            for (TimingListener listener : listeners) {
                listener.timingEvent();
            }
        }

        public void restart() {
            fade.stop();
            alpha = 0;
            fireTimingEvent();
            startTime = System.currentTimeMillis();
            fade.start();
        }

        public float getAlpha() {
            return alpha;
        }

        public void stop() {
            fade.stop();
        }
    }
}

导入java.awt.AlphaComposite；
导入java.awt.BorderLayout；
导入java.awt.Container；
导入java.awt.Dimension；
导入java.awt.EventQueue；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.text.NumberFormat；
导入java.util.ArrayList；
导入java.util.List；
导入javax.swing.JFrame；
导入javax.swing.JMenu；
导入javax.swing.JMenuBar；
导入javax.swing.JMenuItem；
导入javax.swing.JPanel；
导入javax.swing.jpopmenu；
导入javax.swing.Timer；
导入javax.swing.UIManager；
导入javax.swing.UnsupportedLookAndFeelException；
导入javax.swing.event.PopupMenuEvent；
导入javax.swing.event.PopupMenuListener；
公共级法德门{
私人发动机；
公共静态void main（字符串[]args）{
新FadeMenu（）；
}
公共时尚{
invokeLater（新的Runnable（）{
@凌驾
公开募捐{
试一试{
UIManager.setLookAndFeel（UIManager.getSystemLookAndFeelClassName（））；
}catch（ClassNotFoundException |实例化Exception | IllegalacessException |不支持ookandfeelException ex）{
}
引擎=新动画引擎（）；
JMenuBar mb=新的JMenuBar（）；
JMenu flip=新JMenu（“flip”）；
翻转。添加（“静态1”）；
添加（“静态2”）；
添加（“静态3”）；
添加（新的FadeMenuItem（“Fade1”））；
添加（新的FadeMenuItem（“Fade2”））；
添加（新的FadeMenuItem（“Fade3”））；
添加（新的FadeMenuItem（“Fade4”））；
mb.添加（翻转）；
JFrame=新JFrame（“测试”）；
frame.setJMenuBar（mb）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.setLayout（新的BorderLayout（））；
frame.add（newtestpane（））；
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
}
});
}
公共类TestPane扩展了JPanel{
公共测试窗格（）{
}
@凌驾
公共维度getPreferredSize（）{
返回新维度（200200）；
}
}
公共类FadeMenuItem扩展了JMenuItem{
公共FadeMenuItem（字符串文本）{
超级（文本）；
engine.addTimingListener（新的TimingListener（）{
@凌驾
公共无效timingEvent（）{
重新油漆（）；
}
});
}
@凌驾
受保护组件（图形g）{
Graphics2D g2d=（Graphics2D）g.create（）；
setComposite（AlphaComposite.SrcOver.derive（engine.getAlpha（））；
超级油漆组件（g2d）；
g2d.dispose（）；
}
@凌驾
公共无效删除通知（）{
容器父级=getParent（）；
if（JPopupMenu的父实例）{
JPopupMenu菜单=（JPopupMenu）父菜单；
发动机。停止（）；
}
super.removeNotify（）；
}
@凌驾
public void addNotify（）{
super.addNotify（）；
容器父级=getParent（）；
if（JPopupMenu的父实例）{
JPopupMenu菜单=（JPopupMenu）父菜单；
重新启动引擎（）；
}
}
}
公共接口定时侦听器{
公共无效timingEvent（）；
}
公共类动画引擎{
私人定时器衰减；
私人浮动阿尔法；
私人长启动时间；
私人长持续时间=1000；
私人名单听众；
公共动画引擎（）{
侦听器=新的ArrayList（5）；
淡入=新计时器（40，新ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
长时间运行=System.currentTimeMillis（）-startTime；
如果（经过>=持续时间）{
（（计时器）e.getSource（））.stop（）；
α=1f；
}否则{
alpha=（浮动）已用/（浮动）持续时间；
}
fireTimingEvent（）；
}
});
淡入淡出。设置重复（真）；
淡入淡出。设置合并（真）；
衰减。设置初始延迟（500）；
}
public void addTimingListener（TimingListener侦听器）{
添加（侦听器）；
}
public void removeTimingListener（计时侦听器）{
添加（侦听器）；
}
受保护的无效火源