Java滑动JPanels

我有一个菜单，上面有各种各样的按钮，我可以让按钮在点击时调用它们各自的JPanel。问题是我想让Jpanel在被调用时滑入，而不是突然出现。我尝试使用tween引擎，作为Java初学者，我发现它真的很强大，所以我决定使用定时动画。我能够使顶部的Jpanel滑到一边，但由于某些原因，下一个面板不想显示，我真的很累，请有人帮忙！代码如下：

public class Listener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {

        new Timer(0, new ActionListener() {
           public void actionPerformed(ActionEvent e) {                

              mainpane.setLocation(mainpane.getX() - 10, 0);
              if (mainpane.getX() + mainpane.getWidth() == 0) 
              {
                 ((Timer) e.getSource()).stop();
                   System.out.println("Timer stopped");
              } 
           }
        }).start();   
   } 
}

---

滑动面板可能很棘手。下面是一些起始代码。修改以适应 你的需要。根据需要添加错误检查和异常处理

本例使用JButtons和JTree作为内容，但您可以使用几乎任何类型的内容

用法：

static public void main(final String[] args) throws Exception {
    SwingUtilities.invokeAndWait(new Runnable() {
        @Override
        public void run() {
            final JFrame jFrame = new JFrame() {
                {
                    final PanelSlider42<JFrame> slider = new PanelSlider42<JFrame>(this);
                    final JPanel jPanel = slider.getBasePanel();

                    slider.addComponent(new JButton("1"));
                    slider.addComponent(new JButton("22"));
                    slider.addComponent(new JButton("333"));
                    slider.addComponent(new JButton("4444"));

                    getContentPane().add(jPanel);
                    setSize(300, 300);
                    setLocationRelativeTo(null);
                    setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
                    setVisible(true);
                }
            };
        }
    });
}

static public void main（最终字符串[]args）引发异常{
SwingUtilities.invokeAndWait（新的Runnable（）{
@凌驾
公开募捐{
最终JFrame JFrame=新JFrame（）{
{
最终PanelSlider42滑块=新的PanelSlider42（此）；
final JPanel JPanel=slider.getBasePanel（）；
slider.addComponent（新的JButton（“1”））；
slider.addComponent（新的JButton（“22”））；
slider.addComponent（新的JButton（“333”））；
slider.addComponent（新的JButton（“4444”））；
getContentPane（）.add（jPanel）；
设置大小（300300）；
setLocationRelativeTo（空）；
setDefaultCloseOperation（JFrame.DISPOSE_ON_CLOSE）；
setVisible（真）；
}
};
}
});
}

impl很长

package com.java42.example.code;

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseMotionAdapter;
import java.util.ArrayList;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JWindow;
import javax.swing.SwingUtilities;

public class PanelSlider42<ParentType extends Container> {

private static final int           RIGHT             = 0x01;
private static final int           LEFT              = 0x02;
private static final int           TOP               = 0x03;
private static final int           BOTTOM            = 0x04;
private final JPanel               basePanel         = new JPanel();
private final ParentType           parent;
private final Object               lock              = new Object();
private final ArrayList<Component> jPanels           = new ArrayList<Component>();
private final boolean              useSlideButton    = true;
private boolean                    isSlideInProgress = false;

private final JPanel               glassPane;
{
    glassPane = new JPanel();
    glassPane.setOpaque(false);
    glassPane.addMouseListener(new MouseAdapter() {
    });
    glassPane.addMouseMotionListener(new MouseMotionAdapter() {
    });
    glassPane.addKeyListener(new KeyAdapter() {
    });
}

public PanelSlider42(final ParentType parent) {
    if (parent == null) {
        throw new RuntimeException("ProgramCheck: Parent can not be null.");
    }
    if ((parent instanceof JFrame) || (parent instanceof JDialog) || (parent instanceof JWindow) || (parent instanceof JPanel)) {
    }
    else {
        throw new RuntimeException("ProgramCheck: Parent type not supported. " + parent.getClass().getSimpleName());
    }
    this.parent = parent;
    attach();
    basePanel.setSize(parent.getSize());
    basePanel.setLayout(new BorderLayout());
    if (useSlideButton) {
        final JPanel statusPanel = new JPanel();
        basePanel.add(statusPanel, BorderLayout.SOUTH);
        statusPanel.add(new JButton("Slide Left") {
            private static final long serialVersionUID = 9204819004142223529L;
            {
                setMargin(new Insets(0, 0, 0, 0));
            }
            {
                addActionListener(new ActionListener() {
                    @Override
                    public void actionPerformed(final ActionEvent e) {
                        slideLeft();
                    }
                });
            }
        });
        statusPanel.add(new JButton("Slide Right") {
            {
                setMargin(new Insets(0, 0, 0, 0));
            }
            private static final long serialVersionUID = 9204819004142223529L;
            {
                addActionListener(new ActionListener() {
                    @Override
                    public void actionPerformed(final ActionEvent e) {
                        slideRight();
                    }
                });
            }
        });
        statusPanel.add(new JButton("Slide Up") {
            {
                setMargin(new Insets(0, 0, 0, 0));
            }
            private static final long serialVersionUID = 9204819004142223529L;
            {
                addActionListener(new ActionListener() {
                    @Override
                    public void actionPerformed(final ActionEvent e) {
                        slideTop();
                    }
                });
            }
        });
        statusPanel.add(new JButton("Slide Down") {
            {
                setMargin(new Insets(0, 0, 0, 0));
            }
            private static final long serialVersionUID = 9204819004142223529L;
            {
                addActionListener(new ActionListener() {
                    @Override
                    public void actionPerformed(final ActionEvent e) {
                        slideBottom();
                    }
                });
            }
        });
    }
}

public JPanel getBasePanel() {
    return basePanel;
}

private void attach() {
    final ParentType w = this.parent;
    if (w instanceof JFrame) {
        final JFrame j = (JFrame) w;
        if (j.getContentPane().getComponents().length > 0) {
            throw new RuntimeException("ProgramCheck: Parent already contains content.");
        }
        j.getContentPane().add(basePanel);
    }
    if (w instanceof JDialog) {
        final JDialog j = (JDialog) w;
        if (j.getContentPane().getComponents().length > 0) {
            throw new RuntimeException("ProgramCheck: Parent already contains content.");
        }
        j.getContentPane().add(basePanel);
    }
    if (w instanceof JWindow) {
        final JWindow j = (JWindow) w;
        if (j.getContentPane().getComponents().length > 0) {
            throw new RuntimeException("ProgramCheck: Parent already contains content.");
        }
        j.getContentPane().add(basePanel);
    }
    if (w instanceof JPanel) {
        final JPanel j = (JPanel) w;
        if (j.getComponents().length > 0) {
            throw new RuntimeException("ProgramCheck: Parent already contains content.");
        }
        j.add(basePanel);
    }
}

public void addComponent(final Component component) {
    if (jPanels.contains(component)) {
    }
    else {
        jPanels.add(component);
        if (jPanels.size() == 1) {
            basePanel.add(component);
        }
        component.setSize(basePanel.getSize());
        component.setLocation(0, 0);
    }
}

public void removeComponent(final Component component) {
    if (jPanels.contains(component)) {
        jPanels.remove(component);
    }
}

public void slideLeft() {
    slide(LEFT);
}

public void slideRight() {
    slide(RIGHT);
}

public void slideTop() {
    slide(TOP);
}

public void slideBottom() {
    slide(BOTTOM);
}

private void enableUserInput(final ParentType w) {
    if (w instanceof JFrame) {
        ((JFrame) w).getGlassPane().setVisible(false);
    }
    if (w instanceof JDialog) {
        ((JDialog) w).getGlassPane().setVisible(false);
    }
    if (w instanceof JWindow) {
        ((JWindow) w).getGlassPane().setVisible(false);
    }
}

private void disableUserInput(final ParentType w) {
    if (w instanceof JFrame) {
        ((JFrame) w).setGlassPane(glassPane);
    }
    if (w instanceof JDialog) {
        ((JDialog) w).setGlassPane(glassPane);
    }
    if (w instanceof JWindow) {
        ((JWindow) w).setGlassPane(glassPane);
    }
    glassPane.setVisible(true);
}

private void enableTransparentOverylay() {
    if (parent instanceof JFrame) {
        ((JFrame) parent).getContentPane().setBackground(jPanels.get(0).getBackground());
        parent.remove(basePanel);
        parent.validate();
    }
    if (parent instanceof JDialog) {
        ((JDialog) parent).getContentPane().setBackground(jPanels.get(0).getBackground());
        parent.remove(basePanel);
        parent.validate();
    }
    if (parent instanceof JWindow) {
        ((JWindow) parent).getContentPane().setBackground(jPanels.get(0).getBackground());
        parent.remove(basePanel);
        parent.validate();
    }
}

private void slide(final int slideType) {
    if (!isSlideInProgress) {
        isSlideInProgress = true;
        final Thread t0 = new Thread(new Runnable() {
            @Override
            public void run() {
                parent.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
                disableUserInput(parent);
                slide(true, slideType);
                enableUserInput(parent);
                parent.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                isSlideInProgress = false;
            }
        });
        t0.setDaemon(true);
        t0.start();
    }
    else {
        Toolkit.getDefaultToolkit().beep();
    }
}

private void slide(final boolean useLoop, final int slideType) {
    if (jPanels.size() < 2) {
        System.err.println("Not enough panels");
        return;
    }
    synchronized (lock) {
        Component componentOld = null;
        Component componentNew = null;
        if ((slideType == LEFT) || (slideType == TOP)) {
            componentNew = jPanels.remove(jPanels.size() - 1);
            componentOld = jPanels.get(0);
            jPanels.add(0, componentNew);
        }
        if ((slideType == RIGHT) || (slideType == BOTTOM)) {
            componentOld = jPanels.remove(0);
            jPanels.add(componentOld);
            componentNew = jPanels.get(0);
        }
        final int w = componentOld.getWidth();
        final int h = componentOld.getHeight();
        final Point p1 = componentOld.getLocation();
        final Point p2 = new Point(0, 0);
        if (slideType == LEFT) {
            p2.x += w;
        }
        if (slideType == RIGHT) {
            p2.x -= w;
        }
        if (slideType == TOP) {
            p2.y += h;
        }
        if (slideType == BOTTOM) {
            p2.y -= h;
        }
        componentNew.setLocation(p2);
        int step = 0;
        if ((slideType == LEFT) || (slideType == RIGHT)) {
            step = (int) (((float) parent.getWidth() / (float) Toolkit.getDefaultToolkit().getScreenSize().width) * 40.f);
        }
        else {
            step = (int) (((float) parent.getHeight() / (float) Toolkit.getDefaultToolkit().getScreenSize().height) * 20.f);
        }
        step = step < 5 ? 5 : step;
        basePanel.add(componentNew);
        basePanel.revalidate();
        if (useLoop) {
            final int max = (slideType == LEFT) || (slideType == RIGHT) ? w : h;
            final long t0 = System.currentTimeMillis();
            for (int i = 0; i != (max / step); i++) {
                switch (slideType) {
                    case LEFT: {
                        p1.x -= step;
                        componentOld.setLocation(p1);
                        p2.x -= step;
                        componentNew.setLocation(p2);
                        break;
                    }
                    case RIGHT: {
                        p1.x += step;
                        componentOld.setLocation(p1);
                        p2.x += step;
                        componentNew.setLocation(p2);
                        break;
                    }
                    case TOP: {
                        p1.y -= step;
                        componentOld.setLocation(p1);
                        p2.y -= step;
                        componentNew.setLocation(p2);
                        break;
                    }
                    case BOTTOM: {
                        p1.y += step;
                        componentOld.setLocation(p1);
                        p2.y += step;
                        componentNew.setLocation(p2);
                        break;
                    }
                    default:
                        new RuntimeException("ProgramCheck").printStackTrace();
                        break;
                }

                try {
                    Thread.sleep(500 / (max / step));
                } catch (final Exception e) {
                    e.printStackTrace();
                }
            }
            final long t1 = System.currentTimeMillis();
        }
        componentOld.setLocation(-10000, -10000);
        componentNew.setLocation(0, 0);
    }
}
}

package com.java42.example.code；
导入java.awt.BorderLayout；
导入java.awt.Component；
导入java.awt.Container；
导入java.awt.Cursor；
导入java.awt.Insets；
导入java.awt.Point；
导入java.awt.Toolkit；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.awt.event.KeyAdapter；
导入java.awt.event.MouseAdapter；
导入java.awt.event.MouseMotionAdapter；
导入java.util.ArrayList；
导入javax.swing.JButton；
导入javax.swing.JDialog；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.JWindow；
导入javax.swing.SwingUtilities；
公共类PanelSlider42{
私有静态final int RIGHT=0x01；
私有静态final int LEFT=0x02；
专用静态最终int TOP=0x03；
私有静态最终int-BOTTOM=0x04；
私有最终JPanel basePanel=新JPanel（）；
私有最终父类型父；
私有最终对象锁=新对象（）；
private final ArrayList jPanels=new ArrayList（）；
私有最终布尔值useSlideButton=true；
私有布尔值isSlideInProgress=false；
私人最终JPanel玻璃窗格玻璃；
{
glassPane=新的JPanel（）；
玻璃材质窗格玻璃。设置不透明（假）；
glassPane.addMouseListener（新的MouseAdapter（）{
});
glassPane.addMouseMotionListener（新的MouseMotionAdapter（）{
});
glassPane.addKeyListener（新的KeyAdapter（）{
});
}
公共面板滑块42（最终父类型父）{
如果（父项==null）{
抛出新的RuntimeException（“ProgramCheck:Parent不能为null”）；
}
if（（JFrame的父实例）| |（JDialog的父实例）| |（JWindow的父实例）| |（JPanel的父实例））{
}
否则{
抛出新的RuntimeException（“ProgramCheck:不支持父类型。”+Parent.getClass（）.getSimpleName（））；
}
this.parent=parent；
附加（）；
basePanel.setSize（parent.getSize（））；
basePanel.setLayout（新的BorderLayout（））；
如果（使用滑动按钮）{
最终JPanel状态面板=新JPanel（）；
添加（statusPanel，BorderLayout.SOUTH）；
statusPanel.add（新的JButton（“向左滑动”）{
私有静态最终长serialVersionUID=9204819004142223529L；
{
setMargin（新插图（0,0,0,0））；
}
{
addActionListener（新ActionListener（）{
@凌驾
已执行的公共无效行动（最终行动事件e）{
slideLeft（）；
}
});
}
});
statusPanel.add（新的JButton（“向右滑动”）{
{
setMargin（新插图（0,0,0,0））；
}
私有静态最终长serialVersionUID=9204819004142223529L；
{
addActionListener（新ActionListener（）{
@凌驾
已执行的公共无效行动（最终行动事件e）{
slideRight（）；
}
});
}
});
statusPanel.add（新的JButton（“向上滑动”）{
{
setMargin（新插图（0,0,0,0））；
}
私有静态最终长serialVersionUID=9204819004142223529L；
{
addActionListener（新ActionListener（）{
@凌驾
已执行的公共无效行动（最终行动事件e）{
滑动顶（）；
}
});
}
});
statusPanel.add（新的JButton（“向下滑动”）{
{
setMargin（新插图（0,0,0,0））；
}
私有静态最终长serialVersionUID=9204819004142223529L；
{
addActionListener（新ActionListener（）{
@凌驾
已执行的公共无效行动（最终行动事件e）{
slideBottom（）；
}
});
}
});
}
}
公共JPanel ge
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;

public class SlidingPanel {

   JPanel panel;

   public void makeUI() {
      panel = new JPanel();
      panel.setBackground(Color.RED);
      panel.setBounds(0, 0, 400, 400);

      JButton button = new JButton("Click");
      button.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
            ((JButton) e.getSource()).setEnabled(false);
            new Timer(1, new ActionListener() {
               public void actionPerformed(ActionEvent e) {
                  panel.setLocation(panel.getX() - 1, 0);
                  if (panel.getX() + panel.getWidth() == 0) {
                     ((Timer) e.getSource()).stop();
               System.out.println("Timer stopped");
            }
               }
            }).start();
         }
      });
      panel.add(button);
      JFrame frame = new JFrame("Sliding Panel");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setSize(400, 400);
      frame.setLocationRelativeTo(null);
      frame.setLayout(null);
      frame.add(panel);
      frame.setVisible(true);
   }

   public static void main(String[] args) {
      SwingUtilities.invokeLater(new Runnable() {
         public void run() {
            new SlidingPanel().makeUI();
         }
      });
   }
}