微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

Java滑动JPanels

分类：Java作者：编程之家
我有一个显示各种按钮的菜单,我可以让按钮在点击时调用各自的JPanels.事情是我想让Jpanel在调用时滑入而不是瞬间弹出.我尝试使用补间引擎和 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);
                }
            };
        }
    });
}

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));
            }
            {
                addActionListener(new ActionListener() {
                    @Override
                    public void actionPerformed(final ActionEvent e) {
                        slideLeft();
                    }
                });
            }
        });
        statusPanel.add(new JButton("Slide Right") {
            {
                setMargin(new Insets(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));
            }
            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));
            }
            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);
    }
}
}

原文地址：https://www.jb51.cc/java/128291.html

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

java进制转换（无视正负数的差别）
最近看了一下学习资料，感觉进制转换其实还是挺有意思的，尤其是对于负数这一方面。下面和大家分享一下，这里只写了十进制到二进制的转换，其实都是同样的道理 1 public class Test1 { 2 3 public static void main(String[] args) { 4 ...
java集合框架（hashSet自定义元素是否相同，重写hashCode和equals方法）
/*HashSet 基本操作 * --set:元素是无序的，存入和取出顺序不一致，元素不可以重复 * （通过哈希值来判断是否是同一个对象） * ----HashSet：底层数据结构是哈希表， * 保证数据唯一性的方法是调用存入元素的hashCode（）方法 * 和equals(Obj...
java 集合框架(List操作)
/*list 基本操作 * * List a=new List(); * 增 * a.add(index,element);按指定位置添加，其余元素依次后移 * addAll(index,Collection);在从指定位置开始添加一系列元素，其余元素依次后移 * 删 * a.remove(...
java内部类
/* * 内部类 * */ 1 class OutClass{ 2 //定义外部类的成员变量 3 private int x=1; 4 //定义外部类函数 5 public void methodOut(){ 6 System.out.println(...
java集合的操作(set,Iterator)
集合的操作Iterator、Collection、Set和HashSet关系Iterator set=new HashSet(); //向集合中添加元素 set.add(&quot;a&quot;); set.add(&quot;b&quot;); set.add(&quot;c&quot;); s
java接口
接口中常量的修饰关键字：public，static，final（常量）函数的修饰关键字：public，abstract如果没有写全，系统在编译时会自动加上接口中的所有成员都是public接口中的方法，都是抽象方法， * 接口是不可以创建对象，因为有抽象方法；子类如果只实现部分接口的抽象方法，则子类是
java 集合框架(TreeSet操作,自动对数据进行排序,重写CompareTo方法)
/*TreeSet * treeSet存入数据后自动调用元素的compareTo(Object obj) 方法，自动对数据进行排序 * 所以输出的数据是经过排序的数据 * 注：compareTo方法返回值有：负数，零，正数。分别表示小于，等于，大于 * 对于存入自定义的对象元素，要重写元...
java映射(map用法)
主要分两个接口：collection和Map主要分三类：集合(set)、列表(List)、映射(Map)1.集合：没有重复对象，没有特定排序方式2.列表：对象按索引位置排序，可以有重复对象3.映射：有一个键对象和一个值对象，键不可重复，值可以重复hashtable 和hashmap区别1 HashM
java Http消息传递之POST和GET两种方法
/** * 通过Get方法来向服务器传值和获取信息， * 这里举例假设的前提是，链接上服务器，服务器直接发送数据给本地 * * 大体的思路： * 1、首先通过URL地址来获得链接的借口 * 通过接口，来设置链接超时的时间，请求方式，是否可以输入输出数据 * 得到读取服务器内容的...
Java中Json解析
首先准备一个JSON格式的字符串 * String JsonStr = &quot;{object:{persons:&quot; + &quot;[{name:&#39;呵呵&#39;,image:&#39;http://10.0.159.132:8080/Web/s1.png&#39;},&qu
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot