撤消C/doc选项卡的最佳方法JTabbedPane Java

正如标题所示，从JTabbedPane记录/撤消选项卡的最佳方式是什么？类似于在Chrome中拖动一个选项卡，它将打开一个新窗口，然后将其拖回将再次将其放回？

这不是一个简单的问题

首先，您需要一个触发器，您可以确定选项卡将要松开。记住，选项卡可以重新排序，所以仅仅监视拖动事件是不够的

其次，如果窗口关闭（或者即使您想关闭），您需要确定如何“重新停靠”选项卡

---

在这之后，只需将组件从选项卡中移除，然后将visa卡反之亦然放置到框架上即可。

我使用MouseMotionListener和MouseStener实现了这一点。当您将选项卡标题拖动一段相当长的距离时，这将只是取消锁定，当您关闭取消锁定的帧时，将重新锁定它

    import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Window;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.JSpinner;
import javax.swing.JTabbedPane;
import javax.swing.JTextArea;
import javax.swing.JTree;


public class DockableTabbedPane extends JTabbedPane {

    private DockableTabbedPane  DraggableTabbedPane;
    public DockableTabbedPane() {
        super();
        DraggableTabbedPane = this;
        TabDragListener tabDragger = new TabDragListener();
        this.addMouseListener(tabDragger);
        this.addMouseMotionListener(tabDragger);        
    }

    private class TabDragListener implements MouseListener, MouseMotionListener {

        Point p0,p0screen;

        Component current;
        String title;

        public void mousePressed(MouseEvent e) {
            p0 = e.getPoint();


            for (int i = 0; i < getTabCount(); i++) {
                Rectangle bounds = getBoundsAt(i);
                if (bounds.contains(p0)) {
                    current = DockableTabbedPane.this.getComponentAt(i);   
                    title =DockableTabbedPane.this.getTitleAt(i);
                    p0screen = getLocationOnScreen();
                }
            }
        };

        public void mouseDragged(MouseEvent e) {
            Point p = e.getPoint();
            JFrame frame;

            if (current != null) {
                // check for a significant  drag
                if( p.distance(p0)>20){

                    frame = undock(current,title);
                    current = null; 


                }
            }
        }



        public void mouseMoved(MouseEvent arg0) {}

        public void mouseClicked(MouseEvent arg0) {}

        public void mouseEntered(MouseEvent arg0) {}

        public void mouseExited(MouseEvent arg0) {}

        public void mouseReleased(MouseEvent arg0) {
            current=null;
            title =null;
        }
    }

    private UndockedFrame undock(Component current,String title) {


        Point p = current.getLocationOnScreen();
        remove(current);
        UndockedFrame frame = new UndockedFrame(current,title);

        p.translate(20, 20);
        frame.setLocation(p);
        frame.setVisible(true);
        fireStateChanged();
        return frame;    



    }

    private class UndockedFrame extends JFrame {
        Component current;
        String title;
        public UndockedFrame(Component current,String title) {
            this.current = current;

            this.setTitle(title);

            Container content = this.getContentPane();
            content.setLayout(new BorderLayout());
            content.add(current, BorderLayout.CENTER);
            this.setBounds(current.getBounds());
            this.addWindowListener(new UndockedFrameListener());
        }

        public void redock() {

            this.dispose();
            add(title, current);

        }
    }

    // Redock on close
    private class UndockedFrameListener extends WindowAdapter {
        public void windowClosing(WindowEvent e) {
            Window w = e.getWindow();
            if (w instanceof UndockedFrame) {
                UndockedFrame frame = (UndockedFrame)w;
                frame.redock();
            }
        }
    }
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        DockableTabbedPane pane = new DockableTabbedPane();
        pane.add(new JTree(), "Tree 0");
        pane.add(new JTextArea(" Hello"), "Tree 1");
        pane.add(new JFileChooser(), "Tree 2");
        pane.add(new JSpinner(), "Tree 3");
        pane.add(new JSlider(),"Tree 4");
        frame.getContentPane().add(pane);
        frame.setBounds(100, 100, 400, 400);
        frame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        frame.setVisible(true);
    }
}

导入java.awt.BorderLayout；
导入java.awt.Component；
导入java.awt.Container；
导入java.awt.Image；
导入java.awt.Point；
导入java.awt.Rectangle；
导入java.awt.Window；
导入java.awt.event.MouseEvent；
导入java.awt.event.MouseListener；
导入java.awt.event.MouseMotionListener；
导入java.awt.event.WindowAdapter；
导入java.awt.event.WindowEvent；
导入javax.swing.ImageIcon；
导入javax.swing.JFileChooser；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.JSlider；
导入javax.swing.JSpinner；
导入javax.swing.JTabbedPane；
导入javax.swing.JTextArea；
导入javax.swing.JTree；
公共类DockableTabbedPane扩展了JTabbedPane{
专用可停靠选项卡窗格玻璃；
公共可停靠AbbedPane（）{
超级（）；
DraggableTabbedPane=this；
TabDragListener tabDragger=新的TabDragListener（）；
这是addMouseListener（tabDragger）；
this.addMouseMotionListener（tabDragger）；
}
私有类TabDragListener实现MouseListener、MouseMotionListener{
p0点，p0点；
分量电流；
字符串标题；
公共无效鼠标按下（MouseEvent e）{
p0=e.getPoint（）；
for（int i=0；i20）{
帧=取消锁定（当前，标题）；
电流=零；
}
}
}
public void mouseMoved（MouseEvent arg0）{}
public void mouseClicked（MouseEvent arg0）{}
public void mouseEntered（MouseEvent arg0）{}
public void mouseExited（MouseEvent arg0）{}
公共无效MouseEvent arg0{
电流=零；
title=null；
}
}
私有解除锁定帧解除锁定（组件当前，字符串标题）{
点p=当前.getLocationOnScreen（）；
移除（当前）；
UndockedFrame frame=新UndockedFrame（当前，标题）；
p、 翻译（20,20）；
帧设置位置（p）；
frame.setVisible（true）；
fireStateChanged（）；
返回框；
}
私有类UndockedFrame扩展了JFrame{
分量电流；
字符串标题；
公共解除锁定帧（组件当前，字符串标题）{
这个电流=电流；
这个.setTitle（title）；
容器内容=this.getContentPane（）；
setLayout（新的BorderLayout（））；
添加（当前，BorderLayout.CENTER）；
this.setBounds（current.getBounds（））；
this.addWindowListener（新的UndockedFrameListener（））；
}
公共无效redock（）{
这个。dispose（）；
添加（标题，当前）；
}
}
//关闭时重做
私有类UndockedFrameListener扩展了WindowAdapter{
公共无效窗口关闭（WindowEvent e）{
窗口w=e.getWindow（）；
if（带未连接帧的实例）{
UndockedFrame frame=（UndockedFrame）w；
frame.redock（）；
}
}
}
公共静态void main（字符串[]args）{
JFrame=新JFrame（）；
DockableTabbedPane=新的DockableTabbedPane（）；
添加（新JTree（），“树0”）；
添加（新JTextArea（“Hello”），“tree1”）；
添加（新的JFileChooser（），“树2”）；
添加（新的JSpinner（），“树3”）；
添加（新的JSlider（），“树4”）；
frame.getContentPane（）.add（窗格）；
机架立根（100100400400）；
frame.addWindowListener（新的WindowAdapter（）{
公共无效窗口关闭（WindowEvent e）{
系统出口（0）；
}
});
frame.setVisible（true）；
}
}