程序软键盘

蔚落 2022-03-26 03:10 217阅读 0赞

>  在一次软件设计中要设计软键盘，在网上找了一些软键盘的设计程序，下面的这一个是自己做了一些修改的，点击文本框就会弹出键盘来，后来因为一些原因放弃了设计软键盘的构思，将这段代码传到博客上，以便于以后有空继续学习。

package VideoTest;
    import java.awt.AlphaComposite;  
    import java.awt.BorderLayout;  
    import java.awt.Color;  
    import java.awt.Composite;  
    import java.awt.Container;  
    import java.awt.Cursor;  
    import java.awt.Dimension;  
    import java.awt.FlowLayout;  
    import java.awt.Font;  
    import java.awt.GradientPaint;  
    import java.awt.Graphics;  
    import java.awt.Graphics2D;  
    import java.awt.GridLayout;  
    import java.awt.Image;  
    import java.awt.Paint;  
    import java.awt.Polygon;  
    import java.awt.RenderingHints;  
    import java.awt.RenderingHints.Key;  
    import java.awt.event.ActionEvent;  
    import java.awt.event.ActionListener;  
    import java.awt.event.MouseAdapter;  
    import java.awt.event.MouseEvent;  
    import java.awt.image.BufferedImage;  
    import java.util.ArrayList;  
    import java.util.Arrays;  
    import java.util.Random;  
      
    import javax.swing.BorderFactory;  
    import javax.swing.ImageIcon;  
    import javax.swing.JFrame;  
    import javax.swing.JLabel;  
    import javax.swing.JPanel;  
    import javax.swing.JPasswordField;  
    import javax.swing.JPopupMenu;
    import javax.swing.JTextField;
    import javax.swing.JToolTip;  
    import javax.swing.border.Border;  
    import javax.swing.border.CompoundBorder;  
    import javax.swing.border.EmptyBorder;  
      
    import sun.swing.SwingUtilities2;  
      
    //软键盘弹出菜单  
    public class tESRT2 extends JPopupMenu {  
      
        private static final long serialVersionUID = 1L; 
      
      
        public static void main(String[] args) {  
      
            final JFrame frame = new JFrame();  
            frame.setLayout(new FlowLayout(FlowLayout.CENTER, 20, 20));  
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
            frame.setSize(1370, 800);  
            frame.setLocation(0,0);
            frame.setLocationRelativeTo(null);  
      
            final JPanel passwordPanel = new JPanel(new BorderLayout());  
            passwordPanel.setBackground(Color.WHITE);  
            passwordPanel.setPreferredSize(new Dimension(500, 150));  
            passwordPanel.setLayout(new BorderLayout());  
            passwordPanel.setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));  
      
            //frame.add(passwordPanel);  
     
        /*       
          //  final JPasswordField password = new JPasswordField();  
            password.setSelectedTextColor(Color.BLACK);// 颜色障眼法，产生不能去选中密码框的任何东西的幻觉，其实已经选中了但你不知道  
            password.setSelectionColor(Color.WHITE);// 颜色障眼法，产生不能去选中密码框的任何东西的幻觉，其实已经选中了但你不知道  
            password.setForeground(Color.BLACK);  
            password.setFont(password.getFont().deriveFont(22f));  
             password.setEchoChar('●');  
            password.setBorder(new EmptyBorder(5, 3, 0, 3));// 左间隙  
            passwordPanel.add(password, BorderLayout.CENTER);  
         */
    
            final JTextField viewText =new   JTextField();
            final tESRT2 keyPopup = new tESRT2(viewText);
             
            viewText.setOpaque(true);
            viewText.setBackground(Color.WHITE);
           // viewText.setBounds(100,20, 200, 100);
            viewText.setFont(new  Font("华文行楷",Font.BOLD,35));	
             viewText.addMouseListener(new MouseAdapter() {  
                public void mouseClicked(MouseEvent e) {  
                    if (!keyPopup.isVisible()) {  
                        keyPopup.show(passwordPanel, 0, passwordPanel.getPreferredSize().height);  
                      //  keyPopup.getSoftKeyBoardPanel().reset();  
                        keyPopup.repaint();  
                    }  
                }  
            });  
             passwordPanel.add(viewText, BorderLayout.CENTER);
    		   frame.add  (passwordPanel);
        
           /* 
            
            //final tESRT2 keyPopup = new tESRT2(viewText);  
            final JLabel keyBoard = new JLabel("软件盘");  
            keyBoard.setOpaque(true);  
            keyBoard.setBackground(Color.WHITE);  
            keyBoard.setBorder(new EmptyBorder(0, 0, 0, 0));  
            keyBoard.setToolTipText("打开软键盘");  
            keyBoard.setPreferredSize(new Dimension(100,100));  
            keyBoard.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));  
      
            keyBoard.addMouseListener(new MouseAdapter() {  
                public void mouseClicked(MouseEvent e) {  
                    if (!keyPopup.isVisible()) {  
                        keyPopup.show(passwordPanel, 0, passwordPanel.getPreferredSize().height);  
                      //  keyPopup.getSoftKeyBoardPanel().reset();  
                        keyPopup.repaint();  
                    }  
                }  
            });  
            
            passwordPanel.add(keyBoard, BorderLayout.EAST);  
           */
            frame.setVisible(true);  
        }  
      
        private static Color transparentColor = new Color(255, 255, 255, 0);  
        // private static Dimension popupSize = new Dimension(360, 110);//QQ软键盘大小  
        private static Dimension popupSize = new Dimension(1200, 400);  
        private static Color backColor = new Color(23, 127, 194);  //设置面板的颜色
        private static Random random = new Random();  
      
        protected SoftKeyBoardPanel softKeyBoardPanel;  
      
        public tESRT2(JTextField viewText) {  
            softKeyBoardPanel = new SoftKeyBoardPanel(viewText, this);  
            softKeyBoardPanel.setPreferredSize(popupSize);  
            //softKeyBoardPanel.setBorder(BorderFactory.createEmptyBorder());  
      
            add(softKeyBoardPanel);  
            setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));// 空边框  
            setOpaque(false);// 透明  
        }  
      
        public static void gc() {  
            popupSize = null;  
            backColor = null;  
            random = null;  
            System.gc();  
        }  
      
        public static void resetValue() {  
            popupSize = new Dimension(380, 110);  
            backColor = new Color(23, 127, 194);  
            random = new Random();  
        }  
      
        public SoftKeyBoardPanel getSoftKeyBoardPanel() {  
            return softKeyBoardPanel;  
        }  
      
        // 软键盘面板  
        public static class SoftKeyBoardPanel extends JPanel implements ActionListener {  
             JTextField   viewText;
           // JPasswordField passwordField;  
            JPopupMenu popupMenu;  
            RowPanel[] rows;  
            KeyStatus status = KeyStatus.normal;  
            Paint[] paints = new Paint[] { new Color(70, 67, 114), new Color(62, 192, 238), new Color(138, 180, 231) };  
      
            public SoftKeyBoardPanel(JTextField  viewText, JPopupMenu popupMenu) {  
                this.viewText =  viewText;  
                this.popupMenu = popupMenu;  
                initSoftKeyBoardPanel();  
            }  
      
            // 初始化  
            private void initSoftKeyBoardPanel() {  
                setLayout(null);  
                setBackground(backColor);  
      
                JPanel proxyPanel = new JPanel(new GridLayout(4, 1, 0, 5));// 4行一列，0水平间隙，1垂直间隙  
                proxyPanel.setBackground(backColor);  
                proxyPanel.setLocation(3, 4);  
                proxyPanel.setSize(popupSize.width - 6, popupSize.height - 7);  
                add(proxyPanel);  
      
                rows = new RowPanel[] { new RowPanel(RowType.first), new RowPanel(RowType.second), new RowPanel(RowType.third), new RowPanel(RowType.fourth) };  
                for (int i = 0; i < rows.length; i++) {  
                    proxyPanel.add(rows[i]);  
                }  
            }  
      
            // 重写paint绘制想要的效果  
            @Override  
            public void paint(Graphics g) {  
                super.paint(g);  
                Graphics2D g2d = (Graphics2D) g;  
                ImageTool.setAntiAliasing(g2d);// 抗锯齿  
                ImageTool.drawRoundRect(g2d, getWidth(), getHeight(), 0, null, paints);// 绘制软键盘成圆角和多层颜色边框  
            }  
      
            // 处理所有软键盘点击事件  
            @Override  
            public void actionPerformed(ActionEvent e) {  
                KeyLable keyLable = (KeyLable) e.getSource();  
                if (keyLable.isShift() || keyLable.isCapsLock()) {  
                    boolean pressed = keyLable.isPressed();  
      
                    if (keyLable.isShift()) {  
                        clickShift();  
                    } else if (keyLable.isCapsLock()) {  
                        clickCapsLock();  
                    }  
                    pressed = !pressed;  
                    keyLable.setPressed(pressed);  
      
                    notifyKeyLabel();  
                } else if (keyLable.isBackSpace()) {  
                    clickBackSpace();  
                } else if (keyLable.isCommKey()) {  
                    String key;  
                    if (status == KeyStatus.shift || status == KeyStatus.shiftAndCapsLock) {  
                        key = keyLable.getCenterKey();  
                    } else if (status == KeyStatus.normal || status == KeyStatus.capsLock) {  
                        key = keyLable.getLowerLeftKey() == null ? keyLable.getCenterKey() : keyLable.getLowerLeftKey();  
                    } else {  
                        key = "";  
                    }  
                    clickCommKey(key);  
                }  
            }  
      
            // 通知KeyLabel更新状态  
            public void notifyKeyLabel() {  
                for (RowPanel rowPanel : rows) {  
                    for (KeyLable keyLable : rowPanel.getKeys()) {  
                        keyLable.setStatus(status);  
                    }  
                }  
            }  
      
            // 重置键盘， 清除按压状态，并将键盘恢复至初始状态  
            public void reset() {  
                for (RowPanel rowPanel : rows) {  
                    for (KeyLable keyLable : rowPanel.getKeys()) {  
                        keyLable.reset();  
                    }  
                }  
                status = KeyStatus.normal;  
            }  
      
            // 更改状态  
            public void clickShift() {  
                if (status == KeyStatus.capsLock) {  
                    status = KeyStatus.shiftAndCapsLock;  
                } else if (status == KeyStatus.shiftAndCapsLock) {  
                    status = KeyStatus.capsLock;  
                } else if (status == KeyStatus.shift) {  
                    status = KeyStatus.normal;  
                } else if (status == KeyStatus.normal) {  
                    status = KeyStatus.shift;  
                } else {  
                    status = KeyStatus.normal;  
                }  
            }  
      
            // 更改状态  
            public void clickCapsLock() {  
                if (status == KeyStatus.capsLock) {  
                    status = KeyStatus.normal;  
                } else if (status == KeyStatus.shiftAndCapsLock) {  
                    status = KeyStatus.shift;  
                } else if (status == KeyStatus.shift) {  
                    status = KeyStatus.shiftAndCapsLock;  
                } else if (status == KeyStatus.normal) {  
                    status = KeyStatus.capsLock;  
                } else {  
                    status = KeyStatus.normal;  
                }  
            }  
     
            // 点击了删除键， 删除一个字符  
            public void clickBackSpace() {  
                String myviewText = viewText.getText();  
                if (myviewText != null && myviewText.length() > 0) { 
                	char[]  text=myviewText.toCharArray();
                     char[] copyOf = Arrays.copyOf( text, text.length - 1);  
                     viewText.setText(new String(copyOf));  
                   // System.out.println("已删除的字符：" + myviewText[myviewText.length - 1]);  
                    //System.out.println("删除后的的密码：" + new String(copyOf));  
                }  
            }  
      
            // 点击了普通的键，添加一个字符  
            public void clickCommKey(String key) {  
                if (key != null) {  
                    if (key.length() > 1) {// 可有可无的检查  
                        key = key.substring(0, key.length() - 1);  
                    }  
                    
                    String  viewText1=  viewText.getText();
                    String string = (viewText1 == null ? "" : new String(viewText1));  
                    viewText.setText(string + key);  
                   // System.out.println("新添加的字符：" + key);  
                   // System.out.println("添加后的密码：" + string + key);  
                }  
            }  
      
            public RowPanel[] getRows() {  
                return rows;  
            }  
      
            // 创建关闭图标  
            public Image createCloseImage(Color fontColor, boolean isFocus) {  
                int width = 20;  
                BufferedImage bi = new BufferedImage(width, width, BufferedImage.TYPE_4BYTE_ABGR);  
                Graphics2D g2d = bi.createGraphics();  
      
                ImageTool.setAntiAliasing(g2d);  
      
                // 画背景  
                g2d.setPaint(transparentColor);  
                g2d.fillRect(0, 0, width, width);  
      
                int[] xpoints_1 = { 2, 4, 8, 10 };  
                int[] ypoints_1 = { 2, 2, 10, 10 };  
                int npoints_1 = 4;  
                Polygon p_left = new Polygon(xpoints_1, ypoints_1, npoints_1);// 左上角到右下角图标  
      
                int[] xpoints_2 = xpoints_1;  
                int[] ypoints_2 = { 10, 10, 2, 2 };  
                int npoints_2 = 4;  
                Polygon p_right = new Polygon(xpoints_2, ypoints_2, npoints_2);// 右上角到左下角图标  
      
                if (isFocus) {  
                    g2d.setPaint(new GradientPaint(0, 0, fontColor, 0, width, new Color(fontColor.getRed(), fontColor.getGreen(), fontColor.getBlue(), 50)));  
                } else {  
                    g2d.setPaint(fontColor);  
                }  
                // 画关闭图标("x")  
                g2d.fillPolygon(p_left);  
                g2d.fillPolygon(p_right);  
      
                return bi;  
            }  
      
            public class RowPanel extends JPanel {  
                RowType rowType;  
                KeyLable[] keys;  
      
                public RowPanel(RowType rowType) {  
                    this.rowType = rowType;  
                    initRowPanel();  
                }  
      
                private void initRowPanel() {  
                    setOpaque(true);  
                    setLayout(new FlowLayout(FlowLayout.CENTER, 10, 0));// 水平间隙1，垂直间隙0  
                    setBackground(backColor);  
                    if (rowType == RowType.first) {  
      
                        KeyLable key1 = new KeyLable("  !  ", "  1  ", SoftKeyBoardPanel.this);  
                        KeyLable key2 = new KeyLable("  @  ", "  2  ", SoftKeyBoardPanel.this);  
                        KeyLable key3 = new KeyLable("  #  ", "  3  ", SoftKeyBoardPanel.this);  
                        KeyLable key4 = new KeyLable("  $  ", "  4  ", SoftKeyBoardPanel.this);  
                        KeyLable key5 = new KeyLable("  %  ", "  5  ", SoftKeyBoardPanel.this);  
                        KeyLable key6 = new KeyLable("  ^  ", "  6  ", SoftKeyBoardPanel.this);  
                        KeyLable key7 = new KeyLable("  &  ", "  7  ", SoftKeyBoardPanel.this);  
                        KeyLable key8 = new KeyLable("  *  ", "   8  ", SoftKeyBoardPanel.this);  
                        KeyLable key9 = new KeyLable("  (  ", "  9  ", SoftKeyBoardPanel.this);  
                        KeyLable key10 = new KeyLable("  )  ", "  0  ", SoftKeyBoardPanel.this);  
                        KeyLable key11 = new KeyLable("  ~  ", "  `  ", SoftKeyBoardPanel.this);// 这个键的位置随机  
                        KeyLable key12 = new KeyLable("BackSpace  ", true, SoftKeyBoardPanel.this);// 功能键，位置固定在最右  
                        key12.setPreferredSize(new Dimension(120, 60));  
      
                        keys = new KeyLable[] { key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12 };  
                        ArrayList<KeyLable> keylist = new ArrayList<KeyLable>(keys.length);  
      
                        for (KeyLable key : keys) {  
                            if (key != key11) {// key11排除在外  
                                keylist.add(key);  
                            }  
                        }  
      
                        int randomIndex = random.nextInt(keys.length - 1);// 排除最后一个留给key12的位置  
                        keylist.add(randomIndex, key11);  
      
                        for (KeyLable key : keylist) {  
                            this.add(key);  
                        }  
      
                        // 关闭Label  
                        final Image defaImage = createCloseImage(new Color(138, 180, 231), false);  
                        final Image focusImage = createCloseImage(new Color(30, 90, 150), true);  
                        final JLabel closeLabel = new JLabel(new ImageIcon(defaImage)) {  
                            JToolTip toolTip;  
      
                            protected void paintComponent(Graphics g) {  
                                super.paintComponent(g);  
                                ImageIcon icon = (ImageIcon) getIcon();  
                                if (icon != null) {  
                                    g.drawImage(icon.getImage(), 0, 0, 12, 12, 0, 0, 12, 12, null);  
                                }  
                            }  
      
                            public JToolTip createToolTip() {  
                                JToolTip toolTip = new JToolTip();  
                                Color color = new Color(118, 118, 118);  
      
                                toolTip.setComponent(this);  
                                toolTip.setTipText(this.getToolTipText());  
                                toolTip.setBackground(Color.WHITE);  
                                toolTip.setForeground(color);  
                                toolTip.setFont(new Font(Font.DIALOG, Font.PLAIN, 12));  
      
                                Border outside = BorderFactory.createLineBorder(color);  
                                Border inside = BorderFactory.createEmptyBorder(2, 3, 2, 3);  
                                CompoundBorder border = BorderFactory.createCompoundBorder(outside, inside);  
                                toolTip.setBorder(border);  
                                return toolTip;  
                            }  
                        };  
                        MouseAdapter mouseAdapter = new MouseAdapter() {  
                            public void mouseClicked(MouseEvent e) {  
                                popupMenu.setVisible(false);  
                            }  
      
                            public void mouseEntered(MouseEvent e) {  
                                closeLabel.setIcon(new ImageIcon(focusImage));  
                            }  
      
                            public void mouseExited(MouseEvent e) {  
                                closeLabel.setIcon(new ImageIcon(defaImage));  
                            }  
                        };  
                        closeLabel.setToolTipText("关闭");  
                        closeLabel.addMouseListener(mouseAdapter);  
                        closeLabel.setPreferredSize(new Dimension(12, 12));  
                        add(closeLabel);  
                    } else if (rowType == RowType.second) {  
                        // key1至key10是一个闭环顺序，通过随机数决定在哪个位置切断这个环从而使其变成单链  
                        KeyLable key1 = new KeyLable("  +  ", "  =  ", SoftKeyBoardPanel.this);  
                        KeyLable key2 = new KeyLable("  |  ", "  \\  ", SoftKeyBoardPanel.this);  
                        KeyLable key3 = new KeyLable("  {  ", "  [  ", SoftKeyBoardPanel.this);  
                        KeyLable key4 = new KeyLable("  }  ", "  ]  ", SoftKeyBoardPanel.this);  
                        KeyLable key5 = new KeyLable("  :  ", "  ;  ", SoftKeyBoardPanel.this);  
                        KeyLable key6 = new KeyLable("  \"  ", "  '  ", SoftKeyBoardPanel.this);  
                        KeyLable key7 = new KeyLable("  <  ", "  ,  ", SoftKeyBoardPanel.this);  
                        KeyLable key8 = new KeyLable("  >  ", "  .  ", SoftKeyBoardPanel.this);  
                        KeyLable key9 = new KeyLable("  ?  ", "  /  ", SoftKeyBoardPanel.this);  
                        KeyLable key10 = new KeyLable("  _  ", "  -  ", SoftKeyBoardPanel.this);  
                        KeyLable key11 = new KeyLable("  Shift  ", true, SoftKeyBoardPanel.this);// 功能键，位置固定在最左  
                        key11.setPreferredSize(new Dimension(110, 60));  
                        KeyLable key12 = new KeyLable("CapsLock", true, SoftKeyBoardPanel.this);// 功能键，位置固定在最右  
                        key12.setPreferredSize(new Dimension(110, 60));  
      
                        keys = new KeyLable[] { key11,key2, key3, key4, key5, key6, key7, key8, key9, key10,  key1, key12 };  
                        ArrayList<KeyLable> keylist = new ArrayList<KeyLable>(keys.length);  
                        int randomIndex = random.nextInt(keys.length - 2) + 1;// 随机切入点，排除key11和key12的位置  
      
                        keylist.add(key11);  
                        for (int i = randomIndex; i < keys.length - 1; i++) {  
                            keylist.add(keys[i]);  
                        }  
                        for (int i = 1; i < randomIndex; i++) {  
                            keylist.add(keys[i]);  
                        }  
                        keylist.add(key12);  
      
                        for (KeyLable key : keylist) {  
                            this.add(key);  
                        }  
                    } else if (rowType == RowType.third) {  
                        // key1至key13是一个闭环顺序，通过随机数决定在哪个位置切断这个环从而使其变成单链  
                        KeyLable key1 = new KeyLable("  q  ", SoftKeyBoardPanel.this);  
                        KeyLable key2 = new KeyLable("  w  ", SoftKeyBoardPanel.this);  
                        KeyLable key3 = new KeyLable("  e  ", SoftKeyBoardPanel.this);  
                        KeyLable key4 = new KeyLable("  r  ", SoftKeyBoardPanel.this);  
                        KeyLable key5 = new KeyLable("  t  ", SoftKeyBoardPanel.this);  
                        KeyLable key6 = new KeyLable("  y  ", SoftKeyBoardPanel.this);  
                        KeyLable key7 = new KeyLable("  u  ", SoftKeyBoardPanel.this);  
                        KeyLable key8 = new KeyLable("   i  ", SoftKeyBoardPanel.this);  
                        KeyLable key9 = new KeyLable("  o ", SoftKeyBoardPanel.this);  
                        KeyLable key10 = new KeyLable("  p  " , SoftKeyBoardPanel.this);  
                        KeyLable key11 = new KeyLable("  a  ", SoftKeyBoardPanel.this);  
                        KeyLable key12 = new KeyLable("  s  ", SoftKeyBoardPanel.this);  
                        KeyLable key13 = new KeyLable("  d  ", SoftKeyBoardPanel.this);  
      
                        keys = new KeyLable[] { key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13 };  
                        ArrayList<KeyLable> keylist = new ArrayList<KeyLable>(keys.length);  
                        int randomIndex = random.nextInt(keys.length);// 随机切入点  
      
                        for (int i = randomIndex; i < keys.length; i++) {  
                            keylist.add(keys[i]);  
                        }  
                        for (int i = 0; i < randomIndex; i++) {  
                            keylist.add(keys[i]);  
                        }  
      
                        for (KeyLable key : keylist) {  
                            this.add(key);  
                        }  
                    } else if (rowType == RowType.fourth) {  
                        // key1至key13是一个闭环顺序，通过随机数决定在哪个位置切断这个环从而使其变成单链  
                        KeyLable key1 = new KeyLable("  f  ", SoftKeyBoardPanel.this);  
                        KeyLable key2 = new KeyLable("  g  ", SoftKeyBoardPanel.this);  
                        KeyLable key3 = new KeyLable("  h  ", SoftKeyBoardPanel.this);  
                        KeyLable key4 = new KeyLable("  j  ", SoftKeyBoardPanel.this);  
                        KeyLable key5 = new KeyLable("  k  ", SoftKeyBoardPanel.this);  
                        KeyLable key6 = new KeyLable("  l  ", SoftKeyBoardPanel.this);  
                        KeyLable key7 = new KeyLable("  z  ", SoftKeyBoardPanel.this);  
                        KeyLable key8 = new KeyLable("  x  ", SoftKeyBoardPanel.this);  
                        KeyLable key9 = new KeyLable("  c  ", SoftKeyBoardPanel.this);  
                        KeyLable key10 = new KeyLable("  v   ", SoftKeyBoardPanel.this);  
                        KeyLable key11 = new KeyLable("  b  "  , SoftKeyBoardPanel.this);  
                        KeyLable key12 = new KeyLable("  n  ", SoftKeyBoardPanel.this);  
                        KeyLable key13 = new KeyLable("  m  ", SoftKeyBoardPanel.this);  
      
                        keys = new KeyLable[] { key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13 };  
                        ArrayList<KeyLable> keylist = new ArrayList<KeyLable>(keys.length);  
                        int randomIndex = random.nextInt(keys.length);// 随机切入点  
      
                        for (int i = randomIndex; i < keys.length; i++) {  
                            keylist.add(keys[i]);  
                        }  
                        for (int i = 0; i < randomIndex; i++) {  
                            keylist.add(keys[i]);  
                        }  
      
                        for (KeyLable key : keylist) {  
                            this.add(key);  
                        }  
                    }  
                }  
      
                public KeyLable[] getKeys() {  
                    return keys;  
                }  
            }  
        }  
      
        // 键标签  
        public static class KeyLable extends JLabel {  
      
            // 用String而不是char考虑有功能键显示的是文字，不想再多一个字段了  
            String centerKey;  
            String lowerLeftKey;  
            boolean isBackSpace;  
            boolean isCapsLock;  
            boolean isShift;  
            boolean isPressed;  
            KeyStatus status = KeyStatus.normal;  
            Dimension size = new Dimension(80, 60);    //键大小
            Color keyBorderColor = new Color(54, 112, 184);  
            Color keyBorderFocusColor = new Color(64, 194, 241);  
            Color keyBackColor = new Color(253, 255, 255);  
            Color keyBackFocusColor = new Color(28, 159, 228);  
            Font boldFont = new Font("微软雅黑", Font.PLAIN, 20);  
            Color boldColor = new Color(0, 0, 57);  
            Font plainFont = new Font("微软雅黑", Font.PLAIN, 20);  
            Color plainColor = new Color(156, 157, 197);  
      
            public KeyLable(String centerKey, ActionListener action) {  
                this(centerKey, null, action);  
            }  
      
            public KeyLable(String centerKey, String lowerLeftKey, ActionListener action) {  
                this(centerKey, lowerLeftKey, false, action);  
            }  
      
            public KeyLable(String centerKey, boolean isFunctionKey, ActionListener action) {  
                this(centerKey, null, isFunctionKey, action);  
            }  
      
            public KeyLable(String centerKey, String lowerLeftKey, boolean isFunctionKey, final ActionListener action) {  
                this.centerKey = centerKey;  
                this.lowerLeftKey = lowerLeftKey;  
                if (isFunctionKey) {// 这个变量主要是提高效率  
                    if (centerKey.indexOf("Shift") >= 0) {  
                        isShift = true;  
                    } else if (centerKey.indexOf("Back") >= 0 || centerKey.indexOf("Space") >= 0) {  
                        isBackSpace = true;  
                    } else if (centerKey.indexOf("Caps") >= 0 || centerKey.indexOf("Lock") >= 0) {  
                        isCapsLock = true;  
                    }  
                }  
      
                setOpaque(true);// 不透明  
                setBackground(keyBackColor);  
                setPreferredSize(size);  
                setBorder(BorderFactory.createLineBorder(keyBorderColor));  
                setFont(boldFont);  
      
                addMouseListener(new MouseAdapter() {  
                    public void mouseEntered(MouseEvent e) {  
                        KeyLable.this.setBackground(keyBackFocusColor);// 鼠标悬浮时的背景色  
                    }  
      
                    public void mouseExited(MouseEvent e) {  
                        // 如果不是Shift和CapsLock键则还原背景色，或者是Shift和CapsLock键但是不是按压状态也要还原背景色  
                        if ((!KeyLable.this.isShift && !KeyLable.this.isCapsLock) || (!isPressed)) {  
                            KeyLable.this.setBackground(keyBackColor);  
                        }  
                    }  
      
                    public void mouseClicked(MouseEvent e) {  
                        // 创建一个ActionEvent将KeyLable对象作为Source  
                        action.actionPerformed(new ActionEvent(KeyLable.this, ActionEvent.ACTION_PERFORMED, e.getID() + ""));  
                    }  
                });  
            }  
      
            @Override  
            protected void paintComponent(Graphics g) {  
                super.paintComponent(g);// 完成背景色的绘制  
      
                Graphics2D g2d = (Graphics2D) g;  
                ImageTool.setAntiAliasing(g2d);// 抗锯齿  
                Container parent = getParent();  
                ImageTool.clearAngle(g2d, parent != null ? parent.getBackground() : this.getBackground(), this.getWidth(), this.getHeight(), 4);// 清除角落变圆角  
      
                if (getMousePosition() != null) {// 如果鼠标正在这个键的范围内，绘制圆角边框  
                    g2d.setPaint(keyBorderFocusColor);  
                    g2d.drawRoundRect(1, 1, getWidth() - 3, getHeight() - 3, 4, 4);  
                }  
      
                if (status == KeyStatus.normal || status == KeyStatus.capsLock) {  
                    if (lowerLeftKey == null) {  
                        g2d.setFont(boldFont);  
                        g2d.setPaint(boldColor);  
                        // g2d.drawString(centerKey, isCommKey() ? 8 : 4, 17);  
                        SwingUtilities2.drawStringUnderlineCharAt(this, g2d, centerKey, -1, isCommKey() ? 8 : 4, 17);  
      
                    } else {  
                        g2d.setFont(plainFont);  
                        g2d.setPaint(plainColor);  
                        // g2d.drawString(centerKey, 12, 15);  
                        SwingUtilities2.drawStringUnderlineCharAt(this, g2d, centerKey, -1, 12, 15);  
      
                        g2d.setFont(boldFont);  
                        g2d.setPaint(boldColor);  
                        // g2d.drawString(lowerLeftKey, 3, 20);  
                        SwingUtilities2.drawStringUnderlineCharAt(this, g2d, lowerLeftKey, -1, 3, 20);  
                    }  
                } else if (status == KeyStatus.shift || status == KeyStatus.shiftAndCapsLock) {  
                    if (lowerLeftKey == null) {  
                        g2d.setFont(boldFont);  
                        g2d.setPaint(boldColor);  
                        // g2d.drawString(centerKey, isCommKey() ? 8 : 4, 17);  
                        SwingUtilities2.drawStringUnderlineCharAt(this, g2d, centerKey, -1, isCommKey() ? 8 : 4, 17);  
      
                    } else {  
                        g2d.setFont(boldFont);  
                        g2d.setPaint(boldColor);  
                        // g2d.drawString(centerKey, 10, 15);  
                        SwingUtilities2.drawStringUnderlineCharAt(this, g2d, centerKey, -1, 10, 15);  
      
                        g2d.setFont(plainFont);  
                        g2d.setPaint(plainColor);  
                        // g2d.drawString(lowerLeftKey, 3, 20);  
                        SwingUtilities2.drawStringUnderlineCharAt(this, g2d, lowerLeftKey, -1, 3, 20);  
                    }  
                }  
            }  
      
            public String getCenterKey() {  
                return centerKey;  
            }  
      
            public String getLowerLeftKey() {  
                return lowerLeftKey;  
            }  
      
            public boolean isBackSpace() {  
                return isBackSpace;  
            }  
      
            public boolean isCapsLock() {  
                return isCapsLock;  
            }  
      
            public boolean isShift() {  
                return isShift;  
            }  
      
            public void setPressed(boolean isPressed) {  
                this.isPressed = isPressed;  
            }  
      
            public boolean isPressed() {  
                return isPressed;  
            }  
      
            public boolean isCommKey() {  
                return !isBackSpace && !isCapsLock && !isShift;  
            }  
      
            // 重置  
            public void reset() {  
                this.isPressed = false;  
                if (isShift || isCapsLock) {  
                    KeyLable.this.setBackground(keyBackColor);  
                } else if (isCommKey()) {  
                    if (lowerLeftKey == null) {  
                        centerKey = centerKey.toLowerCase();  
                    }  
                }  
                status = KeyStatus.normal;  
                repaint();  
            }  
      
            // 设置状态  
            public void setStatus(KeyStatus status) {  
                if (isCommKey() && this.status != status) {  
                    if (status == KeyStatus.shift || status == KeyStatus.capsLock) {  
                        if (lowerLeftKey == null) {  
                            if (Character.isUpperCase(centerKey.charAt(0))) {  
                                centerKey = centerKey.toLowerCase();  
                            } else {  
                                centerKey = centerKey.toUpperCase();  
                            }  
                        }  
                    } else if (status == KeyStatus.normal || status == KeyStatus.shiftAndCapsLock) {  
                        if (lowerLeftKey == null) {  
                            centerKey = centerKey.toLowerCase();  
                        }  
                    }  
                    this.status = status;  
                    repaint();  
                }  
            }  
        }  
      
        public static enum RowType {  
            first, second, third, fourth  
        }  
      
        public static enum KeyStatus {  
            normal, shift, capsLock, shiftAndCapsLock  
        }  
    }  
      
    class ImageTool {  
      
        // 设置Graphics2D抗锯齿,具体请查看RenderingHints类的API  
        public static void setAntiAliasing(Graphics2D g2d) {  
            setRenderingHint(g2d, RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);  
        }  
      
        public static void setRenderingHint(Graphics2D g2d, Key key, Object value) {  
            if (g2d.getRenderingHints() == null) {  
                g2d.setRenderingHints(new RenderingHints(key, value));  
            } else {  
                g2d.setRenderingHint(key, value);  
            }  
        }  
      
        // 绘制圆角  
        public static void drawRoundRect(Graphics2D g2d, int width, int height, int r, Paint anglePaint, Paint[] borderPaints) {  
            clearAngle(g2d, anglePaint, width, height, r);// 清除角落  
            drawMultiBorder(g2d, width, height, r, anglePaint, borderPaints);// 画边框  
        }  
      
        // 清除角落  
        public static void clearAngle(Graphics2D g2d, Paint anglePaint, int width, int height, int r) {  
            setAntiAliasing(g2d);  
            Composite oldComposite = g2d.getComposite();  
      
            if (anglePaint == null) {  
                g2d.setComposite(AlphaComposite.Clear);// 设置Composite为清空  
            } else {  
                g2d.setPaint(anglePaint);  
            }  
      
            int npoints = 5;// 5点定位一个角落轨迹  
            // 左上角  
            int[] xpoints1 = { r, 0, 0, r / 4, r / 2 };  
            int[] ypoints1 = { 0, 0, r, r / 2, r / 4 };  
            Polygon polygon = new Polygon(xpoints1, ypoints1, npoints);  
            g2d.fillPolygon(polygon);  
            // 右上角  
            int[] xpoints2 = { width - r, width, width, width - r / 4, width - (r / 2) };  
            int[] ypoints2 = ypoints1;  
            polygon = new Polygon(xpoints2, ypoints2, npoints);  
            g2d.fillPolygon(polygon);  
            // 右下角  
            int[] xpoints3 = xpoints2;  
            int[] ypoints3 = { height, height, height - r, height - (r / 2), height - r / 4 };  
            polygon = new Polygon(xpoints3, ypoints3, npoints);  
            g2d.fillPolygon(polygon);  
            // 左下角  
            int[] xpoints4 = xpoints1;  
            int[] ypoints4 = ypoints3;  
            polygon = new Polygon(xpoints4, ypoints4, npoints);  
            g2d.fillPolygon(polygon);  
            // 还原Composite  
            g2d.setComposite(oldComposite);  
        }  
      
        // 绘制有层次感的边框  
        public static void drawMultiBorder(Graphics2D g2d, int width, int height, int r, Paint anglePaint, Paint[] borderPaints) {  
            setAntiAliasing(g2d);  
      
            int roundx = r * 2;  
            int roundy = roundx;  
            int grow = 2;  
            int x = 0;  
            int y = 0;  
            int w = width;  
            int h = height;  
      
            // 从外层往内层开始画  
            for (int i = 0; i < borderPaints.length; i++, x++, y++, w -= grow, h -= grow) {  
                g2d.setPaint(borderPaints[i]);  
                if (r > 0) {  
                    g2d.drawRoundRect(x, y, w - 1, h - 1, roundx, roundy);  
                } else {  
                    g2d.drawRect(x, y, w - 1, h - 1);  
                }  
            }  
        }  
    }

运行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTc5MjE2Mg_size_16_color_FFFFFF_t_70]: /images/20220326/357c343c40074d41a85d54024f3544cc.png