Java 虚拟键盘

痛定思痛。 2022-04-17 07:10 389阅读 0赞

在软件开发的过程中，涉及到触屏键盘的设计问题，利用Java swing来设计一个键盘，实现数据的传输。在网上看到了这段代码，自己看明白了设计原理，并加了一些注释，代码如下：

  1. import java.awt.AWTException;
  2. import java.awt.Robot;
  3. import java.awt.Toolkit;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6. import java.awt.event.KeyEvent;
  7. import java.util.HashMap;
  8. import java.util.Map; 
  9. import javax.swing.JButton;
  10. import javax.swing.JFrame;
  11. import javax.swing.JPanel;
  12. import javax.swing.JTextField; 
  14. /* 设置Java键盘本质上利用swing图形界面控制相关的知识，来在JFrame中搭建一个键盘界面，实现利用键盘控制输入，
  15.  * 电脑键盘的主面板主体包含有二十六个字母和诗歌数字以及其他相关字符，如果利用按钮时间一个一个实现，那将花费
  16.  * 太多的时间和经历， 故而在这个例子中，很好地利用了数组，即将键盘中的 键按行 来分为五个数组，每个数组包含一
  17.  * 行键盘的字符，利用数组来实现键盘的设置，
  18.  */
  20. public class tEST1 extends JPanel implements ActionListener{
  21.     JTextField text  ;
  22.     Robot robot;    
  23.     //line1到line5分别表示键盘的第一排到第五排，在Java中，每一个键有自己的keycode值，
  24.     //例如：0~9的keycode是48~57，A~Z是65~90；
  25.     int[] line1 = {192,49,50,51,52,53,54,55,56,57,48,45,61,8}; // 按键的第一排
  26.     int[] line2 = {81,87,69,82,84,89,85,73,79,80,91,93,92};    // q到\ 没有tab
  27.     int[] line3 = {KeyEvent.VK_CAPS_LOCK,65,83,68,70,71,72,74,75,76,59,222,10}; // 大写到'
  28.     int[] line4 = {16,90,88,67,86,66,78,77,44,46,47,38}; // shift到 向上
  29.     int[] line5 = {17,18,32,18,17,37,40,39};    // ctrl到 >  不包括 fn、window
  30.     Map<Integer, String> uncharMap = new HashMap<Integer, String>(); // 特殊字符
  31.     public tEST1() {
  32.         // 获取当前大小写
  33.         //boolean isUpper = Toolkit.getDefaultToolkit().getLockingKeyState(KeyEvent.VK_CAPS_LOCK);
  34.         //System.out.println("当前是否大写："+isUpper);
  35.         // 模拟输入
  36.         try {
  37.             robot = new Robot();
  38.         } catch (AWTException e) {
  39.             // TODO Auto-generated catch block
  40.             e.printStackTrace();
  41.         }
  42.         //
  43.         this.setLayout(null);
  44.         int x = 20,y = 20 ,width = 60 , height = 40;
  46.         //定义一个文本框类，用于显示键盘输入文本框中的字符
  47.         text = new JTextField(); 
  48.         text.setBounds(x, y, 800, height);          
  49.         this.add(text);
  50.         text.grabFocus();
  51.         // 替换特殊字符
  52.         initUnChar();
  53.         // 添加从 33 - 126 的ascii
  54.         int[][] keyint = new int[5][];//定义一个五行的二维数组
  55.         keyint[0] = line1;
  56.         keyint[1] = line2;
  57.         keyint[2] = line3;
  58.         keyint[3] = line4;
  59.         keyint[4] = line5;
  60.         y = y + height + 20;//height=40;
  61.         // load keys  
  62.         int startx = 0,cellspace = 7;
  63.         loadKeys(line1,startx,cellspace,x, y, width, height);
  64.         y = y + height + 20;    
  66.         // line2
  67.         int[] tmpInt = new int[]{line2[0]}; // tab
  68.         //第二行中，第一个键比较大，故而单独列出
  69.         loadKeys(tmpInt,0,cellspace, x, y, width + width /2 , height); 
  70.         startx = x + width + width / 2 - cellspace * 2 ;
  71.         tmpInt = new int[line2.length - 1];//新数组的长度为原数组长度减一
  72.         System.arraycopy(line2, 1, tmpInt, 0, tmpInt.length);//给行中给每个键加入相应的字符
  73.         loadKeys(tmpInt,startx ,cellspace, x, y, width, height);
  75.         // line3                
  76.         y = y + height + 20;
  77.         tmpInt = new int[]{line3[0]};
  78.         loadKeys(tmpInt,0,cellspace, x, y, width * 2 , height);
  79.         startx = x + width * 2 - cellspace * 2 ;
  80.         tmpInt = new int[line3.length - 1];
  81.         System.arraycopy(line3, 1, tmpInt, 0, tmpInt.length);
  82.         loadKeys(tmpInt,startx,cellspace, x, y, width, height);
  84.         // line4
  85.         y = y + height + 20;
  86.         tmpInt = new int[]{line4[0]};
  87.         loadKeys(tmpInt,0,cellspace, x, y, width * 2 + width / 2 , height);
  88.         startx = x + width * 2 + width / 2 - cellspace * 2 ;
  89.         tmpInt = new int[line4.length - 1];
  90.         System.arraycopy(line4, 1, tmpInt, 0, tmpInt.length);
  91.         loadKeys(tmpInt,startx,cellspace, x, y, width, height);
  92.         /**
  93.         for(int i = 0;i < keyint.length;i++){
  94.             for(int j = 0;j < keyint[i].length; j++){
  95.                 String showStr = uncharMap.get(keyint[i][j]); // 显示的字符
  96.                 if(showStr == null){
  97.                     showStr = String.valueOf((char) keyint[i][j]);
  98.                 }
  99.                 MyJButton jb = new MyJButton(showStr);
  100.                 jb.setBounds((x + width )* (j + 1) , y, width, height);
  101.                 jb.setFocusable(false); //   最关键的一句话 
  102.                 jb.setValue(keyint[i][j]); // 
  103.                 jb.addActionListener(this);
  104.                 this.add(jb);
  105.             }
  106.             x = 20;
  107.             y = y + height + 20;
  108.         }
  109.         */
  110.     }
  111.      public static void main(String[] args) {        
  112.         //定义一个容器，用来实例化tEST1类,放入虚拟键盘 
  113.         JFrame frame = new JFrame();
  114.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  115.         frame.setSize(1024, 800);
  116.         tEST1 kb = new tEST1();
  117.         frame.add(kb);
  118.         frame.setVisible(true);        
  119.     } 
  120.     @Override
  121.     public void actionPerformed(ActionEvent e) {     //定义键盘中每个键的监听器。
  122.         MyJButton jb = (MyJButton)e.getSource();
  123.         int key = jb.getValue();
  124.         //System.out.println(key);
  125.         robot.keyPress(key);
  126.         robot.keyRelease(key);
  127.     }
  128.     // 初始化特殊字符，在键盘中加入特殊字符。 
  129.     public void initUnChar(){
  130.         uncharMap.put(192, "`");
  131.         uncharMap.put(8, "退格");
  132.         uncharMap.put(222, "'");
  133.         uncharMap.put(KeyEvent.VK_CAPS_LOCK, "大/小写");
  134.         uncharMap.put(10, "回车");
  135.         uncharMap.put(16, "SHIFT");
  136.         uncharMap.put(17, "CTRL");
  137.         uncharMap.put(17, "ALT");
  138.         uncharMap.put(38, "↑");
  139.         uncharMap.put(37, "←");
  140.         uncharMap.put(39, "→");
  141.         uncharMap.put(40, "↓");
  142.     }    
  143.     class MyJButton extends JButton{             //定义一个JButton类
  144.         int value;
  145.         public MyJButton(String showStr) {
  146.             super(showStr);
  147.         }
  148.         public void setValue(int value) {
  149.             this.value = value;
  150.         }
  151.         public int getValue() {
  152.             return value;
  153.         }
  154.     }    
  155.     /**loadKey方法体的主要作用是将每个字符定义为键，利用按钮来控制输入输出有七个参数，
  156.      * 难度在于在每个按钮上显示相应的字母和设置一行键的相对坐标位置，设计的参数有键盘在容器中的相对位置，
  157.      * 键盘每一行的起始坐标，键与键之间的间隔，
  158.      * line[]用来表示数组，一个数组中含有多个按键，可以依次加载键盘
  159.      * startx值表示键盘每一行的初始位置，cellspace表示每个键之间的间隔
  160.      * x代表键盘在容器中横向坐标，y代表键盘在容器中的纵向坐标，也就是键盘相对于jframe的相对位置
  161.      * width和height分别代表按钮的长宽，也就是按钮的大小，
  162.      */
  163.     public void loadKeys(int[] line,int startx,int cell,int x,int y ,int width,int height){
  164.         // line 1
  165.         for(int j = 0;j < line.length; j++){
  166.             String showStr = uncharMap.get(line[j]); // 显示的字符，利用showstr来获取每个键的字符，
  167.             if(showStr == null){
  168.                 showStr = String.valueOf((char) line[j]);
  169.             }
  170.             MyJButton jb = new MyJButton(showStr);
  171.             jb.setBounds(startx + x + (cell + width) * j  , y, width, height);
  172.             jb.setFocusable(false); //   最关键的一句话 
  173.             jb.setValue(line[j]); // 
  174.             jb.addActionListener(this);
  175.             this.add(jb);
  176.         }
  177.     }
  178. }

运行结果如下：
在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，389人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java 虚拟键盘

    在软件开发的过程中，涉及到触屏键盘的设计问题，利用Java swing来设计一个键盘，实现数据的传输。在网上看到了这段代码，自己看明白了设计原理，并加了一些注释，代码如下：

    痛定思痛。痛定思痛。/ 0 赞/ 390 阅读

    相关 虚拟键盘 input 挡住

    请注意，有一些浏览器会自动处理，有一些又不会，所以为了兼容，首先应该判断Input到底有没有处于【可视高度】的外面，如果是，再处理。但麻烦的是，正常的手机浏览器，如微信、...

    小灰灰小灰灰/ 0 赞/ 741 阅读