脚踏实地

/**
 * 随机生成字符抽象类
 */
public abstract class AbstractRandomChar {

    protected static final String LOW_STR = "abcdefghijklmnopqrstuvwxyz";
    protected static final String UPPER_STR = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    protected static final String SPECIAL_STR = "~!@#$%^&*()_+/|-=[]{};:'<>?.";
    protected static final String NUM_STR = "0123456789";


    /**
     * 根据字符串获取随机获取字符
     *
     * @param str 指定字符串
     * @return 返回一个随机字符
     */
    protected char getRandomChar(String str) {
        SecureRandom random = new SecureRandom();
        return str.charAt(random.nextInt(str.length()));
    }

    /**
     * 获取随机字符，根据不同的子类不同的实现。现有类型，随机数字、随机大些字母、随机小写字母、随机特殊字符
     *
     * @return 随机字符
     */
    protected abstract char getRandomChar();

}

public class RandomLowChar extends AbstractRandomChar {

    /**
     * 随机获取小写字符
     * @return 随机小写字符
     */
    @Override
    public char getRandomChar() {
        return getRandomChar(LOW_STR);
    }
}

public class RandomNumChar extends AbstractRandomChar {

    /**
     * 获取随机获取数字字符
     * @return 随机获取数字字符
     */
    @Override
    public char getRandomChar() {
        return getRandomChar(NUM_STR);
    }
}

public class RandomSpecialChar extends AbstractRandomChar {

    /**
     * 获取随机获取特殊字符
     * @return 随机大写字符
     */
    @Override
    public char getRandomChar() {
        return getRandomChar(SPECIAL_STR);
    }
}

public class RandomUpperChar extends AbstractRandomChar {

    /**
     * 随机获取大写字符
     * @return 随机大写字符
     */
    @Override
    public char getRandomChar() {
        return getRandomChar(UPPER_STR);
    }
}

/**
 * 生成随机密码
 */
public class GenRandomPwd {

    /**
     * 保存 AbstractRandomChar 对象,用于随机数生成
     */
    private final List<AbstractRandomChar> randomCharList = new ArrayList<>();

    public GenRandomPwd(boolean genNumCharPwd, boolean genLowCharPwd, boolean genUpperCharPwd, boolean genSpecialCharPwd) {

        if (genNumCharPwd) {
            randomCharList.add(new RandomNumChar());
        }

        if (genLowCharPwd) {
            randomCharList.add(new RandomLowChar());
        }

        if (genUpperCharPwd) {
            randomCharList.add(new RandomUpperChar());
        }

        if (genSpecialCharPwd) {
            randomCharList.add(new RandomSpecialChar());
        }

        // 默认都是false的情况下 指定只用数字生成随机数字
        if (randomCharList.isEmpty()) {
            randomCharList.add(new RandomNumChar());
        }
    }


    public String getRandomPwd(int length) {
        // 密码最大长度
        int maxPwdLength = 25;
        // 密码最小长度
        int minPwdLength = 6;
        if (length > maxPwdLength || length < minPwdLength) {
            System.out.printf("密码长度在%d～%d位之间", minPwdLength, maxPwdLength);
            return "";
        }
        // 创建集合将随机生成的字符放入到集合中
        List<Character> list = new ArrayList<>(length);

        // 产生随机数用于随机调用生成字符的函数
        int randomListSize = randomCharList.size();
        for (int i = 0; i < length; i++) {
            int randomCharNum = new SecureRandom().nextInt(randomListSize);
            // 随机从randomCharList中获取一个字符，并加入到list中
            list.add(randomCharList.get(randomCharNum).getRandomChar());
        }

        // 将选好的list打乱顺序重新排序
        Collections.shuffle(list);

        // 将char类型转string字符串
        StringBuilder result = new StringBuilder(list.size());
        for (Character c : list) {
            result.append(c);
        }
        return result.toString();
    }
    
}

public class PwdFrame {

    public void init() {
        Frame f = new Frame("强密码生成器");
        String pwdNumContent = "123";
        String pwdLowContent = "abc";
        String pwdUpperContent = "ABC";
        String pwdSpecialContent = "!@#";

        // 一些组件
        TextField tf = new TextField(22);
        f.setBounds(600, 250, 280, 140);
        JButton genPwdBtn = new JButton("生成");
        JLabel lenLabel = new JLabel("长度", JLabel.LEFT);
        JLabel contentLabel = new JLabel("内容", JLabel.LEFT);
        JPanel panel1 = new JPanel(new FlowLayout());
        JPanel panel2 = new JPanel(new FlowLayout());

        // 密码长度单选框
        ButtonGroup lenGroup = new ButtonGroup();
        JRadioButton len1 = new JRadioButton("6", true);
        JRadioButton len2 = new JRadioButton("8");
        JRadioButton len3 = new JRadioButton("14");
        JRadioButton len4 = new JRadioButton("16");
        JRadioButton len5 = new JRadioButton("20");
        lenGroup.add(len1);
        lenGroup.add(len2);
        lenGroup.add(len3);
        lenGroup.add(len4);
        lenGroup.add(len5);

        // 密码内容复选框
        JRadioButton content1 = new JRadioButton(pwdNumContent, true);
        JRadioButton content2 = new JRadioButton(pwdLowContent);
        JRadioButton content3 = new JRadioButton(pwdUpperContent);
        JRadioButton content4 = new JRadioButton(pwdSpecialContent);

        // 将组件添加到 panel
        panel1.add(lenLabel);
        panel1.add(len1);
        panel1.add(len2);
        panel1.add(len3);
        panel1.add(len4);
        panel1.add(len5);

        panel2.add(contentLabel);
        panel2.add(content1);
        panel2.add(content2);
        panel2.add(content3);
        panel2.add(content4);


        // 设置按钮功能
        genPwdBtn.addActionListener(e -> {
            // 获取密码长度单选框的值
            String checkBoxValLength = getCheckBoxVal(panel1);

            // 获取密码内容单选框的值
            String checkBoxValContent = getCheckBoxVal(panel2);
            boolean numPwd = checkBoxValContent.contains(pwdNumContent);
            boolean lowPwd = checkBoxValContent.contains(pwdLowContent);
            boolean upperPwd = checkBoxValContent.contains(pwdUpperContent);
            boolean specialPwd = checkBoxValContent.contains(pwdSpecialContent);

            // 生成强密码
            GenRandomPwd genRandomPwd = new GenRandomPwd(numPwd, lowPwd, upperPwd, specialPwd);
            tf.setText(genRandomPwd.getRandomPwd(Integer.parseInt(checkBoxValLength)));

            // 获取光标，使光标一直在文本框内
            tf.requestFocus();
        });

        f.add(tf);
        f.add(genPwdBtn);
        f.add(panel1);
        f.add(panel2);
        f.setResizable(false);

        //设置窗体布局模式为流式布局
        f.setLayout(new FlowLayout());

        //关闭窗口
        f.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        f.setVisible(true);
    }


    /**
     * 获取单选框、复选框的值
     *
     * @param panel panel对象
     * @return 单选框的值
     */
    public String getCheckBoxVal(JPanel panel) {
        StringBuilder info = new StringBuilder();
        for (Component c : panel.getComponents()) {
            if (c instanceof JRadioButton && ((JRadioButton) c).isSelected()) {
                // 按空格拆分获取复选框的值
                info.append(((JRadioButton) c).getText());
            }
        }
        return info.toString();
    }

}

public class AutoPwdMainStarter {
    public static void main(String[] args) {
        new PwdFrame().init();
    }
}

/**
 * 截屏小工具 参考：https://blog.csdn.net/Code__rookie/article/details/103509851 有改动
 * @author whitepure
 */
public class CaptureScreen extends JFrame implements ActionListener {
    private JButton start, cancel;
    private JPanel c;
    private BufferedImage get;
    private final JTabbedPane jtp;
    private int index;

    public CaptureScreen() {
        super("屏幕截取");
        try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        } catch (Exception exe) {
            System.out.println("截图异常");
            exe.printStackTrace();
        }
        initWindow();
        jtp = new JTabbedPane(JTabbedPane.TOP, JTabbedPane.SCROLL_TAB_LAYOUT);
    }


    /**
     * 初始化窗口
     */
    private void initWindow() {
        start = new JButton("开始截取");
        cancel = new JButton("退出");
        start.addActionListener(this);
        cancel.addActionListener(this);

        JPanel panel = new JPanel();
        JPanel all = new JPanel();

        c = new JPanel(new BorderLayout());
        panel.add(start);
        panel.add(cancel);

        all.add(panel);
        this.getContentPane().add(c, BorderLayout.CENTER);
        this.getContentPane().add(all, BorderLayout.SOUTH);
        setFrameSizeDefault();
        this.setVisible(true);
        this.setAlwaysOnTop(true);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setResizable(false);
    }

    /**
     * 设置窗口size 位置
     */
    private void setFrameSizeWhenExitsImg() {
        this.setSize(720, 620);
        this.setLocation(400,150);
    }

    /**
     * 设置窗口size 位置
     */
    private void setFrameSizeDefault() {
        this.setSize(180, 80);
        this.setLocation(600,300);
    }

    private void updates() {
        this.setVisible(true);
        if (get == null) {
            return;
        }
        // 如果索引是0,则表示一张图片都没有被加入过,则要清除当前的东西,重新把tabpane放进来
        if (index == 0) {
            c.removeAll();
            c.add(jtp, BorderLayout.CENTER);
        }
        PicPanel pic = new PicPanel(get);
        jtp.addTab("图片" + (++index), pic);
        jtp.setSelectedComponent(pic);
        SwingUtilities.updateComponentTreeUI(c);
    }


    /**
     * 点击开始截屏执行
     */
    private void doStart() {
        // 点击截屏后隐藏主界面并 sleep 500ms 彻底隐藏主界面
        this.setVisible(false);
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize();
        Rectangle rec = new Rectangle(0, 0, dimension.width, dimension.height);
        BufferedImage bi = null;
        try {
            bi = new Robot().createScreenCapture(rec);
        } catch (AWTException e) {
            e.printStackTrace();
        }
        JFrame jf = new JFrame();
        // 自定义的截屏时窗口对象，调整大小然后开始截图
        CutScreen temp = new CutScreen(jf, bi, dimension.width, dimension.height);
        jf.getContentPane().add(temp, BorderLayout.CENTER);

        jf.setUndecorated(true);
        jf.setSize(dimension);
        jf.setVisible(true);
        jf.setAlwaysOnTop(true);

        // 设置当前窗口大小
        setFrameSizeWhenExitsImg();
    }

    /**
     * 公用的处理保存图片的方法
     */
    public void doSave(BufferedImage get) {
        try {
            if (get == null) {
                JOptionPane.showMessageDialog(this
                        , "图片不能为空!!", "错误", JOptionPane.ERROR_MESSAGE);
                return;
            }
            JFileChooser jfc = new JFileChooser(".");
            jfc.addChoosableFileFilter(new gifFilter());
            jfc.addChoosableFileFilter(new bmpFilter());
            jfc.addChoosableFileFilter(new jpgFilter());
            jfc.addChoosableFileFilter(new pngFilter());
            int i = jfc.showSaveDialog(this);
            if (i == JFileChooser.APPROVE_OPTION) {
                File file = jfc.getSelectedFile();
                String about = "PNG";
                String ext = file.toString().toLowerCase();
                javax.swing.filechooser.FileFilter ff = jfc.getFileFilter();
                if (ff instanceof jpgFilter) {
                    if (!ext.endsWith(".jpg")) {
                        String ns = ext + ".jpg";
                        file = new File(ns);
                        about = "JPG";
                    }
                } else if (ff instanceof pngFilter) {
                    if (!ext.endsWith(".png")) {
                        String ns = ext + ".png";
                        file = new File(ns);
                        about = "PNG";
                    }
                } else if (ff instanceof bmpFilter) {
                    if (!ext.endsWith(".bmp")) {
                        String ns = ext + ".bmp";
                        file = new File(ns);
                        about = "BMP";
                    }
                } else if (ff instanceof gifFilter) {
                    if (!ext.endsWith(".gif")) {
                        String ns = ext + ".gif";
                        file = new File(ns);
                        about = "GIF";
                    }
                }
                if (ImageIO.write(get, about, file)) {
                    JOptionPane.showMessageDialog(this, "保存成功！");
                } else {
                    JOptionPane.showMessageDialog(this, "保存失败！");
                }
            }
        } catch (Exception exe) {
            exe.printStackTrace();
        }
    }

    /**
     * 公共的处理把当前的图片加入剪帖板的方法
     */
    public void doCopy(final BufferedImage image) {
        try {
            if (get == null) {
                JOptionPane.showMessageDialog(this
                        , "图片不能为空!!", "错误", JOptionPane.ERROR_MESSAGE);
                return;
            }

            Transferable trans = new Transferable() {
                @Override
                public DataFlavor[] getTransferDataFlavors() {
                    return new DataFlavor[]{DataFlavor.imageFlavor};
                }

                @Override
                public boolean isDataFlavorSupported(DataFlavor flavor) {
                    return DataFlavor.imageFlavor.equals(flavor);
                }

                @Override
                public Object getTransferData(DataFlavor flavor)
                        throws UnsupportedFlavorException, IOException {
                    if (isDataFlavorSupported(flavor)) {
                        return image;
                    }
                    throw new UnsupportedFlavorException(flavor);
                }
            };

            Toolkit.getDefaultToolkit().getSystemClipboard().setContents(trans, null);
            JOptionPane.showMessageDialog(this, "已复制到系统粘帖板!!");
        } catch (Exception exe) {
            exe.printStackTrace();
            JOptionPane.showMessageDialog(this
                    , "复制到系统粘帖板出错!!", "错误", JOptionPane.ERROR_MESSAGE);
        }
    }

    /**
     * 处理关闭事件
     * @param c 窗口对象
     */
    private void doClose(Component c) {
        jtp.remove(c);
        if (jtp.getTabCount() == 0){
            // 将当前截屏的窗口重置为初始化状态
            setFrameSizeDefault();
        }
        c = null;
        System.gc();
    }

    /**
     * 判断当前按钮发生的事件
     *
     * @param ae 事件对象
     */
    @Override
    public void actionPerformed(ActionEvent ae) {
        Object source = ae.getSource();
        if (source == start) {
            doStart();
            return;
        }
        if (source == cancel) {
            System.exit(0);
            return;
        }
        try {
            UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
            SwingUtilities.updateComponentTreeUI(this);
        } catch (Exception exe) {
            exe.printStackTrace();
        }
    }


    /**
     * 截图后预览截图的panel
     */
    private class PicPanel extends JPanel implements ActionListener {
        JButton save;
        JButton copy;
        JButton close;
        BufferedImage get;

        public PicPanel(BufferedImage get) {
            super(new BorderLayout());
            this.get = get;
            initPanel();
        }

        /**
         * 初始化
         */
        private void initPanel() {
            save = new JButton("保存");
            copy = new JButton("复制到剪帖板");
            close = new JButton("删除");

            JPanel buttonPanel = new JPanel();
            buttonPanel.add(copy);
            buttonPanel.add(save);
            buttonPanel.add(close);
            JLabel icon = new JLabel(new ImageIcon(get));
            this.add(new JScrollPane(icon), BorderLayout.CENTER);
            this.add(buttonPanel, BorderLayout.SOUTH);

            save.addActionListener(this);
            copy.addActionListener(this);
            close.addActionListener(this);
        }

        /**
         * 判断当前按钮点击发生的事件
         *
         * @param e 事件对象
         */
        @Override
        public void actionPerformed(ActionEvent e) {
            Object source = e.getSource();
            if (source == save) {
                doSave(get);
            } else if (source == copy) {
                doCopy(get);
            } else if (source == close) {
                get = null;
                doClose(this);
            }
        }
    }

    // 保存BMP格式的过滤器
    private class bmpFilter extends javax.swing.filechooser.FileFilter {
        public bmpFilter() {
        }

        @Override
        public boolean accept(File file) {
            if (file.toString().toLowerCase().endsWith(".bmp") ||
                    file.isDirectory()) {
                return true;
            } else {
                return false;
            }
        }

        @Override
        public String getDescription() {
            return "*.BMP(BMP图像)";
        }
    }

    // 保存JPG格式的过滤器
    private class jpgFilter extends javax.swing.filechooser.FileFilter {
        public jpgFilter() {
        }

        @Override
        public boolean accept(File file) {
            if (file.toString().toLowerCase().endsWith(".jpg") ||
                    file.isDirectory()) {
                return true;
            } else {
                return false;
            }
        }

        @Override
        public String getDescription() {
            return "*.JPG(JPG图像)";
        }
    }

    // 保存GIF格式的过滤器
    private class gifFilter extends javax.swing.filechooser.FileFilter {
        public gifFilter() {
        }

        @Override
        public boolean accept(File file) {
            return file.toString().toLowerCase().endsWith(".gif") ||
                    file.isDirectory();
        }

        @Override
        public String getDescription() {
            return "*.GIF(GIF图像)";
        }
    }

    // 保存PNG格式的过滤器
    private class pngFilter extends javax.swing.filechooser.FileFilter {
        @Override
        public boolean accept(File file) {
            return file.toString().toLowerCase().endsWith(".png") ||
                    file.isDirectory();
        }

        @Override
        public String getDescription() {
            return "*.PNG(PNG图像)";
        }
    }

    /**
     * 显示当前的屏幕图像
     */
    private class CutScreen extends JPanel implements MouseListener, MouseMotionListener {
        public static final int START_X = 1;
        public static final int START_Y = 2;
        public static final int END_X = 3;
        public static final int END_Y = 4;
        private final BufferedImage bi;
        private final int width;
        private final int height;
        private final JFrame jf;
        //表示一般情况下的鼠标状态（十字线）
        private final Cursor cs = new Cursor(Cursor.CROSSHAIR_CURSOR);
        private int startX, startY, endX, endY, tempX, tempY;
        //表示选中的区域
        private Rectangle select = new Rectangle(0, 0, 0, 0);
        // 表示当前的编辑状态
        private States current = States.DEFAULT;
        //表示八个编辑点的区域
        private Rectangle[] rec;
        //当前被选中的X和Y,只有这两个需要改变
        private int currentX, currentY;
        //当前鼠标移的地点
        private Point p = new Point();
        //是否显示提示.如果鼠标左键一按,则提示就不再显示了
        private boolean showTip = true;

        public CutScreen(JFrame jf, BufferedImage bi, int width, int height) {
            this.jf = jf;
            this.bi = bi;
            this.width = width;
            this.height = height;
            this.addMouseListener(this);
            this.addMouseMotionListener(this);
            initRecs();
        }

        private void initRecs() {
            rec = new Rectangle[8];
            for (int i = 0; i < rec.length; i++) {
                rec[i] = new Rectangle();
            }
        }

        @Override
        public void paintComponent(Graphics g) {
            g.drawImage(bi, 0, 0, width, height, this);
            g.setColor(Color.RED);
            g.drawLine(startX, startY, endX, startY);
            g.drawLine(startX, endY, endX, endY);
            g.drawLine(startX, startY, startX, endY);
            g.drawLine(endX, startY, endX, endY);

            int x = Math.min(startX, endX);
            int y = Math.min(startY, endY);
            select = new Rectangle(x, y, Math.abs(endX - startX), Math.abs(endY - startY));
            int x1 = (startX + endX) / 2;
            int y1 = (startY + endY) / 2;

            g.fillRect(x1 - 2, startY - 2, 5, 5);
            g.fillRect(x1 - 2, endY - 2, 5, 5);
            g.fillRect(startX - 2, y1 - 2, 5, 5);
            g.fillRect(endX - 2, y1 - 2, 5, 5);
            g.fillRect(startX - 2, startY - 2, 5, 5);
            g.fillRect(startX - 2, endY - 2, 5, 5);
            g.fillRect(endX - 2, startY - 2, 5, 5);
            g.fillRect(endX - 2, endY - 2, 5, 5);

            rec[0] = new Rectangle(x - 5, y - 5, 10, 10);
            rec[1] = new Rectangle(x1 - 5, y - 5, 10, 10);
            rec[2] = new Rectangle((Math.max(startX, endX)) - 5, y - 5, 10, 10);
            rec[3] = new Rectangle((Math.max(startX, endX)) - 5, y1 - 5, 10, 10);
            rec[4] = new Rectangle((Math.max(startX, endX)) - 5, (Math.max(startY, endY)) - 5, 10, 10);
            rec[5] = new Rectangle(x1 - 5, (Math.max(startY, endY)) - 5, 10, 10);
            rec[6] = new Rectangle(x - 5, (Math.max(startY, endY)) - 5, 10, 10);
            rec[7] = new Rectangle(x - 5, y1 - 5, 10, 10);

            if (showTip) {
                g.setColor(Color.CYAN);
                g.fillRect(p.x, p.y, 235, 20);
                g.setColor(Color.RED);
                g.drawRect(p.x, p.y, 235, 20);
                g.setColor(Color.BLACK);
                g.drawString("按住鼠标不放选择截图,双击完成截图", p.x + 10, p.y + 15);
            }
        }

        /**
         * 根据东南西北等八个方向决定选中的要修改的X和Y的座标
         *
         * @param state 状态
         */
        private void initSelect(States state) {
            switch (state) {
                case EAST:
                    currentX = (endX > startX ? END_X : START_X);
                    currentY = 0;
                    break;
                case WEST:
                    currentX = (endX > startX ? START_X : END_X);
                    currentY = 0;
                    break;
                case NORTH:
                    currentX = 0;
                    currentY = (startY > endY ? END_Y : START_Y);
                    break;
                case SOUTH:
                    currentX = 0;
                    currentY = (startY > endY ? START_Y : END_Y);
                    break;
                case NORTH_EAST:
                    currentY = (startY > endY ? END_Y : START_Y);
                    currentX = (endX > startX ? END_X : START_X);
                    break;
                case NORTH_WEST:
                    currentY = (startY > endY ? END_Y : START_Y);
                    currentX = (endX > startX ? START_X : END_X);
                    break;
                case SOUTH_EAST:
                    currentY = (startY > endY ? START_Y : END_Y);
                    currentX = (endX > startX ? END_X : START_X);
                    break;
                case SOUTH_WEST:
                    currentY = (startY > endY ? START_Y : END_Y);
                    currentX = (endX > startX ? START_X : END_X);
                    break;
                case DEFAULT:
                default:
                    currentX = 0;
                    currentY = 0;
                    break;
            }
        }

        /**
         * 鼠标移动对象
         *
         * @param me 事件对象
         */
        @Override
        public void mouseMoved(MouseEvent me) {
            doMouseMoved(me);
            initSelect(current);
            if (showTip) {
                p = me.getPoint();
                repaint();
            }
        }

        /**
         * 处理鼠标移动,是为了每次都能初始化一下所要选择的区域
         *
         * @param me 鼠标事件对象
         */
        private void doMouseMoved(MouseEvent me) {
            if (select.contains(me.getPoint())) {
                this.setCursor(new Cursor(Cursor.MOVE_CURSOR));
                current = States.MOVE;
            } else {
                States[] st = States.values();
                for (int i = 0; i < rec.length; i++) {
                    if (rec[i].contains(me.getPoint())) {
                        current = st[i];
                        this.setCursor(st[i].getCursor());
                        return;
                    }
                }
                this.setCursor(cs);
                current = States.DEFAULT;
            }

        }

        @Override
        public void mouseExited(MouseEvent me) {
        }

        @Override
        public void mouseEntered(MouseEvent me) {
        }

        /**
         * 鼠标拖拽对象
         *
         * @param me 事件对象
         */
        @Override
        public void mouseDragged(MouseEvent me) {
            int x = me.getX();
            int y = me.getY();
            // 分别处理一系列的（光标）状态（枚举值）
            if (current == States.MOVE) {
                startX += (x - tempX);
                startY += (y - tempY);
                endX += (x - tempX);
                endY += (y - tempY);
                tempX = x;
                tempY = y;
            } else if (current == States.EAST || current == States.WEST) {
                if (currentX == START_X) {
                    startX += (x - tempX);
                    tempX = x;
                } else {
                    endX += (x - tempX);
                    tempX = x;
                }
            } else if (current == States.NORTH || current == States.SOUTH) {
                if (currentY == START_Y) {
                    startY += (y - tempY);
                    tempY = y;
                } else {
                    endY += (y - tempY);
                    tempY = y;
                }
            } else if (current == States.NORTH_EAST || current == States.SOUTH_EAST || current == States.SOUTH_WEST) {
                if (currentY == START_Y) {
                    startY += (y - tempY);
                    tempY = y;
                } else {
                    endY += (y - tempY);
                    tempY = y;
                }
                if (currentX == START_X) {
                    startX += (x - tempX);
                    tempX = x;
                } else {
                    endX += (x - tempX);
                    tempX = x;
                }
            } else {
                startX = tempX;
                startY = tempY;
                endX = me.getX();
                endY = me.getY();
            }
            this.repaint();
        }


        /**
         * 鼠标按压事件
         *
         * @param me 事件对象
         */
        @Override
        public void mousePressed(MouseEvent me) {
            showTip = false;
            tempX = me.getX();
            tempY = me.getY();
        }


        /**
         * 鼠标释放事件
         *
         * @param me 事件对象
         */
        @Override
        public void mouseReleased(MouseEvent me) {
            // 鼠标右键
            if (me.isPopupTrigger()) {
                if (current == States.MOVE) {
                    showTip = true;
                    p = me.getPoint();
                    startX = 0;
                    startY = 0;
                    endX = 0;
                    endY = 0;
                    repaint();
                } else {
                    jf.dispose();
                    updates();
                }
            }
        }


        /**
         * 鼠标点击事件
         *
         * @param me 事件
         */
        @Override
        public void mouseClicked(MouseEvent me) {
            // 双击左键触发事件
            if (me.getClickCount() == 2 && select.contains(me.getPoint())) {
                if (select.x + select.width < this.getWidth() && select.y + select.height < this.getHeight()) {
                    get = bi.getSubimage(select.x, select.y, select.width, select.height);
                    jf.dispose();
                    updates();
                    return;
                }

                int wid = select.width, het = select.height;
                if (select.x + select.width >= this.getWidth()) {
                    wid = this.getWidth() - select.x;
                }
                if (select.y + select.height >= this.getHeight()) {
                    het = this.getHeight() - select.y;
                }
                get = bi.getSubimage(select.x, select.y, wid, het);
                jf.dispose();
                updates();
            }
        }

    }
    
}