source: trunk/src/gui/embedded/qmousepc_qws.cpp@ 890

Last change on this file since 890 was 846, checked in by Dmitry A. Kuminov, 15 years ago

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
  • Property svn:eol-style set to native
File size: 21.6 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4** All rights reserved.
5** Contact: Nokia Corporation ([email protected])
6**
7** This file is part of the QtGui module of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
15**
16** GNU Lesser General Public License Usage
17** Alternatively, this file may be used under the terms of the GNU Lesser
18** General Public License version 2.1 as published by the Free Software
19** Foundation and appearing in the file LICENSE.LGPL included in the
20** packaging of this file. Please review the following information to
21** ensure the GNU Lesser General Public License version 2.1 requirements
22** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23**
24** In addition, as a special exception, Nokia gives you certain additional
25** rights. These rights are described in the Nokia Qt LGPL Exception
26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at [email protected].
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include "qmousepc_qws.h"
43
44#ifndef QT_NO_QWS_MOUSE_PC
45
46#include "qwindowsystem_qws.h"
47#include "qsocketnotifier.h"
48#include "qwsevent_qws.h"
49#include "qwscommand_qws_p.h"
50#include "qwsutils_qws.h"
51
52#include "qapplication.h"
53#include "qpolygon.h"
54#include "qtimer.h"
55#include "qfile.h"
56#include "qtextstream.h"
57#include "qstringlist.h"
58#include <private/qcore_unix_p.h> // overrides QT_OPEN
59
60#include <unistd.h>
61#include <stdlib.h>
62#include <stdio.h>
63#include <sys/ioctl.h>
64#include <sys/types.h>
65#include <sys/stat.h>
66#include <fcntl.h>
67#include <errno.h>
68#include <termios.h>
69
70#include <qscreen_qws.h>
71
72QT_BEGIN_NAMESPACE
73
74//#define QWS_MOUSE_DEBUG
75
76/*
77 * Automatic-detection mouse driver
78 */
79
80class QWSPcMouseSubHandler {
81protected:
82 enum { max_buf=32 };
83
84 int fd;
85
86 uchar buffer[max_buf];
87 int nbuf;
88
89 QPoint motion;
90 int bstate;
91 int wheel;
92
93 int goodness;
94 int badness;
95
96 virtual int tryData()=0;
97
98public:
99 QWSPcMouseSubHandler(int f) : fd(f)
100 {
101 initState();
102 }
103 virtual ~QWSPcMouseSubHandler() {}
104
105 int file() const { return fd; }
106
107 void closeIfNot(int& f)
108 {
109 if (fd != f) {
110 f = fd;
111 QT_CLOSE(fd);
112 }
113 }
114
115 void initState() { nbuf = bstate = goodness = badness = 0; }
116
117 void worse(int by=1) { badness+=by; }
118 bool reliable() const { return goodness >= 5 && badness < 50; }
119 int buttonState() const { return bstate; }
120 bool motionPending() const { return motion!=QPoint(0,0); }
121 QPoint takeMotion() { QPoint r=motion; motion=QPoint(0,0); return r; }
122 int takeWheel() { int result = wheel; wheel = 0; return result; }
123
124 void appendData(uchar* data, int length)
125 {
126 memcpy(buffer+nbuf, data, length);
127 nbuf += length;
128 }
129
130 enum UsageResult { Insufficient, Motion, Button };
131
132 UsageResult useData()
133 {
134 int pbstate = bstate;
135 int n = tryData();
136#ifdef QWS_MOUSE_DEBUG
137 if (n) {
138 fprintf(stderr, "QWSPcMouseSubHandler tryData read %d bytes:", n);
139 for (int i=0; i<n; ++i)
140 fprintf(stderr, " %02x", buffer[i]);
141 fprintf(stderr, "\n");
142 }
143#endif
144 if (n > 0) {
145 if (n<nbuf)
146 memmove(buffer, buffer+n, nbuf-n);
147 nbuf -= n;
148 return (wheel || pbstate != bstate) ? Button : Motion;
149 }
150 return Insufficient;
151 }
152};
153
154class QWSPcMouseSubHandler_intellimouse : public QWSPcMouseSubHandler {
155 int packetsize;
156public:
157 QWSPcMouseSubHandler_intellimouse(int f) : QWSPcMouseSubHandler(f)
158 {
159 init();
160 }
161
162 void init()
163 {
164 int n;
165 uchar reply[20];
166
167 if (tcflush(fd,TCIOFLUSH) == -1) {
168#ifdef QWS_MOUSE_DEBUG
169 perror("QWSPcMouseSubHandler_intellimouse: pre-init tcflush");
170#endif
171 }
172 static const uchar initseq[] = { 243, 200, 243, 100, 243, 80 };
173 static const uchar query[] = { 0xf2 };
174 if (QT_WRITE(fd, initseq, sizeof(initseq))!=sizeof(initseq)) {
175 badness = 100;
176 return;
177 }
178 usleep(10000);
179 if (tcflush(fd,TCIOFLUSH) == -1) {
180#ifdef QWS_MOUSE_DEBUG
181 perror("QWSPcMouseSubHandler_intellimouse: post-init tcflush");
182#endif
183 }
184 if (QT_WRITE(fd, query, sizeof(query))!=sizeof(query)) {
185 badness = 100;
186 return;
187 }
188 usleep(10000);
189 n = QT_READ(fd, reply, 20);
190 if (n > 0) {
191 goodness = 10;
192 switch (reply[n-1]) {
193 case 3:
194 case 4:
195 packetsize = 4;
196 break;
197 default:
198 packetsize = 3;
199 }
200 } else {
201 badness = 100;
202 }
203 }
204
205 int tryData()
206 {
207 if (nbuf >= packetsize) {
208 //int overflow = (buffer[0]>>6)& 0x03;
209
210 if (/*overflow ||*/ !(buffer[0] & 8)) {
211#ifdef QWS_MOUSE_DEBUG
212 qDebug("Intellimouse: skipping (overflow)");
213#endif
214 badness++;
215 return 1;
216 } else {
217 QPoint delta((buffer[0] & 0x10) ? buffer[1]-256 : buffer[1],
218 (buffer[0] & 0x20) ? 256-buffer[2] : -buffer[2]);
219 motion += delta;
220 int nbstate = buffer[0] & 0x7;
221#ifdef QWS_MOUSE_DEBUG
222 int debugwheel =
223#endif
224 wheel = packetsize > 3 ? -(signed char)buffer[3] : 0;
225 if (wheel < -2 || wheel > 2)
226 wheel = 0;
227 wheel *= 120; // WHEEL_DELTA?
228#ifdef QWS_MOUSE_DEBUG
229 qDebug("Intellimouse: motion %d,%d, state %d, raw wheel %d, wheel %d", motion.x(), motion.y(), nbstate, debugwheel, wheel);
230#endif
231 if (motion.x() || motion.y() || bstate != nbstate || wheel) {
232 bstate = nbstate;
233 goodness++;
234 } else {
235 badness++;
236 return 1;
237 }
238 }
239 return packetsize;
240 }
241 return 0;
242 }
243};
244
245class QWSPcMouseSubHandler_mouseman : public QWSPcMouseSubHandler {
246 int packetsize;
247public:
248 QWSPcMouseSubHandler_mouseman(int f) : QWSPcMouseSubHandler(f)
249 {
250 init();
251 }
252
253 void init()
254 {
255 if (tcflush(fd,TCIOFLUSH) == -1) {
256#ifdef QWS_MOUSE_DEBUG
257 perror("QWSPcMouseSubHandler_mouseman: initial tcflush");
258#endif
259 }
260 QT_WRITE(fd,"",1);
261 usleep(50000);
262 QT_WRITE(fd,"@EeI!",5);
263 usleep(10000);
264 static const char ibuf[] = { 246, 244 };
265 QT_WRITE(fd,ibuf,1);
266 QT_WRITE(fd,ibuf+1,1);
267 if (tcflush(fd,TCIOFLUSH) == -1) {
268#ifdef QWS_MOUSE_DEBUG
269 perror("QWSPcMouseSubHandler_mouseman: tcflush");
270#endif
271 }
272 usleep(10000);
273
274 char buf[100];
275 while (QT_READ(fd, buf, 100) > 0) { } // eat unwanted replies
276 }
277
278 int tryData()
279 {
280 if (nbuf >= 3) {
281 int nbstate = 0;
282 if (buffer[0] & 0x01)
283 nbstate |= Qt::LeftButton;
284 if (buffer[0] & 0x02)
285 nbstate |= Qt::RightButton;
286 if (buffer[0] & 0x04)
287 nbstate |= Qt::MidButton;
288
289 int overflow = (buffer[0]>>6)& 0x03;
290 if (overflow) {
291 //### wheel events signalled with overflow bit, ignore for now
292 badness++;
293 return 1;
294 } else {
295 bool xs = buffer[0] & 0x10;
296 bool ys = buffer[0] & 0x20;
297 int dx = xs ? buffer[1]-256 : buffer[1];
298 int dy = ys ? buffer[2]-256 : buffer[2];
299
300 motion += QPoint(dx, -dy);
301 if (motion.x() || motion.y() || bstate != nbstate) {
302 bstate = nbstate;
303 goodness++;
304 } else {
305 badness++;
306 return 1;
307 }
308 }
309 return 3;
310 }
311 return 0;
312 }
313};
314
315class QWSPcMouseSubHandler_serial : public QWSPcMouseSubHandler {
316public:
317 QWSPcMouseSubHandler_serial(int f) : QWSPcMouseSubHandler(f)
318 {
319 initSerial();
320 }
321
322protected:
323 void setflags(int f)
324 {
325 termios tty;
326 if (tcgetattr(fd, &tty) == -1) {
327#ifdef QWS_MOUSE_DEBUG
328 perror("QWSPcMouseSubHandler_serial: tcgetattr");
329#endif
330 }
331 tty.c_iflag = IGNBRK | IGNPAR;
332 tty.c_oflag = 0;
333 tty.c_lflag = 0;
334 tty.c_cflag = f | CREAD | CLOCAL | HUPCL;
335#ifdef Q_OS_LINUX
336 tty.c_line = 0;
337#endif
338 tty.c_cc[VTIME] = 0;
339 tty.c_cc[VMIN] = 1;
340 if (tcsetattr(fd, TCSANOW, &tty) == -1) {
341#ifdef QWS_MOUSE_DEBUG
342 perror("QWSPcMouseSubHandler_serial: tcgetattr");
343#endif
344 }
345 }
346
347private:
348 void initSerial()
349 {
350 int speed[4] = { B9600, B4800, B2400, B1200 };
351
352 for (int n = 0; n < 4; n++) {
353 setflags(CSTOPB | speed[n]);
354 QT_WRITE(fd, "*q", 2);
355 usleep(10000);
356 }
357 }
358};
359
360class QWSPcMouseSubHandler_mousesystems : public QWSPcMouseSubHandler_serial {
361public:
362 // ##### This driver has not been tested
363
364 QWSPcMouseSubHandler_mousesystems(int f) : QWSPcMouseSubHandler_serial(f)
365 {
366 init();
367 }
368
369 void init()
370 {
371 setflags(B1200|CS8|CSTOPB);
372 // 60Hz
373 if (QT_WRITE(fd, "R", 1)!=1) {
374 badness = 100;
375 return;
376 }
377 if (tcflush(fd,TCIOFLUSH) == -1) {
378#ifdef QT_QWS_VNC_DEBUG
379 perror("QWSPcMouseSubHandler_mousesystems: tcflush");
380#endif
381 }
382 }
383
384 int tryData()
385 {
386 if (nbuf >= 5) {
387 if ((buffer[0] & 0xf8) != 0x80) {
388 badness++;
389 return 1;
390 }
391 motion +=
392 QPoint((signed char)buffer[1] + (signed char)buffer[3],
393 -(signed char)buffer[2] + (signed char)buffer[4]);
394 int t = ~buffer[0];
395 int nbstate = ((t&3) << 1) | ((t&4) >> 2);
396 if (motion.x() || motion.y() || bstate != nbstate) {
397 bstate = nbstate;
398 goodness++;
399 } else {
400 badness++;
401 return 1;
402 }
403 return 5;
404 }
405 return 0;
406 }
407};
408
409class QWSPcMouseSubHandler_ms : public QWSPcMouseSubHandler_serial {
410 int mman;
411public:
412 QWSPcMouseSubHandler_ms(int f) : QWSPcMouseSubHandler_serial(f)
413 {
414 mman=0;
415 init();
416 }
417
418 void init()
419 {
420 setflags(B1200|CS7);
421 // 60Hz
422 if (QT_WRITE(fd, "R", 1)!=1) {
423 badness = 100;
424 return;
425 }
426 if (tcflush(fd,TCIOFLUSH) == -1) {
427#ifdef QWS_MOUSE_DEBUG
428 perror("QWSPcMouseSubHandler_ms: tcflush");
429#endif
430 }
431 }
432
433 int tryData()
434 {
435 if (!(buffer[0] & 0x40)) {
436 if (buffer[0] == 0x20 && (bstate & Qt::MidButton)) {
437 mman=1; // mouseman extension
438 }
439 return 1;
440 }
441 int extra = mman&&(bstate & Qt::MidButton);
442 if (nbuf >= 3+extra) {
443 int nbstate = 0;
444 if (buffer[0] == 0x40 && !bstate && !buffer[1] && !buffer[2]) {
445 nbstate = Qt::MidButton;
446 } else {
447 nbstate = ((buffer[0] & 0x20) >> 5)
448 | ((buffer[0] & 0x10) >> 3);
449 if (extra && buffer[3] == 0x20)
450 nbstate = Qt::MidButton;
451 }
452
453 if (buffer[1] & 0x40) {
454 badness++;
455 return 1;
456 } else {
457 motion +=
458 QPoint((signed char)((buffer[0]&0x3)<<6)
459 |(signed char)(buffer[1]&0x3f),
460 (signed char)((buffer[0]&0xc)<<4)
461 |(signed char)(buffer[2]&0x3f));
462 if (motion.x() || motion.y() || bstate != nbstate) {
463 bstate = nbstate;
464 goodness++;
465 } else {
466 badness++;
467 return 1;
468 }
469 return 3+extra;
470 }
471 }
472 return 0;
473 }
474};
475
476//===========================================================================
477
478class QWSPcMouseHandlerPrivate : public QObject
479{
480 Q_OBJECT
481public:
482 QWSPcMouseHandlerPrivate(QWSPcMouseHandler *h, const QString &, const QString &);
483 ~QWSPcMouseHandlerPrivate();
484
485 void suspend();
486 void resume();
487
488private:
489 enum { max_dev=32 };
490 QWSPcMouseSubHandler *sub[max_dev];
491 QList<QSocketNotifier*> notifiers;
492 int nsub;
493 int retries;
494
495private slots:
496 void readMouseData(int);
497
498private:
499 void openDevices();
500 void closeDevices();
501 void notify(int fd);
502 bool sendEvent(QWSPcMouseSubHandler& h);
503
504private:
505 QWSPcMouseHandler *handler;
506 QString driver;
507 QString device;
508 qreal accel;
509 int accel_limit;
510};
511
512QWSPcMouseHandler::QWSPcMouseHandler(const QString &driver, const QString &device)
513 : QWSMouseHandler(driver, device)
514{
515 d = new QWSPcMouseHandlerPrivate(this, driver, device);
516}
517
518QWSPcMouseHandler::~QWSPcMouseHandler()
519{
520 delete d;
521}
522
523void QWSPcMouseHandler::suspend()
524{
525 d->suspend();
526}
527
528void QWSPcMouseHandler::resume()
529{
530 d->resume();
531}
532
533
534QWSPcMouseHandlerPrivate::QWSPcMouseHandlerPrivate(QWSPcMouseHandler *h,
535 const QString &drv, const QString &arg)
536 : handler(h), driver(drv)
537{
538 QStringList args = arg.split(QLatin1Char(':'), QString::SkipEmptyParts);
539
540 int index;
541
542 accel = qreal(2.0);
543 QRegExp accelRegex(QLatin1String("^accel=(\\d+\\.?\\d*)$"));
544 index = args.indexOf(accelRegex);
545 if (index >= 0) {
546 accel = qreal(accelRegex.cap(1).toDouble());
547 args.removeAt(index);
548 }
549
550 accel_limit = 5;
551 QRegExp accelLimitRegex(QLatin1String("^accel_limit=(\\d+)$"));
552 index = args.indexOf(accelLimitRegex);
553 if (index >= 0) {
554 accel_limit = accelLimitRegex.cap(1).toInt();
555 args.removeAt(index);
556 }
557
558 device = args.join(QString());
559
560 retries = 0;
561 openDevices();
562}
563
564QWSPcMouseHandlerPrivate::~QWSPcMouseHandlerPrivate()
565{
566 closeDevices();
567}
568
569/*
570QWSPcMouseHandler::UsageResult QWSPcMouseHandler::useDev(Dev& d)
571{
572 if (d.nbuf >= mouseData[d.protocol].bytesPerPacket) {
573 uchar *mb = d.buf;
574 int bstate = 0;
575 int dx = 0;
576 int dy = 0;
577
578 switch (mouseProtocol) {
579 case MouseMan:
580 case IntelliMouse:
581 {
582 bstate = mb[0] & 0x7; // assuming Qt::*Button order
583
584 int overflow = (mb[0]>>6)& 0x03;
585 if (mouseProtocol == MouseMan && overflow) {
586 //### wheel events signalled with overflow bit, ignore for now
587 }
588 else {
589 bool xs = mb[0] & 0x10;
590 bool ys = mb[0] & 0x20;
591 dx = xs ? mb[1]-256 : mb[1];
592 dy = ys ? mb[2]-256 : mb[2];
593 }
594 break;
595 }
596 case Microsoft:
597 if (((mb[0] & 0x20) >> 3)) {
598 bstate |= Qt::LeftButton;
599 }
600 if (((mb[0] & 0x10) >> 4)) {
601 bstate |= Qt::RightButton;
602 }
603
604 dx=(signed char)(((mb[0] & 0x03) << 6) | (mb[1] & 0x3f));
605 dy=-(signed char)(((mb[0] & 0x0c) << 4) | (mb[2] & 0x3f));
606
607 break;
608 }
609 }
610 }
611*/
612
613
614bool QWSPcMouseHandlerPrivate::sendEvent(QWSPcMouseSubHandler& h)
615{
616 if (h.reliable()) {
617 QPoint motion = h.takeMotion();
618 if (qAbs(motion.x()) > accel_limit || qAbs(motion.y()) > accel_limit)
619 motion *= accel;
620 QPoint newPos = handler->pos() + motion;
621 if (qt_screen->isTransformed()) {
622 QSize s = QSize(qt_screen->width(), qt_screen->height());
623 newPos = qt_screen->mapToDevice(newPos, s);
624 }
625 handler->limitToScreen(newPos);
626
627 handler->mouseChanged(newPos, h.buttonState(), h.takeWheel());
628 return true;
629 } else {
630 h.takeMotion();
631 if (h.buttonState() & (Qt::RightButton|Qt::MidButton)) {
632 // Strange for the user to press right or middle without
633 // a moving mouse!
634 h.worse();
635 }
636 return false;
637 }
638}
639
640void QWSPcMouseHandlerPrivate::openDevices()
641{
642 nsub=0;
643 int fd = -1;
644
645 QString drv = driver.toLower();
646 if (!drv.isEmpty() && drv != QLatin1String("auto")) {
647 // Manually specified mouse
648 QByteArray dev = device.toLatin1();
649 if (drv == QLatin1String("intellimouse")) {
650 if (dev.isEmpty())
651 dev = "/dev/psaux";
652 fd = QT_OPEN(dev, O_RDWR | O_NDELAY);
653 if (fd >= 0)
654 sub[nsub++] = new QWSPcMouseSubHandler_intellimouse(fd);
655 } else if (drv == QLatin1String("microsoft")) {
656 if (dev.isEmpty())
657 dev = "/dev/ttyS0";
658 fd = QT_OPEN(dev, O_RDWR | O_NDELAY);
659 if (fd >= 0)
660 sub[nsub++] = new QWSPcMouseSubHandler_ms(fd);
661 } else if (drv == QLatin1String("mousesystems")) {
662 if (dev.isEmpty())
663 dev = "/dev/ttyS0";
664 fd = QT_OPEN(dev, O_RDWR | O_NDELAY);
665 if (fd >= 0)
666 sub[nsub++] = new QWSPcMouseSubHandler_mousesystems(fd);
667 } else if (drv == QLatin1String("mouseman")) {
668 if (dev.isEmpty())
669 dev = "/dev/psaux";
670 fd = QT_OPEN(dev, O_RDWR | O_NDELAY);
671 if (fd >= 0)
672 sub[nsub++] = new QWSPcMouseSubHandler_mouseman(fd);
673 }
674 if (fd >= 0)
675 notify(fd);
676 else
677 qCritical("Error opening mouse device '%s': %s",
678 dev.constData(), strerror(errno));
679 } else {
680 // Try automatically
681 fd = QT_OPEN("/dev/psaux", O_RDWR | O_NDELAY);
682 if (fd >= 0) {
683 sub[nsub++] = new QWSPcMouseSubHandler_intellimouse(fd);
684 notify(fd);
685 }
686 fd = QT_OPEN("/dev/input/mice", O_RDWR | O_NDELAY);
687 if (fd >= 0) {
688 sub[nsub++] = new QWSPcMouseSubHandler_intellimouse(fd);
689 notify(fd);
690 //qDebug("/dev/input/mice fd %d #%d", fd, nsub-1);
691 }
692
693// include the code below to auto-detect serial mice, and to mess up
694// any sort of serial communication
695#if 0
696 const char fn[4][11] = { "/dev/ttyS0", "/dev/ttyS1", "/dev/ttyS2", "/dev/ttyS3" };
697 for (int ch = 0; ch < 4; ++ch) {
698 fd = QT_OPEN(fn[ch], O_RDWR | O_NDELAY);
699 if (fd >= 0) {
700 //sub[nsub++] = new QWSPcMouseSubHandler_intellimouse(fd);
701 sub[nsub++] = new QWSPcMouseSubHandler_mousesystems(fd);
702 sub[nsub++] = new QWSPcMouseSubHandler_ms(fd);
703 notify(fd);
704 }
705 }
706#endif
707 }
708}
709
710void QWSPcMouseHandlerPrivate::closeDevices()
711{
712 int pfd=-1;
713 for (int i=0; i<nsub; i++) {
714 sub[i]->closeIfNot(pfd);
715 delete sub[i];
716 }
717 qDeleteAll(notifiers);
718 notifiers.clear();
719}
720
721void QWSPcMouseHandlerPrivate::suspend()
722{
723 for (int i=0; i<notifiers.size(); ++i)
724 notifiers.at(i)->setEnabled(false);
725}
726
727void QWSPcMouseHandlerPrivate::resume()
728{
729 for (int i=0; i<nsub; i++)
730 sub[i]->initState();
731
732 for (int i=0; i<notifiers.size(); ++i)
733 notifiers.at(i)->setEnabled(true);
734}
735
736
737
738void QWSPcMouseHandlerPrivate::notify(int fd)
739{
740 QSocketNotifier *mouseNotifier
741 = new QSocketNotifier(fd, QSocketNotifier::Read, this);
742 connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData(int)));
743 notifiers.append(mouseNotifier);
744}
745
746void QWSPcMouseHandlerPrivate::readMouseData(int fd)
747{
748 for (;;) {
749 uchar buf[8];
750 int n = read(fd, buf, 8);
751 if (n<=0)
752 break;
753 for (int i=0; i<nsub; i++) {
754 QWSPcMouseSubHandler& h = *sub[i];
755 if (h.file() == fd) {
756 h.appendData(buf,n);
757 for (;;) {
758 switch (h.useData()) {
759 case QWSPcMouseSubHandler::Button:
760 sendEvent(h);
761 break;
762 case QWSPcMouseSubHandler::Insufficient:
763 goto breakbreak;
764 case QWSPcMouseSubHandler::Motion:
765 break;
766 }
767 }
768 breakbreak:
769 ;
770 }
771 }
772 }
773 bool any_reliable=false;
774 for (int i=0; i<nsub; i++) {
775 QWSPcMouseSubHandler& h = *sub[i];
776 if (h.motionPending())
777 sendEvent(h);
778 any_reliable = any_reliable || h.reliable();
779 }
780 if (any_reliable) {
781 // ... get rid of all unreliable ones? All bad ones?
782 } else if (retries < 2) {
783 // Try again - maybe the mouse was being moved when we tried to init.
784 closeDevices();
785 openDevices();
786 retries++;
787 }
788}
789
790QT_END_NAMESPACE
791
792#include "qmousepc_qws.moc"
793
794#endif // QT_NO_MOUSE_PC
Note: See TracBrowser for help on using the repository browser.