Chinaunix首页 | 论坛 | 博客

Gpepperqinglajiao.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

qinglajiao

  • 博客访问： 688327
  • 博文数量： 207
  • 博客积分： 1743
  • 博客等级： 上尉
  • 技术积分： 2044
  • 用 户 组： 普通用户
  • 注册时间： 2012-08-20 14:36
文章分类

全部博文（207）

文章存档

2016年（24）

2015年（10）

2014年（50）

2013年（45）

2012年（78）

我的朋友
最近访客
推荐博文
相关博文
driver: linux下如何模拟按键输入和模拟鼠标

分类： LINUX

2014-07-03 16:14:37

原文地址：driver: linux下如何模拟按键输入和模拟鼠标 作者：wangchenxicool

概述：
查看/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的正数值和负数值分别代表两个不同方向的值.

/*
* Event types
*/
#define EV_SYN 0x00
#define EV_KEY 0x01 //按键
#define EV_REL 0x02 //相对坐标(轨迹球)
#define EV_ABS 0x03 //绝对坐标
#define EV_MSC 0x04 //其他
#define EV_SW 0x05
#define EV_LED 0x11 //LED
#define EV_SND 0x12//声音
#define EV_REP 0x14//repeat
#define EV_FF 0x15
#define EV_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则为上移
  8.     
  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. }

 

阅读(966) | 评论(0) | 转发(0) |
0

上一篇：NET_IP_ALIGN 作用 usbnet异常分体

下一篇：Pseudo-tty drivers -- ptm and pts

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6