原文地址

http://blog.chinaunix.net/uid-23381466-id-3883164.html


概述：
查看/dev/input/eventX是什么类型的事件， cat /proc/bus/input/devices

设备有着自己特殊的按键键码，我需要将一些标准的按键，比如0－9，X－Z等模拟成标准按键，比如KEY_0,KEY-Z等，所以需要用到按键模拟，具体方法就是操作/dev/input/event1文件，向它写入个input_event结构体就可以模拟按键的输入了。

input_event 说明：
linux/input.h中有定义，这个文件还定义了标准按键的编码等

点击(此处)折叠或打开

  1. struct input_event {


  3. struct timeval time;//按键时间


  5. __u16 type;//类型，在下面有定义


  7. __u16 code;//要模拟成什么按键


  9. __s32 value;//是按下还是释放


  11. };


code：
事件的代码.如果事件的类型代码是EV_KEY,该代码code为设备键盘代码.代码植0~127为键盘上的按键代码,0x110~0x116 为鼠标上按键代码,其中0x110(BTN_LEFT)为鼠标左键,0x111(BTN_RIGHT)为鼠标右键,0x112(BTN_ MIDDLE)为鼠标中键.其它代码含义请参看include/linux/input.h文件. 如果事件的类型代码是EV_REL,code值表示轨迹的类型.如指示鼠标的X轴方向REL_X(代码为0x00),指示鼠标的Y轴方向REL_Y(代码为0x01),指示鼠标中轮子方向REL_WHEEL(代码为0x08).

type:
EV_KEY,键盘
EV_REL,相对坐标
EV_ABS,绝对坐标

value：
事件的值.如果事件的类型代码是EV_KEY,当按键按下时值为1,松开时值为0; 如果事件的类型代码是EV_ REL,value的正数值和负数值分别代表两个不同方向的值.

/*
* Eventtypes
*/
#defineEV_SYN 0x00
#define EV_KEY 0x01 //按键
#defineEV_REL 0x02 //相对坐标(轨迹球)
#defineEV_ABS 0x03 //绝对坐标
#defineEV_MSC 0x04 //其他
#defineEV_SW 0x05
#defineEV_LED 0x11 //LED
#define EV_SND0x12//声音
#defineEV_REP 0x14//repeat
#defineEV_FF 0x15
#defineEV_PWR 0x16
#define EV_FF_STATUS 0x17
#define EV_MAX 0x1f
#define EV_CNT (EV_MAX+1)

kernel里input模块

点击(此处)折叠或打开

  1. //input_dev结构:

  2. struct input_dev

  3. {

  4. void *private;


  6. const char *name;

  7. const char *phys;

  8. const char *uniq;

  9. struct input_id id;


  11. /*

  12. * 根据各种输入信号的类型来建立类型为unsigned long 的数组,

  13. * 数组的每1bit代表一种信号类型,

  14. * 内核中会对其进行置位或清位操作来表示时间的发生和被处理.

  15. */


  17. unsigned long evbit[NBITS(EV_MAX)];

  18. unsigned long keybit[NBITS(KEY_MAX)];

  19. unsigned long relbit[NBITS(REL_MAX)];

  20. unsigned long absbit[NBITS(ABS_MAX)];

  21. unsigned long mscbit[NBITS(MSC_MAX)];

  22. unsigned long ledbit[NBITS(LED_MAX)];

  23. unsigned long sndbit[NBITS(SND_MAX)];

  24. unsigned long ffbit[NBITS(FF_MAX)];

  25. unsigned long swbit[NBITS(SW_MAX)];


  27. .........................................

  28. };


  30. /**

  31. * input_set_capability - mark device as capable of a certain event

  32. * @dev: device that is capable of emitting or accepting event

  33. * @type: type of the event (EV_KEY, EV_REL, etc...)

  34. * @code: event code

  35. *

  36. *In addition to setting up corresponding bit in appropriate capability

  37. * bitmap the function also adjusts dev->evbit.

  38. */


  40. /* 记录本设备对于哪些事件感兴趣(对其进行处理)*/

  41. void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)

  42. {

  43. switch (type)

  44. {

  45. case EV_KEY:

  46. __set_bit(code, dev->keybit);//比如按键,应该对哪些键值的按键进行处理(对于其它按键不予理睬)

  47. break;


  49. case EV_REL:

  50. __set_bit(code, dev->relbit);

  51. break;


  53. case EV_ABS:

  54. __set_bit(code, dev->absbit);

  55. break;


  57. case EV_MSC:

  58. __set_bit(code, dev->mscbit);

  59. break;


  61. case EV_SW:

  62. __set_bit(code, dev->swbit);

  63. break;


  65. case EV_LED:

  66. __set_bit(code, dev->ledbit);

  67. break;


  69. case EV_SND:

  70. __set_bit(code, dev->sndbit);

  71. break;


  73. case EV_FF:

  74. __set_bit(code, dev->ffbit);

  75. break;


  77. default:

  78. printk(KERN_ERR

  79. "input_set_capability: unknown type %u (code %u)\n",

  80. type, code);

  81. dump_stack();

  82. return;

  83. }


  85. __set_bit(type, dev->evbit);//感觉和前面重复了(前面一经配置过一次了)

  86. }

  87. EXPORT_SYMBOL(input_set_capability);


  89. static irqreturn_t gpio_keys_isr(int irq, void *dev_id)

  90. {

  91. int i;

  92. struct platform_device *pdev = dev_id;

  93. struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;

  94. struct input_dev *input = platform_get_drvdata(pdev);


  96. for(i = 0; i < pdata->nbuttons; i++)

  97. {

  98. struct gpio_keys_button *button =&pdata->buttons[i];

  99. int gpio = button->gpio;


  101. if(irq == gpio_to_irq(gpio))//判断哪个键被按了?

  102. {

  103. unsigned int type = button->type ?: EV_KEY;

  104. int state =(gpio_get_value(gpio)? 1 : 0) ^ button->active_low;//记录按键状态


  106. input_event(input, type, button->code,!!state);//汇报输入事件

  107. input_sync(input);//等待输入事件处理完成

  108. }

  109. }


  111. return IRQ_HANDLED;

  112. }



  115. /*

  116. * input_event()- report new input event

  117. * @dev: device that generated the event

  118. * @type: type of the event

  119. * @code: event code

  120. * @value: value of the event

  121. *

  122. * This function should be used by drivers implementing various input devices

  123. * See also input_inject_event()

  124. */

  125. void input_event(struct input_dev *dev, unsigned int type, unsigned int code,int value)

  126. {

  127. struct input_handle *handle;


  129. if(type > EV_MAX ||!test_bit(type, dev->evbit))//首先判断该事件类型是否有效且为该设备所接受

  130. return;


  132. add_input_randomness(type, code, value);


  134. switch (type)

  135. {


  137. case EV_SYN:

  138. switch (code)

  139. {

  140. case SYN_CONFIG:

  141. if(dev->event)

  142. dev->event(dev, type, code, value);

  143. break;


  145. case SYN_REPORT:

  146. if(dev->sync)

  147. return;

  148. dev->sync = 1;

  149. break;

  150. }

  151. break;


  153. case EV_KEY:

  154. /*

  155. * 这里需要满足几个条件:

  156. * 1: 键值有效(不超出定义的键值的有效范围)

  157. * 2: 键值为设备所能接受(属于该设备所拥有的键值范围)

  158. * 3: 按键状态改变了

  159. */


  161. if(code > KEY_MAX ||!test_bit(code, dev->keybit)||!!test_bit(code, dev->key)== value)

  162. return;


  164. if(value == 2)

  165. break;


  167. change_bit(code, dev->key);//改变对应按键的状态


  169. /* 如果你希望按键未释放的时候不断汇报按键事件的话需要以下这个(在简单的gpio_keys驱动中不需要这个,暂时不去分析)*/

  170. if(test_bit(EV_REP, dev->evbit)&& dev->rep[REP_PERIOD]&& dev->rep[REP_DELAY]&& dev->timer.data && value)

  171. {

  172. dev->repeat_key = code;

  173. mod_timer(&dev->timer, jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));

  174. }


  176. break;

  177. ........................................................


  179. if(type != EV_SYN)

  180. dev->sync = 0;


  182. if(dev->grab)

  183. dev->grab->handler->event(dev->grab, type, code, value);

  184. else

  185. /*

  186. * 循环调用所有处理该设备的handle(event,mouse,ts,joy等),

  187. * 如果有进程打开了这些handle(进行读写),则调用其对应的event接口向气汇报该输入事件.

  188. */

  189. list_for_each_entry(handle,&dev->h_list, d_node)

  190. if(handle->open)

  191. handle->handler->event(handle, type, code, value);

  192. }

  193. }

  194. EXPORT_SYMBOL(input_event);



  197. //event层对于input层报告的这个键盘输入事件的处理:

  198. //drivers / input / evdev.c:


  200. static struct input_handler evdev_handler =

  201. {

  202. .event = evdev_event,

  203. .connect = evdev_connect,

  204. .disconnect = evdev_disconnect,

  205. .fops =&evdev_fops,

  206. .minor = EVDEV_MINOR_BASE,

  207. .name ="evdev",

  208. .id_table = evdev_ids,

  209. };


Linux 有自己的 input 子系统，可以统一管理鼠标和键盘事件。基于输入子系统 实现的 uinput 可以方便的在用户空间模拟鼠标和键盘事件。
当然，也可以自己造轮子， 做一个字符设备接收用户输入，根据输入，投递 input 事件。
还有一种方式就是直接 往 evnent 里写入数据， 都可以达到控制鼠标键盘的功能。

本篇文章就是演示直接写入 event 的方法。


1。模拟按键输入

点击(此处)折叠或打开

  1. //其中0表示释放，1按键按下，2表示一直按下

  2. //0 for EV_KEY for release, 1 for keypress and 2 for autorepeat.


  4. void simulate_key(int fd,int value)

  5. {

  6. struct input_event event;

  7. event.type = EV_KEY;

  8. //event.code = KEY_0;//要模拟成什么按键

  9. event.value = value;//是按下还是释放按键或者重复

  10. gettimeofday(&event.time, 0);

  11. if(write(fd,&event, sizeof(event))< 0)

  12. {

  13. dprintk("simulate key error~~~\n");

  14. return ;

  15. }

  16. }


2。模拟鼠标输入（轨迹球）

点击(此处)折叠或打开

  1. void simulate_mouse(int fd, char buf[4])

  2. {

  3. int rel_x, rel_y;

  4. static struct input_event event, ev;


  6. //buf[0],buf[2],小于0则为左移，大于0则为右移

  7. //buf[1],buf[3],小于0则为下移，大于0则为上移


  9. dprintk("MOUSE TOUCH: x1=%d,y1=%d,x2=%d,y2=%d\n", buf[0], buf[1], buf[2], buf[3]);

  10. rel_x =(buf[0]+ buf[2])/ 2;

  11. rel_y =-(buf[1]+ buf[3])/ 2;//和我们的鼠标是相反的方向，所以取反

  12. event.type = EV_REL;

  13. event.code = REL_X;

  14. event.value = rel_x;

  15. gettimeofday(&event.time, 0);

  16. if( write(fd,&event, sizeof(event))!= sizeof(event))

  17. dprintk("rel_x error~~~:%s\n", strerror(errno));

  18. event.code = REL_Y;

  19. event.value = rel_y;

  20. gettimeofday(&event.time, 0);

  21. if( write(fd,&event, sizeof(event))!= sizeof(event))

  22. dprintk("rel_y error~~~:%s\n", strerror(errno));


  24. //一定要刷新空的

  25. write(fd,&ev, sizeof(ev));

  26. }


鼠标和键盘文件打开方法：

点击(此处)折叠或打开

  1. int fd_kbd;///dev/input/event1

  2. int fd_mouse;//dev/input/mouse2


  4. fd_kbd = open("/dev/input/event1", O_RDWR);


  6. if(fd_kbd <= 0)

  7. {

  8. printf("error open keyboard:%s\n", strerror(errno));

  9. return -1;

  10. }


  12. fd_mouse = open("/dev/input/event3", O_RDWR);//如果不行的话，那试试/dev/input/mice

  13. if(fd_mouse <= 0)

  14. {

  15. printf("error open mouse:%s\n", strerror(errno));

  16. return -2;

  17. }


/dev/input/mice是鼠标的抽象，代表的是鼠标，也许是/dev/input/mouse,/dev/input/mouse1，或者空， 这个文件一直会存在。 这里你也许会问，我怎么知道/dev/input/eventX这些事件到底是什么事件阿，是鼠标还是键盘或者别的， eventX代表的是所有输入设备(input核心)的事件，比如按键按下，或者鼠标移动，或者游戏遥控器等等， 在系统查看的方法是 cat /proc/bus/input/devices 就可以看到每个eventX是什么设备的事件了。

下面是一个模拟鼠标和键盘输入的例子：
关于这里 open 哪个 event ， 可以通过 cat /proc/bus/input/devices


点击(此处)折叠或打开

  1. #include <string.h>

  2. #include <stdio.h>

  3. #include <sys/types.h>

  4. #include <sys/stat.h>

  5. #include <fcntl.h>

  6. #include <linux/input.h>

  7. #include <linux/uinput.h>

  8. #include <stdio.h>

  9. #include <sys/time.h>

  10. #include <sys/types.h>

  11. #include <unistd.h>


  13. void simulate_key(int fd,int kval)

  14. {

  15. struct input_event event;

  16. event.type = EV_KEY;

  17. event.value = 1;

  18. event.code = kval;

  19. gettimeofday(&event.time, 0);

  20. write(fd,&event, sizeof(event));

  21. event.type = EV_SYN;

  22. event.code = SYN_REPORT;

  23. event.value = 0;

  24. write(fd,&event, sizeof(event));


  26. memset(&event, 0, sizeof(event));

  27. gettimeofday(&event.time,NULL);

  28. event.type = EV_KEY;

  29. event.code = kval;

  30. event.value = 0;

  31. write(fd,&event, sizeof(event));

  32. event.type = EV_SYN;

  33. event.code = SYN_REPORT;

  34. event.value = 0;

  35. write(fd,&event, sizeof(event));

  36. }


  38. void simulate_mouse(int fd)

  39. {

  40. struct input_event event;

  41. memset(&event, 0, sizeof(event));

  42. gettimeofday(&event.time,NULL);

  43. event.type = EV_REL;

  44. event.code = REL_X;

  45. event.value = 10;

  46. write(fd,&event, sizeof(event));

  47. event.type = EV_REL;

  48. event.code = REL_Y;

  49. event.value = 10;

  50. write(fd,&event, sizeof(event));

  51. event.type = EV_SYN;

  52. event.code = SYN_REPORT;

  53. event.value = 0;

  54. write(fd,&event, sizeof(event));

  55. }


  57. int main()

  58. {

  59. int fd_kbd;

  60. int fd_mouse;

  61. fd_kbd = open("/dev/input/event1", O_RDWR);

  62. if(fd_kbd <= 0)

  63. {

  64. printf("error open keyboard:\n");

  65. return -1;

  66. }

  67. fd_mouse = open("/dev/input/event2", O_RDWR);

  68. if(fd_mouse <= 0)

  69. {

  70. printf("error open mouse\n");

  71. return -2;

  72. }

  73. int i = 0;

  74. for(i = 0; i < 10; i++)

  75. {

  76. simulate_key(fd_kbd, KEY_A + i);

  77. simulate_mouse(fd_mouse);

  78. sleep(1);

  79. }

  80. close(fd_kbd);

  81. }


下面是一个读取 鼠标和键盘事件的例子：

点击(此处)折叠或打开

  1. #include <stdio.h>

  2. #include <stdlib.h>

  3. #include <linux/input.h>

  4. #include <sys/types.h>

  5. #include <sys/stat.h>

  6. #include <fcntl.h>

  7. #include <unistd.h>

  8. #include <errno.h>


  10. static void show_event(struct input_event* event)

  11. {

  12. printf("%d %d %d\n", event->type, event->code, event->value);

  13. return;

  14. }


  16. int main(int argc, char* argv[])

  17. {

  18. struct input_event event ={{0}, 0};

  19. const char* file_name = argc == 2 ? argv[1]:"/dev/input/event2";

  20. int fd = open(file_name, O_RDWR);


  22. if(fd > 0)

  23. {

  24. while(1)

  25. {

  26. int ret = read(fd,&event, sizeof(event));

  27. if(ret == sizeof(event))

  28. {

  29. show_event(&event);

  30. }

  31. else

  32. {

  33. break;

  34. }

  35. }

  36. close(fd);

  37. }

  38. return 0;

  39. }



很多人对于 如何模拟 CTRL + SPACE 感兴趣， 下面也给个例子，呵呵。

点击(此处)折叠或打开

  1. void simulate_ctrl_space(int fd)

  2. {

  3. struct input_event event;

  4. //先发送一个 CTRL 按下去的事件。

  5. event.type = EV_KEY;

  6. event.value = 1;

  7. event.code = KEY_LEFTCTRL;

  8. gettimeofday(&event.time, 0);

  9. write(fd,&event, sizeof(event));

  10. event.type = EV_SYN;

  11. event.code = SYN_REPORT;

  12. event.value = 0;

  13. write(fd,&event, sizeof(event));

  14. //先发送一个 SPACE 按下去的事件。

  15. event.type = EV_KEY;

  16. event.value = 1;

  17. event.code = KEY_SPACE;

  18. gettimeofday(&event.time, 0);

  19. write(fd,&event, sizeof(event));

  20. //发送一个 释放 SPACE 的事件

  21. memset(&event, 0, sizeof(event));

  22. gettimeofday(&event.time,NULL);

  23. event.type = EV_KEY;

  24. event.code = KEY_SPACE;

  25. event.value = 0;

  26. write(fd,&event, sizeof(event));

  27. event.type = EV_SYN;

  28. event.code = SYN_REPORT;

  29. event.value = 0;

  30. write(fd,&event, sizeof(event));


  32. //发送一个 释放 CTRL 的事件

  33. memset(&event, 0, sizeof(event));

  34. gettimeofday(&event.time,NULL);

  35. event.type = EV_KEY;

  36. event.code = KEY_LEFTCTRL;

  37. event.value = 0;

  38. write(fd,&event, sizeof(event));


  40. event.type = EV_SYN;

  41. event.code = SYN_REPORT;

  42. event.value = 0;

  43. write(fd,&event, sizeof(event));

  44. }



浅析linux中鼠标数据读取

点击(此处)折叠或打开

  1. //我们就是去读/dev/input/mice设备节点,源码如下：

  2. #include <stdio.h>

  3. #include <errno.h>

  4. #include <fcntl.h>

  5. #include <sys/select.h>

  6. #include <string.h>


  8. /* Mouse button bits*/

  9. #define WHEEL_UP 0x10

  10. #define WHEEL_DOWN 0x08


  12. #define BUTTON_L 0x04

  13. #define BUTTON_M 0x02

  14. #define BUTTON_R 0x01

  15. #define SCALE 3 /* default scaling factor for acceleration */

  16. #define THRESH 5 /* default threshhold for acceleration */


  18. static int xpos;/* current x position of mouse */

  19. static int ypos;/* current y position of mouse */

  20. static int minx;/* minimum allowed x position */

  21. static int maxx;/* maximum allowed x position */

  22. static int miny;/* minimum allowed y position */

  23. static int maxy;/* maximum allowed y position */

  24. static int buttons;/* current state of buttons */

  25. static int scale = SCALE;/* acceleration scale factor */

  26. static int thresh = THRESH;/* acceleration threshhold */


  28. static int mouse_update(int dx,int dy,int dz);

  29. static int IMPS2_Read (int*dx,int*dy,int*dz,int*bp);

  30. static void mouse_setposition (int newx,int newy);

  31. static void mouse_setrange (int newminx,int newminy,int newmaxx,int newmaxy);


  33. int mouse_fd;


  35. int main(void)

  36. {

  37. int dx, dy, dz;

  38. static unsigned char imps2_param []={243, 200, 243, 100, 243, 80};//,242};

  39. // 来自vnc4的xc/programs/Xserver/hw/xfree86/input/mouse/mouse.c==>PROT_IMPS2

  40. const char *mdev ="/dev/input/mice";


  42. mouse_fd = open (mdev, O_RDWR);//| O_NONBLOCK);

  43. if(mouse_fd < 0)

  44. {

  45. printf("[luther.gliethttp]: RW error [please use root user]: %s\n", mdev);

  46. mouse_fd = open (mdev, O_RDONLY);//| O_NONBLOCK);

  47. if(mouse_fd < 0)

  48. return -1;

  49. }

  50. else

  51. {

  52. write (mouse_fd, imps2_param, sizeof (imps2_param));// 初始化序列, 这样可以读取4个字节数据

  53. // 0x80用来表示滚轮向上还是向下滚动

  54. // 0xa0表示滚轮向上滚动的同时中键按下

  55. printf("[luther.gliethttp]: imps2_param ok!\n");

  56. }


  58. mouse_setrange(0, 0, 1024, 768);


  60. for(;;)

  61. {

  62. IMPS2_Read(&dx,&dy,&dz,&buttons);

  63. mouse_update(dx, dy, dz);

  64. mouse_setposition(xpos, ypos);

  65. printf("[%04d,%04d,0x%04x]\n", xpos, ypos, buttons);

  66. }


  68. return 0;

  69. }


  71. static int IMPS2_Read (int*dx,int*dy,int*dz,int*bp)

  72. {

  73. static unsigned char buf[5];

  74. static int buttons[7]={ 0, 1, 3, 0, 2, 0, 0};// 1左键,2中键,3右键

  75. static int nbytes;

  76. int n;


  78. while((n = read (mouse_fd,&buf [nbytes], 4 - nbytes)))

  79. {

  80. if(n < 0)

  81. {

  82. if(errno == EINTR)

  83. continue;

  84. else

  85. return -1;

  86. }


  88. nbytes += n;


  90. if(nbytes == 4)

  91. {

  92. int wheel;

  93. // printf("[luther.gliethttp]: %02x %02x %02x %02x\n", buf[0], buf[1], buf[2], buf[3]);

  94. if((buf[0]& 0xc0)!= 0)

  95. {

  96. buf[0]= buf[1];

  97. buf[1]= buf[2];

  98. buf[2]= buf[3];

  99. nbytes = 3;

  100. return -1;

  101. }


  103. /*FORM XFree86 4.0.1 */

  104. *bp = buttons[(buf[0]& 0x07)];

  105. *dx =(buf[0]& 0x10)? buf[1]- 256 : buf[1];

  106. *dy =(buf[0]& 0x20)?-(buf[2]- 256):-buf[2];


  108. /*Is a wheel event?*/

  109. if((wheel = buf[3])!= 0)

  110. {

  111. if(wheel > 0x7f)

  112. {

  113. *bp |= WHEEL_UP;

  114. }

  115. else

  116. {

  117. *bp |= WHEEL_DOWN;

  118. }

  119. }


  121. *dz = 0;

  122. nbytes = 0;

  123. return 1;

  124. }

  125. }

  126. return 0;

  127. }


  129. static int mouse_update(int dx,int dy,int dz)

  130. {

  131. int r;

  132. int sign;


  134. sign = 1;

  135. if(dx < 0)

  136. {

  137. sign =-1;

  138. dx =-dx;

  139. }

  140. if(dx > thresh)

  141. dx = thresh +(dx - thresh)* scale;

  142. dx *= sign;

  143. xpos += dx;

  144. if( xpos < minx )

  145. xpos = minx;

  146. if( xpos > maxx )

  147. xpos = maxx;


  149. sign = 1;

  150. if(dy < 0)

  151. {

  152. sign =-1;

  153. dy =-dy;

  154. }

  155. if(dy > thresh)

  156. dy = thresh +(dy - thresh)* scale;

  157. dy *= sign;

  158. ypos += dy;

  159. if( ypos < miny )

  160. ypos = miny;

  161. if( ypos > maxy )

  162. ypos = maxy;


  164. return 1;

  165. }


  167. static void mouse_setposition (int newx,int newy)

  168. {

  169. if(newx < minx)

  170. newx = minx;

  171. if(newx > maxx)

  172. newx = maxx;

  173. if(newy < miny)

  174. newy = miny;

  175. if(newy > maxy)

  176. newy = maxy;

  177. if(newx == xpos && newy == ypos)

  178. return;

  179. xpos = newx;

  180. ypos = newy;

  181. }


  183. static void mouse_setrange (int newminx,int newminy,int newmaxx,int newmaxy)

  184. {

  185. minx = newminx;

  186. miny = newminy;

  187. maxx = newmaxx;

  188. maxy = newmaxy;

  189. mouse_setposition ((newminx + newmaxx)/ 2,(newminy + newmaxy)/ 2);

  190. }


  192. static int mouse_getbutton (void)

  193. {

  194. return buttons;

  195. }


  197. static void mouse_getxy (int* x,int* y)

  198. {

  199. *x = xpos;

  200. *y = ypos;

  201. }