diff options
Diffstat (limited to 'packages/qte/qte-2.3.10/deprecated')
6 files changed, 2752 insertions, 0 deletions
diff --git a/packages/qte/qte-2.3.10/deprecated/.mtn2git_empty b/packages/qte/qte-2.3.10/deprecated/.mtn2git_empty new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/packages/qte/qte-2.3.10/deprecated/.mtn2git_empty diff --git a/packages/qte/qte-2.3.10/deprecated/mnci-touchscreen.patch b/packages/qte/qte-2.3.10/deprecated/mnci-touchscreen.patch new file mode 100644 index 0000000000..570c2ff290 --- /dev/null +++ b/packages/qte/qte-2.3.10/deprecated/mnci-touchscreen.patch @@ -0,0 +1,1987 @@ + +# +# Patch managed by http://www.holgerschurig.de/patcher.html +# + +--- qt-2.3.10/src/kernel/qwsmouse_qws.cpp~ramses-touchscreen ++++ qt-2.3.10/src/kernel/qwsmouse_qws.cpp +@@ -1,5 +1,5 @@ + /**************************************************************************** +-** $Id: qt/src/kernel/qwsmouse_qws.cpp 2.3.10 edited 2005-01-24 $ ++** $Id: qt/src/kernel/qwsmouse_qws.cpp 2.3.7 edited 2003-02-04 $ + ** + ** Implementation of Qt/Embedded mouse drivers + ** +@@ -47,85 +47,32 @@ + #include <stdlib.h> + #include <stdio.h> + #include <sys/ioctl.h> +-#include <sys/time.h> + #include <sys/types.h> + #include <sys/stat.h> + #include <fcntl.h> + #include <errno.h> + #include <termios.h> + ++ + #include <qgfx_qws.h> + #if !defined(_OS_QNX6_) + +-#ifdef QT_QWS_CASSIOPEIA +-#include <linux/tpanel.h> +-#endif +-#ifdef QT_QWS_TSLIB +-#include <tslib.h> +-#endif +- +- +-//#define QT_QWS_K2 +- +-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_K2) +-#define QT_QWS_IPAQ_RAW +-typedef struct { +- unsigned short pressure; +- unsigned short x; +- unsigned short y; +- unsigned short pad; +- struct timeval stamp; +-} TS_EVENT; +-#elif defined(QT_QWS_SL5XXX) +-#define QT_QWS_SL5XXX_RAW +-typedef struct { +- long y; +- long x; +- long pressure; +- long long millisecs; +-} TS_EVENT; +-#define QT_QWS_TP_SAMPLE_SIZE 10 +-#define QT_QWS_TP_MINIMUM_SAMPLES 4 +-#define QT_QWS_TP_PRESSURE_THRESHOLD 500 +-#define QT_QWS_TP_MOVE_LIMIT 50 +-#define QT_QWS_TP_JITTER_LIMIT 2 +-#elif defined(QT_QWS_SLC700) +-#define QT_QWS_SLC700_RAW +-typedef struct { +- unsigned short pressure; +- unsigned short x; +- unsigned short y; +- unsigned short millisecs; +-} TS_EVENT; +-#define QT_QWS_TP_SAMPLE_SIZE 10 +-#define QT_QWS_TP_MINIMUM_SAMPLES 4 +-#define QT_QWS_TP_PRESSURE_THRESHOLD 500 +-#define QT_QWS_TP_MOVE_LIMIT 50 +-#define QT_QWS_TP_JITTER_LIMIT 2 +-#endif +- +-#ifndef QT_QWS_TP_SAMPLE_SIZE +-#define QT_QWS_TP_SAMPLE_SIZE 5 +-#endif +- +-#ifndef QT_QWS_TP_MINIMUM_SAMPLES +-#define QT_QWS_TP_MINIMUM_SAMPLES 5 ++#ifndef QT_QWS_TP_PRESSURE_DOWN_THRESHOLD ++#define QT_QWS_TP_PRESSURE_DOWN_THRESHOLD 500 + #endif + +-#ifndef QT_QWS_TP_PRESSURE_THRESHOLD +-#define QT_QWS_TP_PRESSURE_THRESHOLD 1 ++#ifndef QT_QWS_TP_PRESSURE_UP_THRESHOLD ++#define QT_QWS_TP_PRESSURE_UP_THRESHOLD 450 + #endif + +-#ifndef QT_QWS_TP_MOVE_LIMIT +-#define QT_QWS_TP_MOVE_LIMIT 100 ++#ifndef QT_QWS_TP_TABLE_SIZE ++#define QT_QWS_TP_TABLE_SIZE 2 + #endif + +-#ifndef QT_QWS_TP_JITTER_LIMIT +-#define QT_QWS_TP_JITTER_LIMIT 2 ++#ifndef QT_QWS_TP_MOVE_MAX ++#define QT_QWS_TP_MOVE_MAX 100 + #endif + +-//#define QWS_CUSTOMTOUCHPANEL +- + /*! + \class QWSMouseHandler qwsmouse_qws.h + \brief Mouse driver/handler for Qt/Embedded +@@ -168,8 +115,7 @@ + enum MouseProtocol { Unknown = -1, Auto = 0, + MouseMan, IntelliMouse, Microsoft, + QVFBMouse, TPanel, BusMouse, +- FirstAuto = MouseMan, +- LastAuto = Microsoft }; ++ }; + + static void limitToScreen( QPoint &pt ) + { +@@ -186,810 +132,14 @@ + } MouseConfig; + + static const MouseConfig mouseConfig[] = { +-#ifndef QT_NO_QWS_MOUSE_AUTO + { "Auto", Auto }, +-#endif +-#ifndef QT_NO_QWS_MOUSE_PC +- { "MouseMan", MouseMan }, +- { "IntelliMouse", IntelliMouse }, +- { "USB", IntelliMouse }, +- { "Microsoft", Microsoft }, +-#endif +-#ifndef QT_NO_QWS_VFB + { "QVFbMouse", QVFBMouse }, +-#endif + { "TPanel", TPanel }, +- { "BusMouse", BusMouse }, + { 0, Unknown } + }; + +-#ifndef QT_NO_QWS_MOUSE_AUTO +-/* +- * Automatic-detection mouse driver +- */ +- +-class QAutoMouseSubHandler { +-protected: +- enum { max_buf=32 }; +- +- int fd; +- +- uchar buffer[max_buf]; +- int nbuf; +- +- QPoint motion; +- int bstate; +- +- int goodness; +- int badness; +- +- virtual int tryData()=0; +- +-public: +- QAutoMouseSubHandler(int f) : fd(f) +- { +- nbuf = bstate = goodness = badness = 0; +- } +- +- int file() const { return fd; } +- +- void closeIfNot(int& f) +- { +- if ( fd != f ) { +- f = fd; +- close(fd); +- } +- } +- +- void worse(int by=1) { badness+=by; } +- bool reliable() const { return goodness >= 5 && badness < 50; } +- int buttonState() const { return bstate; } +- bool motionPending() const { return motion!=QPoint(0,0); } +- QPoint takeMotion() { QPoint r=motion; motion=QPoint(0,0); return r; } +- +- void appendData(uchar* data, int length) +- { +- memcpy(buffer+nbuf, data, length); +- nbuf += length; +- } +- +- enum UsageResult { Insufficient, Motion, Button }; +- +- UsageResult useData() +- { +- int pbstate = bstate; +- int n = tryData(); +- if ( n > 0 ) { +- if ( n<nbuf ) +- memmove( buffer, buffer+n, nbuf-n ); +- nbuf -= n; +- return pbstate == bstate ? Motion : Button; +- } +- return Insufficient; +- } +-}; +- +-class QAutoMouseSubHandler_intellimouse : public QAutoMouseSubHandler { +- int packetsize; +-public: +- QAutoMouseSubHandler_intellimouse(int f) : QAutoMouseSubHandler(f) +- { +- init(); +- } +- +- void init() +- { +- int n; +- uchar reply[20]; +- +- tcflush(fd,TCIOFLUSH); +- static const uchar initseq[] = { 243, 200, 243, 100, 243, 80 }; +- static const uchar query[] = { 0xf2 }; +- if (write(fd, initseq, sizeof(initseq))!=sizeof(initseq)) { +- badness = 100; +- return; +- } +- usleep(10000); +- tcflush(fd,TCIOFLUSH); +- if (write(fd, query, sizeof(query))!=sizeof(query)) { +- badness = 100; +- return; +- } +- usleep(10000); +- n = read(fd, reply, 20); +- if ( n > 0 ) { +- goodness = 10; +- switch ( reply[n-1] ) { +- case 3: +- case 4: +- packetsize = 4; +- break; +- default: +- packetsize = 3; +- } +- } else { +- badness = 100; +- } +- } +- +- int tryData() +- { +- if ( nbuf >= packetsize ) { +- //int overflow = (buffer[0]>>6 )& 0x03; +- +- if ( /*overflow ||*/ !(buffer[0] & 8) ) { +- badness++; +- return 1; +- } else { +- motion += +- QPoint((buffer[0] & 0x10) ? buffer[1]-256 : buffer[1], +- (buffer[0] & 0x20) ? 256-buffer[2] : -buffer[2]); +- int nbstate = buffer[0] & 0x7; +- if ( motion.x() || motion.y() || bstate != nbstate ) { +- bstate = nbstate; +- goodness++; +- } else { +- badness++; +- return 1; +- } +- } +- return packetsize; +- } +- return 0; +- } +-}; +- +-class QAutoMouseSubHandler_serial : public QAutoMouseSubHandler { +-public: +- QAutoMouseSubHandler_serial(int f) : QAutoMouseSubHandler(f) +- { +- initSerial(); +- } +- +-protected: +- void setflags(int f) +- { +- termios tty; +- tcgetattr(fd, &tty); +- tty.c_iflag = IGNBRK | IGNPAR; +- tty.c_oflag = 0; +- tty.c_lflag = 0; +- tty.c_cflag = f | CREAD | CLOCAL | HUPCL; +-#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) +- tty.c_line = 0; +-#endif +- tty.c_cc[VTIME] = 0; +- tty.c_cc[VMIN] = 1; +- tcsetattr(fd, TCSANOW, &tty); +- } +- +-private: +- void initSerial() +- { +- int speed[4] = { B9600, B4800, B2400, B1200 }; +- +- for (int n = 0; n < 4; n++) { +- setflags(CSTOPB | speed[n]); +- write(fd, "*q", 2); +- usleep(10000); +- } +- } +-}; +- +-class QAutoMouseSubHandler_mousesystems : public QAutoMouseSubHandler_serial { +-public: +- // ##### This driver has not been tested +- +- QAutoMouseSubHandler_mousesystems(int f) : QAutoMouseSubHandler_serial(f) +- { +- init(); +- } +- +- void init() +- { +- setflags(B1200|CS8|CSTOPB); +- // 60Hz +- if (write(fd, "R", 1)!=1) { +- badness = 100; +- return; +- } +- tcflush(fd,TCIOFLUSH); +- } +- +- int tryData() +- { +- if ( nbuf >= 5 ) { +- if ( (buffer[0] & 0xf8) != 0x80 ) { +- badness++; +- return 1; +- } +- motion += +- QPoint((signed char)buffer[1] + (signed char)buffer[3], +- -(signed char)buffer[2] + (signed char)buffer[4]); +- int t = ~buffer[0]; +- int nbstate = ((t&3) << 1) | ((t&4) >> 2); +- if ( motion.x() || motion.y() || bstate != nbstate ) { +- bstate = nbstate; +- goodness++; +- } else { +- badness++; +- return 1; +- } +- return 5; +- } +- return 0; +- } +-}; +- +-class QAutoMouseSubHandler_ms : public QAutoMouseSubHandler_serial { +- int mman; +-public: +- QAutoMouseSubHandler_ms(int f) : QAutoMouseSubHandler_serial(f) +- { +- mman=0; +- init(); +- } +- +- void init() +- { +- setflags(B1200|CS7); +- // 60Hz +- if (write(fd, "R", 1)!=1) { +- badness = 100; +- return; +- } +- tcflush(fd,TCIOFLUSH); +- } +- +- int tryData() +- { +- if ( !(buffer[0] & 0x40) ) { +- if ( buffer[0] == 0x20 && (bstate & Qt::MidButton) ) { +- mman=1; // mouseman extension +- } +- return 1; +- } +- int extra = mman&&(bstate & Qt::MidButton); +- if ( nbuf >= 3+extra ) { +- int nbstate = 0; +- if ( buffer[0] == 0x40 && !bstate && !buffer[1] && !buffer[2] ) { +- nbstate = Qt::MidButton; +- } else { +- nbstate = ((buffer[0] & 0x20) >> 5) +- | ((buffer[0] & 0x10) >> 3); +- if ( extra && buffer[3] == 0x20 ) +- nbstate = Qt::MidButton; +- } +- +- if ( buffer[1] & 0x40 ) { +- badness++; +- return 1; +- } else { +- motion += +- QPoint((signed char)((buffer[0]&0x3)<<6) +- |(signed char)(buffer[1]&0x3f), +- (signed char)((buffer[0]&0xc)<<4) +- |(signed char)(buffer[2]&0x3f)); +- if ( motion.x() || motion.y() || bstate != nbstate ) { +- bstate = nbstate; +- goodness++; +- } else { +- badness++; +- return 1; +- } +- return 3+extra; +- } +- } +- return 0; +- } +-}; +- +-/* +-QAutoMouseHandler::UsageResult QAutoMouseHandler::useDev(Dev& d) +-{ +- if ( d.nbuf >= mouseData[d.protocol].bytesPerPacket ) { +- uchar *mb = d.buf; +- int bstate = 0; +- int dx = 0; +- int dy = 0; +- +- switch (mouseProtocol) { +- case MouseMan: +- case IntelliMouse: +- { +- bstate = mb[0] & 0x7; // assuming Qt::*Button order +- +- int overflow = (mb[0]>>6 )& 0x03; +- if (mouseProtocol == MouseMan && overflow) { +- //### wheel events signalled with overflow bit, ignore for now +- } +- else { +- bool xs = mb[0] & 0x10; +- bool ys = mb[0] & 0x20; +- dx = xs ? mb[1]-256 : mb[1]; +- dy = ys ? mb[2]-256 : mb[2]; +- } +- break; +- } +- case Microsoft: +- if ( ((mb[0] & 0x20) >> 3) ) { +- bstate |= Qt::LeftButton; +- } +- if ( ((mb[0] & 0x10) >> 4) ) { +- bstate |= Qt::RightButton; +- } +- +- dx=(signed char)(((mb[0] & 0x03) << 6) | (mb[1] & 0x3f)); +- dy=-(signed char)(((mb[0] & 0x0c) << 4) | (mb[2] & 0x3f)); +- +- break; +- } +- } +- } +-*/ +- +-#endif +- +-class QAutoMouseHandler : public QWSMouseHandler { +- Q_OBJECT +- +-public: +- QAutoMouseHandler(); +- ~QAutoMouseHandler(); +- +-#ifndef QT_NO_QWS_MOUSE_AUTO +-private: +- enum { max_dev=32 }; +- QAutoMouseSubHandler *sub[max_dev]; +- QList<QSocketNotifier> notifiers; +- int nsub; +- int retries; +-#endif +- +-private slots: +- void readMouseData(int); +- +-private: +-#ifndef QT_NO_QWS_MOUSE_AUTO +- void openDevices(); +- void closeDevices(); +- void notify(int fd); +- bool sendEvent(QAutoMouseSubHandler& h) +- { +- if ( h.reliable() ) { +- mousePos += h.takeMotion(); +- limitToScreen( mousePos ); +-/* +-qDebug("%d,%d %c%c%c", +-mousePos.x(),mousePos.y(), +-(h.buttonState()&Qt::LeftButton)?'L':'.', +-(h.buttonState()&Qt::MidButton)?'M':'.', +-(h.buttonState()&Qt::RightButton)?'R':'.'); +-*/ +- emit mouseChanged(mousePos,h.buttonState()); +- return TRUE; +- } else { +- h.takeMotion(); +- if ( h.buttonState() & (Qt::RightButton|Qt::MidButton) ) { +- // Strange for the user to press right or middle without +- // a moving mouse! +- h.worse(); +- } +- return FALSE; +- } +- } +-#endif +-}; +- +-QAutoMouseHandler::QAutoMouseHandler() +-{ +-#ifndef QT_NO_QWS_MOUSE_AUTO +- notifiers.setAutoDelete( TRUE ); +- retries = 0; +- openDevices(); +-#endif +-} +- +-QAutoMouseHandler::~QAutoMouseHandler() +-{ +-#ifndef QT_NO_QWS_MOUSE_AUTO +- closeDevices(); +-#endif +-} +- +-#ifndef QT_NO_QWS_MOUSE_AUTO +-void QAutoMouseHandler::openDevices() +-{ +- nsub=0; +- int fd; +- fd = open( "/dev/psaux", O_RDWR | O_NDELAY ); +- if ( fd >= 0 ) { +- sub[nsub++] = new QAutoMouseSubHandler_intellimouse(fd); +- notify(fd); +- } +-#if !defined(QT_QWS_IPAQ) && !defined(QT_QWS_SL5XXX) && !defined(QT_QWS_K2) && !defined(QT_QWS_SLC700) +- char fn[] = "/dev/ttyS?"; +- for (int ch='0'; ch<='3'; ch++) { +- fn[9] = ch; +- fd = open( fn, O_RDWR | O_NDELAY ); +- if ( fd >= 0 ) { +- //sub[nsub++] = new QAutoMouseSubHandler_intellimouse(fd); +- sub[nsub++] = new QAutoMouseSubHandler_mousesystems(fd); +- sub[nsub++] = new QAutoMouseSubHandler_ms(fd); +- notify(fd); +- } +- } +-#endif +- // ... +-} +- +-void QAutoMouseHandler::closeDevices() +-{ +- int pfd=-1; +- for (int i=0; i<nsub; i++) { +- sub[i]->closeIfNot(pfd); +- delete sub[i]; +- } +- notifiers.clear(); +-} +- +-void QAutoMouseHandler::notify(int fd) +-{ +- QSocketNotifier *mouseNotifier +- = new QSocketNotifier( fd, QSocketNotifier::Read, this ); +- connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData(int))); +- notifiers.append( mouseNotifier ); +-} +-#endif +- +-void QAutoMouseHandler::readMouseData(int fd) +-{ +-#ifndef QT_NO_QWS_MOUSE_AUTO +- for (;;) { +- uchar buf[8]; +- int n = read(fd, buf, 8); +- if ( n<=0 ) +- break; +- for (int i=0; i<nsub; i++) { +- QAutoMouseSubHandler& h = *sub[i]; +- if ( h.file() == fd ) { +- h.appendData(buf,n); +- for (;;) { +- switch ( h.useData() ) { +- case QAutoMouseSubHandler::Button: +- sendEvent(h); +- break; +- case QAutoMouseSubHandler::Insufficient: +- goto breakbreak; +- case QAutoMouseSubHandler::Motion: +- break; +- } +- } +- breakbreak: +- ; +- } +- } +- } +- bool any_reliable=FALSE; +- for (int i=0; i<nsub; i++) { +- QAutoMouseSubHandler& h = *sub[i]; +- if ( h.motionPending() ) +- sendEvent(h); +- any_reliable = any_reliable || h.reliable(); +- } +- if ( any_reliable ) { +- // ... get rid of all unreliable ones? All bad ones? +- } else if ( retries < 2 ) { +- // Try again - maybe the mouse was being moved when we tried to init. +- closeDevices(); +- openDevices(); +- retries++; +- } +-#else +- Q_UNUSED( fd ); +-#endif +-} +- +- +- +- +-/* +- * Standard mouse driver +- */ +- +-typedef struct { +- int bytesPerPacket; +-} MouseData; +- +-static const MouseData mouseData[] = { +- { 3 }, // dummy for auto protocal, correction made by add by YYD +- { 3 }, // MouseMan +- { 4 }, // intelliMouse +- { 3 }, // Microsoft +- { 0 }, // QVFBMouse, +- { 0 }, // TPanel, +- { 3 }, // BusMouse, +-}; +- +- +-class QWSMouseHandlerPrivate : public QWSMouseHandler { +- Q_OBJECT +-public: +- QWSMouseHandlerPrivate( MouseProtocol protocol, QString mouseDev ); +- ~QWSMouseHandlerPrivate(); +- +-#ifndef QT_NO_QWS_MOUSE_PC +-private: +- static const int mouseBufSize = 128; +- int mouseFD; +- int mouseIdx; +- uchar mouseBuf[mouseBufSize]; +- MouseProtocol mouseProtocol; +- void handleMouseData(); +-#endif +- +-private slots: +- void readMouseData(); +- +-private: +- int obstate; +-}; +- +- +-void QWSMouseHandlerPrivate::readMouseData() +-{ +-#ifndef QT_NO_QWS_MOUSE_PC +- int n; +- if ( BusMouse == mouseProtocol ) { +- // a workaround of linux busmouse driver interface. +- // It'll only read 3 bytes a time and return all other buffer zeroed, thus cause protocol errors +- for (;;) { +- if ( mouseBufSize - mouseIdx < 3 ) +- break; +- n = read( mouseFD, mouseBuf+mouseIdx, 3 ); +- if ( n != 3 ) +- break; +- mouseIdx += 3; +- } +- } else { +- do { +- n = read(mouseFD, mouseBuf+mouseIdx, mouseBufSize-mouseIdx ); +- if ( n > 0 ) +- mouseIdx += n; +- } while ( n > 0 ); +- } +- handleMouseData(); +-#endif +-} +- +- +-#ifndef QT_NO_QWS_MOUSE_PC +-/* +-*/ +- +-void QWSMouseHandlerPrivate::handleMouseData() +-{ +- static const int accel_limit = 5; +- static const int accel = 2; +- +- int idx = 0; +- int bstate = 0; +- int dx = 0, dy = 0; +- bool sendEvent = false; +- int tdx = 0, tdy = 0; +- +- while ( mouseIdx-idx >= mouseData[mouseProtocol].bytesPerPacket ) { +- //qDebug( "Got mouse data" ); +- uchar *mb = mouseBuf+idx; +- bstate = 0; +- dx = 0; +- dy = 0; +- sendEvent = false; +- switch (mouseProtocol) { +- case MouseMan: +- case IntelliMouse: +- { +- if (mb[0] & 0x01) +- bstate |= Qt::LeftButton; +- if (mb[0] & 0x02) +- bstate |= Qt::RightButton; +- if (mb[0] & 0x04) +- bstate |= Qt::MidButton; +- +- int overflow = (mb[0]>>6 )& 0x03; +- if (mouseProtocol == MouseMan && overflow) { +- //### wheel events signalled with overflow bit, ignore for now +- } +- else { +- bool xs = mb[0] & 0x10; +- bool ys = mb[0] & 0x20; +- dx = xs ? mb[1]-256 : mb[1]; +- dy = ys ? mb[2]-256 : mb[2]; + +- sendEvent = true; +- } +-#if 0 //debug +- if (mouseProtocol == MouseMan) +- printf("(%2d) %02x %02x %02x ", idx, mb[0], mb[1], mb[2]); +- else +- printf("(%2d) %02x %02x %02x %02x ",idx,mb[0],mb[1],mb[2],mb[3]); +- const char *b1 = (mb[0] & 0x01) ? "b1":" ";//left +- const char *b2 = (mb[0] & 0x02) ? "b2":" ";//right +- const char *b3 = (mb[0] & 0x04) ? "b3":" ";//mid + +- if ( overflow ) +- printf( "Overflow%d %s %s %s (%4d,%4d)\n", overflow, +- b1, b2, b3, mousePos.x(), mousePos.y() ); +- else +- printf( "%s %s %s (%+3d,%+3d) (%4d,%4d)\n", +- b1, b2, b3, dx, dy, mousePos.x(), mousePos.y() ); +-#endif +- break; +- } +- case Microsoft: +- if ( (mb[0] & 0x20) ) +- bstate |= Qt::LeftButton; +- if ( (mb[0] & 0x10) ) +- bstate |= Qt::RightButton; +- +- dx=(signed char)(((mb[0] & 0x03) << 6) | (mb[1] & 0x3f)); +- dy=-(signed char)(((mb[0] & 0x0c) << 4) | (mb[2] & 0x3f)); +- sendEvent=true; +- +- break; +- case BusMouse: +- if ( !(mb[0] & 0x04) ) +- bstate |= Qt::LeftButton; +- if ( !(mb[0] & 0x01) ) +- bstate |= Qt::RightButton; +- +- dx=(signed char)mb[1]; +- dy=(signed char)mb[2]; +- sendEvent=true; +- break; +- +- default: +- qWarning( "Unknown mouse protocol in QWSMouseHandlerPrivate" ); +- break; +- } +- if (sendEvent) { +- if ( QABS(dx) > accel_limit || QABS(dy) > accel_limit ) { +- dx *= accel; +- dy *= accel; +- } +- tdx += dx; +- tdy += dy; +- if ( bstate != obstate ) { +- mousePos += QPoint(tdx,-tdy); +- limitToScreen( mousePos ); +- emit mouseChanged(mousePos,bstate); +- sendEvent = FALSE; +- tdx = 0; +- tdy = 0; +- obstate = bstate; +- } +- } +- idx += mouseData[mouseProtocol].bytesPerPacket; +- } +- if ( sendEvent ) { +- mousePos += QPoint(tdx,-tdy); +- limitToScreen( mousePos ); +- emit mouseChanged(mousePos,bstate); +- } +- +- int surplus = mouseIdx - idx; +- for ( int i = 0; i < surplus; i++ ) +- mouseBuf[i] = mouseBuf[idx+i]; +- mouseIdx = surplus; +-} +-#endif +- +- +-QWSMouseHandlerPrivate::QWSMouseHandlerPrivate( MouseProtocol protocol, +- QString mouseDev ) +-{ +-#ifndef QT_NO_QWS_MOUSE_PC +- mouseProtocol = protocol; +- +- if ( mouseDev.isEmpty() ) +- mouseDev = "/dev/mouse"; +- obstate = -1; +- mouseFD = -1; +- mouseFD = open( mouseDev.local8Bit().data(), O_RDWR | O_NDELAY); +- if ( mouseFD < 0 ) { +- mouseFD = open( mouseDev.local8Bit().data(), O_RDONLY | O_NDELAY); +- if ( mouseFD < 0 ) +- qDebug( "Cannot open %s (%s)", mouseDev.ascii(), +- strerror(errno)); +- } else { +- // Clear pending input +- tcflush(mouseFD,TCIFLUSH); +- +- bool ps2 = false; +- +- switch (mouseProtocol) { +- case MouseMan: +- ps2 = true; +- write(mouseFD,"",1); +- usleep(50000); +- write(mouseFD,"@EeI!",5); +- break; +- +- case IntelliMouse: { +-// ps2 = true; +- const unsigned char init1[] = { 243, 200, 243, 100, 243, 80 }; +- const unsigned char init2[] = { 246, 230, 244, 243, 100, 232, 3 }; +- write(mouseFD,init1,sizeof(init1)); +- usleep(50000); +- write(mouseFD,init2,sizeof(init2)); +- } +- break; +- +- case Microsoft: +- struct termios tty; +- +- tcgetattr(mouseFD, &tty); +- +- tty.c_iflag = IGNBRK | IGNPAR; +- tty.c_oflag = 0; +- tty.c_lflag = 0; +-#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) +- tty.c_line = 0; +-#endif // _OS_FREEBSD_ +- tty.c_cc[VTIME] = 0; +- tty.c_cc[VMIN] = 1; +- tty.c_cflag = B1200 | CS7 | CREAD | CLOCAL | HUPCL; +- tcsetattr(mouseFD, TCSAFLUSH, &tty); /* set parameters */ +- break; +- +- case BusMouse: +- usleep(50000); +- break; +- +- default: +- qDebug("Unknown mouse protocol"); +- exit(1); +- } +- +- if (ps2) { +- char buf[] = { 246, 244 }; +- write(mouseFD,buf,1); +- write(mouseFD,buf+1,1); +- } +- +- usleep(50000); +- tcflush(mouseFD,TCIFLUSH); // ### doesn't seem to work. +- usleep(50000); +- tcflush(mouseFD,TCIFLUSH); // ### doesn't seem to work. +- +- char buf[100]; // busmouse driver will not read if bufsize < 3, YYD +- while (read(mouseFD, buf, 100) > 0) { } // eat unwanted replies +- +- mouseIdx = 0; +- +- QSocketNotifier *mouseNotifier; +- mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read, this ); +- connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData())); +- } +-#else +- Q_UNUSED(protocol); +- Q_UNUSED(mouseDev); +-#endif +-} +- +-QWSMouseHandlerPrivate::~QWSMouseHandlerPrivate() +-{ +-#ifndef QT_NO_QWS_MOUSE_PC +- if (mouseFD >= 0) { +- tcflush(mouseFD,TCIFLUSH); // yyd. +- close(mouseFD); +- } +-#endif +-} +- +-/* +- * +- */ + + QCalibratedMouseHandler::QCalibratedMouseHandler() + : samples(5), currSample(0), numSamples(0) +@@ -1030,7 +180,8 @@ + if ( file.open( IO_WriteOnly ) ) { + QTextStream t( &file ); + t << a << " " << b << " " << c << " "; +- t << d << " " << e << " " << f << " " << s; ++ t << d << " " << e << " " << f << " " << s << endl; ++ file.close(); + } else + #endif + { +@@ -1046,6 +197,7 @@ + if ( file.open( IO_ReadOnly ) ) { + QTextStream t( &file ); + t >> a >> b >> c >> d >> e >> f >> s; ++ file.close(); + } else + #endif + { +@@ -1073,12 +225,24 @@ + writeCalibration(); + } + ++void QCalibratedMouseHandler::setCalibration(int aa, int bb, int cc, int dd, int ee, int ff, int ss) ++{ ++ a = aa; ++ b = bb; ++ c = cc; ++ d = dd; ++ e = ee; ++ f = ff; ++ s = ss; ++} ++ + QPoint QCalibratedMouseHandler::transform( const QPoint &p ) + { + QPoint tp; + + tp.setX( (a * p.x() + b * p.y() + c) / s ); + tp.setY( (d * p.x() + e * p.y() + f) / s ); ++//qDebug("QCalibratedMouseHandler::transform(%d,%d) -> %d,%d)", p.x(), p.y(), tp.x(), tp.y() ); + + return tp; + } +@@ -1143,814 +307,192 @@ + return sent; + } + +-/* +- * Handler for /dev/tpanel Linux kernel driver +- */ + +-class QVrTPanelHandlerPrivate : public QCalibratedMouseHandler { +- Q_OBJECT +-public: +- QVrTPanelHandlerPrivate(MouseProtocol, QString dev); +- ~QVrTPanelHandlerPrivate(); + +-private: +- int mouseFD; +- MouseProtocol mouseProtocol; +-private slots: +- void sendRelease(); +- void readMouseData(); +-private: +- static const int mouseBufSize = 1280; +- QTimer *rtimer; +- int mouseIdx; +- uchar mouseBuf[mouseBufSize]; +-}; + +-#ifndef QT_QWS_CASSIOPEIA +-QVrTPanelHandlerPrivate::QVrTPanelHandlerPrivate( MouseProtocol, QString ) : +- QCalibratedMouseHandler() +-{ +-} +-#else +-QVrTPanelHandlerPrivate::QVrTPanelHandlerPrivate( MouseProtocol, QString dev ) : +- QCalibratedMouseHandler() +-{ +- if ( dev.isEmpty() ) +- dev = "/dev/tpanel"; +- +- if ((mouseFD = open( dev, O_RDONLY)) < 0) { +- qFatal( "Cannot open %s (%s)", dev.latin1(), strerror(errno)); +- } else { +- sleep(1); +- } +- +- struct scanparam s; +- s.interval = 20000; +- s.settletime = 480; +- if ( ioctl(mouseFD, TPSETSCANPARM, &s) < 0 +- || fcntl(mouseFD, F_SETFL, O_NONBLOCK) < 0 ) +- qWarning("Error initializing touch panel."); +- +- QSocketNotifier *mouseNotifier; +- mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read, +- this ); +- connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData())); +- +- rtimer = new QTimer( this ); +- connect( rtimer, SIGNAL(timeout()), this, SLOT(sendRelease())); +- mouseIdx = 0; +- setFilterSize( 3 ); +- +- printf("\033[?25l"); fflush(stdout); // VT100 cursor off +-} +-#endif +- +-QVrTPanelHandlerPrivate::~QVrTPanelHandlerPrivate() +-{ +- if (mouseFD >= 0) +- close(mouseFD); +-} +- +-void QVrTPanelHandlerPrivate::sendRelease() +-{ +- sendFiltered( mousePos, 0 ); +-} + +-void QVrTPanelHandlerPrivate::readMouseData() +-{ +-#ifdef QT_QWS_CASSIOPEIA +- if(!qt_screen) +- return; +- static bool pressed = FALSE; +- +- int n; +- do { +- n = read(mouseFD, mouseBuf+mouseIdx, mouseBufSize-mouseIdx ); +- if ( n > 0 ) +- mouseIdx += n; +- } while ( n > 0 && mouseIdx < mouseBufSize ); +- +- int idx = 0; +- while ( mouseIdx-idx >= (int)sizeof( short ) * 6 ) { +- uchar *mb = mouseBuf+idx; +- ushort *data = (ushort *) mb; +- if ( data[0] & 0x8000 ) { +- if ( data[5] > 750 ) { +- QPoint t(data[3]-data[4],data[2]-data[1]); +- if ( sendFiltered( t, Qt::LeftButton ) ) +- pressed = TRUE; +- if ( pressed ) +- rtimer->start( 200, TRUE ); // release unreliable +- } +- } else if ( pressed ) { +- rtimer->start( 50, TRUE ); +- pressed = FALSE; +- } +- idx += sizeof( ushort ) * 6; +- } ++struct input_event { ++ struct timeval time; ++ unsigned short type; ++ unsigned short code; ++ unsigned int value; ++}; + +- int surplus = mouseIdx - idx; +- for ( int i = 0; i < surplus; i++ ) +- mouseBuf[i] = mouseBuf[idx+i]; +- mouseIdx = surplus; + +-#endif +-} ++#define EV_ABS 0x03 ++#define ABS_X 0x00 ++#define ABS_Y 0x01 ++#define ABS_PRESSURE 0x18 + + +-class QTPanelHandlerPrivate : public QCalibratedMouseHandler ++class QInputEventHandler : public QCalibratedMouseHandler + { + Q_OBJECT + public: +- QTPanelHandlerPrivate(MouseProtocol, QString dev); +- ~QTPanelHandlerPrivate(); ++ QInputEventHandler(MouseProtocol, QString dev); ++ ~QInputEventHandler(); ++ ++ virtual void calibrate( QWSPointerCalibrationData * ); ++ virtual void setCalibration(int aa, int bb, int cc, int dd, int ee, int ff, int ss); + + private: +- static const int mouseBufSize = 2048; ++ void init(); ++ void fini(); ++ + int mouseFD; +- QPoint oldmouse; +- QPoint oldTotalMousePos; +- bool waspressed; +- QPointArray samples; +- unsigned int currSample; +- unsigned int lastSample; +- unsigned int numSamples; +- int skipCount; +- int mouseIdx; +- uchar mouseBuf[mouseBufSize]; ++ struct input_event sample; ++ int myX, myY, myP, oldX, oldY, oldP; ++ int xtable[QT_QWS_TP_TABLE_SIZE]; ++ int ytable[QT_QWS_TP_TABLE_SIZE]; ++ int ptr; + + private slots: + void readMouseData(); + }; + + +-QTPanelHandlerPrivate::QTPanelHandlerPrivate( MouseProtocol, QString dev ) +- : samples(QT_QWS_TP_SAMPLE_SIZE), currSample(0), lastSample(0), +- numSamples(0), skipCount(0) +-{ +- Q_UNUSED(dev); +-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700) +-#if defined(QT_QWS_IPAQ) +-# ifdef QT_QWS_IPAQ_RAW +- if ((mouseFD = open( "/dev/h3600_tsraw", O_RDONLY | O_NDELAY)) < 0) { +-# else +- if ((mouseFD = open( "/dev/h3600_ts", O_RDONLY | O_NDELAY)) < 0) { +-# endif +- qWarning( "Cannot open /dev/h3600_ts (%s)", strerror(errno)); +- return; +- } +-#elif defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700) +-//# ifdef QT_QWS_SL5XXX_TSRAW +-# if 0 +- if ((mouseFD = open( "/dev/tsraw", O_RDONLY | O_NDELAY)) < 0) { +- qWarning( "Cannot open /dev/tsraw (%s)", strerror(errno)); +- return; +- } +-# else +- if ((mouseFD = open( "/dev/ts", O_RDONLY | O_NDELAY)) < 0) { +- qWarning( "Cannot open /dev/ts (%s)", strerror(errno)); +- return; +- } +-# endif +-#elif defined(QT_QWS_SIMPAD ) +- if ((mouseFD = open( "/dev/touchscreen/ucb1x00", O_RDONLY | O_NONBLOCK )) < 0) { +- qWarning( "Cannot open /dev/touchscreen/ucb1x00 (%s)", strerror(errno)); +- return; +- } +-#endif +- +- QSocketNotifier *mouseNotifier; +- mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read, +- this ); +- connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData())); +- waspressed=FALSE; +- mouseIdx = 0; +-#endif +-} +- +-QTPanelHandlerPrivate::~QTPanelHandlerPrivate() ++QInputEventHandler::QInputEventHandler( MouseProtocol, QString ) ++ : myP(-1) + { +-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700) || defined(QT_QWS_SIMPAD) +- if (mouseFD >= 0) +- close(mouseFD); +-#endif ++ init(); + } + +-void QTPanelHandlerPrivate::readMouseData() ++QInputEventHandler::~QInputEventHandler() + { +-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700) || defined(QT_QWS_SIMPAD) +- if(!qt_screen) +- return; +- +- int n; +- do { +- n = read(mouseFD, mouseBuf+mouseIdx, mouseBufSize-mouseIdx ); +- if ( n > 0 ) +- mouseIdx += n; +- } while ( n > 0 && mouseIdx < mouseBufSize ); +- +- TS_EVENT *data; +- int idx = 0; +- +- // perhaps we shouldn't be reading EVERY SAMPLE. +- while ( mouseIdx-idx >= (int)sizeof( TS_EVENT ) ) { +- uchar *mb = mouseBuf+idx; +- data = (TS_EVENT *) mb; +- if(data->pressure >= QT_QWS_TP_PRESSURE_THRESHOLD) { +-#if defined(QT_QWS_SL5XXX) || defined(QT_QWS_SLC700) +- samples[currSample] = QPoint( 1000 - data->x, data->y ); +-#else +- samples[currSample] = QPoint( data->x, data->y ); +-#endif +- +- numSamples++; +- if ( numSamples >= QT_QWS_TP_MINIMUM_SAMPLES ) { +- int sampleCount = QMIN(numSamples + 1,samples.count()); +- +- // average the rest +- mousePos = QPoint( 0, 0 ); +- QPoint totalMousePos = oldTotalMousePos; +- totalMousePos += samples[currSample]; +- if(numSamples >= samples.count()) +- totalMousePos -= samples[lastSample]; +- +- mousePos = totalMousePos / (sampleCount - 1); +- +-# if defined(QT_QWS_IPAQ_RAW) || defined(QT_QWS_SL5XXX_RAW) +- mousePos = transform( mousePos ); +-# endif +- if(!waspressed) +- oldmouse = mousePos; +- QPoint dp = mousePos - oldmouse; +- int dxSqr = dp.x() * dp.x(); +- int dySqr = dp.y() * dp.y(); +- if ( dxSqr + dySqr < (QT_QWS_TP_MOVE_LIMIT * QT_QWS_TP_MOVE_LIMIT) ) { +- if ( waspressed ) { +- if ( (dxSqr + dySqr > (QT_QWS_TP_JITTER_LIMIT * QT_QWS_TP_JITTER_LIMIT) ) || skipCount > 2) { +- emit mouseChanged(mousePos,Qt::LeftButton); +- oldmouse = mousePos; +- skipCount = 0; +- } else { +- skipCount++; +- } +- } else { +- emit mouseChanged(mousePos,Qt::LeftButton); +- oldmouse=mousePos; +- waspressed=true; +- } +- +- // save recuring information +- currSample++; +- if (numSamples >= samples.count()) +- lastSample++; +- oldTotalMousePos = totalMousePos; +- } else { +- numSamples--; // don't use this sample, it was bad. +- } +- } else { +- // build up the average +- oldTotalMousePos += samples[currSample]; +- currSample++; +- } +- if ( currSample >= samples.count() ) +- currSample = 0; +- if ( lastSample >= samples.count() ) +- lastSample = 0; +- } else { +- currSample = 0; +- lastSample = 0; +- numSamples = 0; +- skipCount = 0; +- oldTotalMousePos = QPoint(0,0); +- if ( waspressed ) { +- emit mouseChanged(oldmouse,0); +- oldmouse = QPoint( -100, -100 ); +- waspressed=false; +- } +- } +- idx += sizeof( TS_EVENT ); +- } ++ fini(); + +- int surplus = mouseIdx - idx; +- for ( int i = 0; i < surplus; i++ ) +- mouseBuf[i] = mouseBuf[idx+i]; +- mouseIdx = surplus; +-#endif + } + +-// YOPY touch panel support based on changes contributed by Ron Victorelli +-// (victorrj at icubed.com) to Custom TP driver. +-// +-class QYopyTPanelHandlerPrivate : public QWSMouseHandler { +- Q_OBJECT +-public: +- QYopyTPanelHandlerPrivate(MouseProtocol, QString dev); +- ~QYopyTPanelHandlerPrivate(); +- +-private: +- int mouseFD; +- int prevstate; +-private slots: +- void readMouseData(); +- +-}; +- +-QYopyTPanelHandlerPrivate::QYopyTPanelHandlerPrivate( MouseProtocol, QString ) ++void QInputEventHandler::setCalibration(int aa, int bb, int cc, int dd, int ee, int ff, int ss) + { +-#ifdef QT_QWS_YOPY +- if ((mouseFD = open( "/dev/ts", O_RDONLY)) < 0) { +- qWarning( "Cannot open /dev/ts (%s)", strerror(errno)); +- return; +- } else { +- sleep(1); +- } +- prevstate=0; +- QSocketNotifier *mouseNotifier; +- mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read, +- this ); +- connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData())); +-#endif +-} ++ QCalibratedMouseHandler::setCalibration(aa, bb, cc, dd, ee, ff, ss); + +-QYopyTPanelHandlerPrivate::~QYopyTPanelHandlerPrivate() +-{ +- if (mouseFD >= 0) +- close(mouseFD); ++ writeCalibration(); ++ fini(); ++ init(); + } + +-#define YOPY_XPOS(d) (d[1]&0x3FF) +-#define YOPY_YPOS(d) (d[2]&0x3FF) +-#define YOPY_PRES(d) (d[0]&0xFF) +-#define YOPY_STAT(d) (d[3]&0x01 ) +- +-struct YopyTPdata { +- +- unsigned char status; +- unsigned short xpos; +- unsigned short ypos; +- +-}; +- +-void QYopyTPanelHandlerPrivate::readMouseData() ++void QInputEventHandler::calibrate( QWSPointerCalibrationData *cd ) + { +-#ifdef QT_QWS_YOPY +- if(!qt_screen) +- return; +- YopyTPdata data; +- +- unsigned int yopDat[4]; +- +- int ret; +- +- ret=read(mouseFD,&yopDat,sizeof(yopDat)); ++ QCalibratedMouseHandler::calibrate( cd ); + +- if(ret) { +- data.status= ( YOPY_PRES(yopDat) ) ? 1 : 0; +- data.xpos=YOPY_XPOS(yopDat); +- data.ypos=YOPY_YPOS(yopDat); +- QPoint q; +- q.setX(data.xpos); +- q.setY(data.ypos); +- mousePos=q; +- if(data.status && !prevstate) { +- emit mouseChanged(mousePos,Qt::LeftButton); +- } else if( !data.status && prevstate ) { +- emit mouseChanged(mousePos,0); +- } +- prevstate = data.status; +- } +- if(ret<0) { +- qDebug("Error %s",strerror(errno)); +- } +-#endif ++ // write calibration data, and close and reopen ++ // tslib, in order to ensure it uses the new values ++ writeCalibration(); ++ fini(); ++ init(); + } + +-class QCustomTPanelHandlerPrivate : public QWSMouseHandler { +- Q_OBJECT +-public: +- QCustomTPanelHandlerPrivate(MouseProtocol, QString dev); +- ~QCustomTPanelHandlerPrivate(); +- +-private: +- int mouseFD; +-private slots: +- void readMouseData(); +- +-}; +- +-QCustomTPanelHandlerPrivate::QCustomTPanelHandlerPrivate( MouseProtocol, QString ) ++void QInputEventHandler::init() + { +-#ifdef QWS_CUSTOMTOUCHPANEL +- if ((mouseFD = open( "/dev/ts", O_RDONLY)) < 0) { +- qWarning( "Cannot open /dev/ts (%s)", strerror(errno)); ++ if ((mouseFD = open( "/dev/input/event1", O_RDONLY)) < 0) { ++ qWarning( "Cannot open /dev/input/event1 (%s)", strerror(errno)); + return; +- } else { +- sleep(1); + } + + QSocketNotifier *mouseNotifier; +- mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read, +- this ); ++ mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read, this ); ++ setFilterSize(2); + connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData())); +-#endif + } + +-QCustomTPanelHandlerPrivate::~QCustomTPanelHandlerPrivate() ++void QInputEventHandler::fini() + { + if (mouseFD >= 0) + close(mouseFD); + } + +-struct CustomTPdata { +- +- unsigned char status; +- unsigned short xpos; +- unsigned short ypos; +- +-}; +- +-void QCustomTPanelHandlerPrivate::readMouseData() ++void QInputEventHandler::readMouseData() + { +-#ifdef QWS_CUSTOMTOUCHPANEL +- if(!qt_screen) +- return; +- CustomTPdata data; +- +- unsigned char data2[5]; +- +- int ret; +- +- ret=read(mouseFD,data2,5); ++ if (!qt_screen) ++ return; + +- if(ret==5) { +- data.status=data2[0]; +- data.xpos=(data2[1] << 8) | data2[2]; +- data.ypos=(data2[3] << 8) | data2[4]; +- QPoint q; +- q.setX(data.xpos); +- q.setY(data.ypos); +- mousePos=q; +- if(data.status & 0x40) { +- emit mouseChanged(mousePos,Qt::LeftButton); +- } else { +- emit mouseChanged(mousePos,0); ++ unsigned int size = read(mouseFD, &sample, sizeof(sample)); ++ if (size < sizeof(sample)) { ++ qDebug("no input"); ++ return; ++ } ++ //qDebug("type,code,val: %d,%d,%d", sample.type, sample.code, sample.value); ++ if (sample.type == EV_ABS) { ++ if (sample.code == ABS_Y) { ++ myY = sample.value; ++ return; ++ } else ++ if (sample.code == ABS_X) { ++ myX = sample.value; ++ return; ++ } else ++ if (sample.code == ABS_PRESSURE) { ++ myP = sample.value; ++ } + } +- } +- if(ret<0) { +- qDebug("Error %s",strerror(errno)); +- } +-#endif +-} +- +-/* +- * Virtual framebuffer mouse driver +- */ +- +-#ifndef QT_NO_QWS_VFB +-#include "qvfbhdr.h" +-extern int qws_display_id; +-#endif +- +-class QVFbMouseHandlerPrivate : public QWSMouseHandler { +- Q_OBJECT +-public: +- QVFbMouseHandlerPrivate(MouseProtocol, QString dev); +- ~QVFbMouseHandlerPrivate(); +- +-#ifndef QT_NO_QWS_VFB +- bool isOpen() const { return mouseFD > 0; } +- +-private: +- static const int mouseBufSize = 128; +- int mouseFD; +- int mouseIdx; +- uchar mouseBuf[mouseBufSize]; +-#endif +- +-private slots: +- void readMouseData(); +-}; +- +-QVFbMouseHandlerPrivate::QVFbMouseHandlerPrivate( MouseProtocol, QString mouseDev ) +-{ +-#ifndef QT_NO_QWS_VFB +- mouseFD = -1; +- if ( mouseDev.isEmpty() ) +- mouseDev = QString(QT_VFB_MOUSE_PIPE).arg(qws_display_id); +- +- if ((mouseFD = open( mouseDev.local8Bit().data(), O_RDWR | O_NDELAY)) < 0) { +- qDebug( "Cannot open %s (%s)", mouseDev.ascii(), +- strerror(errno)); +- } else { +- // Clear pending input +- char buf[2]; +- while (read(mouseFD, buf, 1) > 0) { } +- +- mouseIdx = 0; +- +- QSocketNotifier *mouseNotifier; +- mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read, this ); +- connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData())); +- } +-#endif +-} +- +-QVFbMouseHandlerPrivate::~QVFbMouseHandlerPrivate() +-{ +-#ifndef QT_NO_QWS_VFB +- if (mouseFD >= 0) +- close(mouseFD); +-#endif +-} +- +-void QVFbMouseHandlerPrivate::readMouseData() +-{ +-#ifndef QT_NO_QWS_VFB +- int n; +- do { +- n = read(mouseFD, mouseBuf+mouseIdx, mouseBufSize-mouseIdx ); +- if ( n > 0 ) +- mouseIdx += n; +- } while ( n > 0 ); +- +- int idx = 0; +- while ( mouseIdx-idx >= int(sizeof( QPoint ) + sizeof( int )) ) { +- uchar *mb = mouseBuf+idx; +- QPoint *p = (QPoint *) mb; +- mb += sizeof( QPoint ); +- int *bstate = (int *)mb; +- mousePos = *p; +- limitToScreen( mousePos ); +- emit mouseChanged(mousePos, *bstate); +- idx += sizeof( QPoint ) + sizeof( int ); +- } +- +- int surplus = mouseIdx - idx; +- for ( int i = 0; i < surplus; i++ ) +- mouseBuf[i] = mouseBuf[idx+i]; +- mouseIdx = surplus; +-#endif +-} +- +-/* +- mouse handler for tslib +- see http://cvs.arm.linux.org.uk/ +- */ +-/* +- +- Copyright (C) 2003, 2004, 2005 Texas Instruments, Inc. +- Copyright (C) 2004, 2005 Holger Hans Peter Freyther +- All rights reserved. +- +- Redistribution and use in source and binary forms, with or without +- modification, are permitted provided that the following conditions are met: +- +- Redistributions of source code must retain the above copyright notice, +- this list of conditions and the following disclaimer. +- +- Redistributions in binary form must reproduce the above copyright +- notice, this list of conditions and the following disclaimer in the +- documentation and/or other materials provided with the distribution. +- +- Neither the name Texas Instruments, Inc nor the names of its +- contributors may be used to endorse or promote products derived +- from this software without specific prior written permission. +- +- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +- FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +- COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +- SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +- STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING +- IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +- POSSIBILITY OF SUCH DAMAGE. +- +-*/ +-class QTSLibHandlerPrivate : public QCalibratedMouseHandler +-{ +- Q_OBJECT +-public: +- QTSLibHandlerPrivate(); +- ~QTSLibHandlerPrivate(); +- +- virtual void clearCalibration(); +- virtual void calibrate( QWSPointerCalibrationData * ); +- static int sortByX( const void*, const void* ); +- static int sortByY( const void*, const void* ); +- +-private: +- bool m_raw : 1; +- QSocketNotifier *m_notify; +- +-#ifdef QT_QWS_TSLIB +- struct tsdev *m_ts; +-#endif +- void openTs(); +- void closeTs(); +- void interpolateSample(); +- +-private slots: +- void readMouseData(); +- +-}; +- +-QTSLibHandlerPrivate::QTSLibHandlerPrivate() +- : m_raw(false), m_notify(0 ) +-{ +- openTs(); +-} +- +-QTSLibHandlerPrivate::~QTSLibHandlerPrivate() +-{ +- closeTs(); +-} +- +-void QTSLibHandlerPrivate::openTs() +-{ +-#ifdef QT_QWS_TSLIB +- char *tsdevice; +- if((tsdevice = getenv("TSLIB_TSDEVICE")) != NULL) { +- m_ts = ts_open( tsdevice, 1 ); //1 = nonblocking, 0 = blocking mode +- } else { +- m_ts = ts_open( "/dev/ts", 1 ); +- } +- +- if (!m_ts) { +- qWarning( "Cannot open touchscreen (%s)", strerror( errno)); +- return; +- } +- +- if (ts_config( m_ts)) { +- qWarning( "Cannot configure touchscreen (%s)", strerror( errno)); +- return; +- } +- m_notify = new QSocketNotifier( ts_fd(m_ts), QSocketNotifier::Read, this ); +- connect( m_notify, SIGNAL(activated(int)),this, SLOT(readMouseData())); +-#endif +-} +- +-void QTSLibHandlerPrivate::closeTs() +-{ +-#ifdef QT_QWS_TSLIB +- if (m_ts) +- ts_close(m_ts); +- m_ts = 0; +-#endif +- +- delete m_notify; +- m_notify = 0; +- m_raw = false; +-} +- +-void QTSLibHandlerPrivate::clearCalibration() +-{ +- m_raw = true; +-} +- +-void QTSLibHandlerPrivate::calibrate( QWSPointerCalibrationData * cd) +-{ +- QPoint dev_tl = cd->devPoints[ QWSPointerCalibrationData::TopLeft ]; +- QPoint dev_br = cd->devPoints[ QWSPointerCalibrationData::BottomRight ]; +- QPoint screen_tl = cd->screenPoints[ QWSPointerCalibrationData::TopLeft ]; +- QPoint screen_br = cd->screenPoints[ QWSPointerCalibrationData::BottomRight ]; +- int a, b, c, d, e, f, s; +- +- s = 1 << 16; + +- a = s * (screen_tl.x() - screen_br.x() ) / (dev_tl.x() - dev_br.x()); +- b = 0; +- c = s * screen_tl.x() - a * dev_tl.x(); ++ // up->up ++ if (oldP==0 && myP==0) { ++ //qDebug("uu %d,%d,%d", myX,myY,myP); ++ return; ++ } + +- d = 0; +- e = s * (screen_tl.y() - screen_br.y() ) / (dev_tl.y() - dev_br.y()); +- f = s * screen_tl.y() - e * dev_tl.y(); ++ // up->down ++ if (oldP==0 && myP>QT_QWS_TP_PRESSURE_DOWN_THRESHOLD) { ++ //qDebug("ud %d,%d,%d", myX,myY,myP); + +- QString calFile = "/etc/pointercal"; +-#ifndef QT_NO_TEXTSTREAM +- QFile file( calFile ); +- if ( file.open( IO_WriteOnly ) ) { +- QTextStream t( &file ); +- t << a << " " << b << " " << c << " "; +- t << d << " " << e << " " << f << " " << s; +- file.flush(); closeTs(); +- openTs(); +- } else +-#endif +- { +- qDebug( "Could not save calibration: %s", calFile.latin1() ); +- } +-} ++ xtable[0] = myX; ++ ytable[0] = myY; ++ ptr = 1; ++ oldX = myX; ++ oldY = myY; ++ oldP = myP; ++ return; ++ } + +-void QTSLibHandlerPrivate::readMouseData() +-{ +-#ifdef QT_QWS_TSLIB +- if(!qt_screen) +- return; ++ // down->down ++ if (oldP>QT_QWS_TP_PRESSURE_DOWN_THRESHOLD && myP>QT_QWS_TP_PRESSURE_UP_THRESHOLD) { ++ //qDebug("dd %d,%d,%d (%d,%d)", myX,myY,myP, oldX,oldY); + +- /* +- * After clear Calibration +- * we're in raw mode and do some easy median +- * search. +- */ +- if ( m_raw ) +- return interpolateSample(); ++ int dxSqr = myX-oldX; dxSqr *= dxSqr; ++ int dySqr = myY-oldY; dySqr *= dySqr; ++ oldX = myX; ++ oldY = myY; ++ if (dxSqr+dySqr > QT_QWS_TP_MOVE_MAX*QT_QWS_TP_MOVE_MAX) { ++ //qWarning("distance too wide %d", dxSqr+dySqr); ++ return; ++ } + +- static struct ts_sample sample; +- static int ret; ++ if (ptr < QT_QWS_TP_TABLE_SIZE) { ++ xtable[ptr] = myX; ++ ytable[ptr++] = myY; ++ } + +- /* +- * Ok. We need to see if we can read more than one event +- * We do this not to lose an update. +- */ +- while ( true ) { +- if ((ret = ts_read(m_ts, &sample, 1)) != 1 ) +- return; ++ if (ptr == QT_QWS_TP_TABLE_SIZE) { ++ int i; ++ int mx = 0; ++ int my = 0; ++ for (i=0; i<QT_QWS_TP_TABLE_SIZE; i++) { ++ mx += xtable[i]; ++ my += ytable[i]; ++ if (i>0) { ++ xtable[i-1] = xtable[i]; ++ ytable[i-1] = ytable[i]; ++ } ++ } ++ ptr--; ++ mousePos = transform(QPoint(mx/QT_QWS_TP_TABLE_SIZE, my/QT_QWS_TP_TABLE_SIZE)); + ++ emit mouseChanged(mousePos, Qt::LeftButton); ++ } ++ return; ++ } + +- QPoint pos( sample.x, sample.y ); +- mouseChanged( pos, sample.pressure != 0 ? 1 : 0 ); +- } +-#endif ++ // down->up ++ //qDebug("du %d,%d,%d", myX,myY,myP); ++ emit mouseChanged(mousePos, 0); ++ oldP = 0; + } + +-/* +- * Lets take all down events and then sort them +- * and take the event in the middle. +- * +- * inspired by testutils.c +- */ +-void QTSLibHandlerPrivate::interpolateSample() { +-#ifdef QT_QWS_TSLIB +-#define TSLIB_MAX_SAMPLES 25 +- static struct ts_sample samples[TSLIB_MAX_SAMPLES]; +- int index = 0; +- int read_samples = 0; +- int ret; +- +- do { +- /* do not access negative arrays */ +- if ( index < 0 ) +- index = 0; +- +- /* we're opened non-blocking */ +- if((ret= ts_read_raw(m_ts, &samples[index], 1 ) ) != 1 ) +- /* no event yet, so try again */ +- if (ret==-1 ) +- continue; +- +- read_samples++; +- index = (index+1)%TSLIB_MAX_SAMPLES; +- }while (samples[index == 0 ? (TSLIB_MAX_SAMPLES-1) : index-1].pressure != 0); +- +- /* +- * If we've wrapped around each sample is used otherwise +- * we will use the index +- */ +- index = read_samples >= TSLIB_MAX_SAMPLES ? +- (TSLIB_MAX_SAMPLES-1 ) : index; +- int x, y; +- +- /* +- * now let us use the median value +- * even index does not have an item in the middle +- * so let us take the average of n/2 and (n/2)-1 as the middle +- */ +- int m = index/2; +- ::qsort(samples, index, sizeof(ts_sample), QTSLibHandlerPrivate::sortByX); +- x = (index % 2 ) ? samples[m].x : +- ( samples[m-1].x + samples[m].x )/2; +- +- ::qsort(samples, index, sizeof(ts_sample), QTSLibHandlerPrivate::sortByY); +- y = (index % 2 ) ? samples[m].y : +- ( samples[m-1].y + samples[m].y )/2; + +- emit mouseChanged( QPoint(x, y), 1 ); +- emit mouseChanged( QPoint(0, 0), 0 ); +-#endif +-} + +-int QTSLibHandlerPrivate::sortByX( const void* one, const void* two) { +-#ifdef QT_QWS_TSLIB +- return reinterpret_cast<const struct ts_sample*>(one)->x - +- reinterpret_cast<const struct ts_sample*>(two)->x; +-#else +- return 0; +-#endif +-} + +-int QTSLibHandlerPrivate::sortByY( const void* one, const void* two) { +-#ifdef QT_QWS_TSLIB +- return reinterpret_cast<const struct ts_sample*>(one)->y - +- reinterpret_cast<const struct ts_sample*>(two)->y; +-#else +- return 0; +-#endif +-} +-////// + + /* + * return a QWSMouseHandler that supports /a spec. +@@ -1977,7 +519,7 @@ + + if ( mouseProto == "USB" && mouseDev.isEmpty() ) + mouseDev = "/dev/input/mice"; +- ++ + MouseProtocol mouseProtocol = Unknown; + + int idx = 0; +@@ -1988,50 +530,7 @@ + idx++; + } + +- +- QWSMouseHandler *handler = 0; +- +- switch ( mouseProtocol ) { +-#ifndef QT_NO_QWS_MOUSE_AUTO +- case Auto: +- handler = new QAutoMouseHandler(); +- break; +-#endif +- +-#ifndef QT_NO_QWS_MOUSE_PC +- case MouseMan: +- case IntelliMouse: +- case Microsoft: +- case BusMouse: +- handler = new QWSMouseHandlerPrivate( mouseProtocol, mouseDev ); +- break; +-#endif +- +-#ifndef QT_NO_QWS_VFB +- case QVFBMouse: +- handler = new QVFbMouseHandlerPrivate( mouseProtocol, mouseDev ); +- break; +-#endif +- +- case TPanel: +-#if defined(QWS_CUSTOMTOUCHPANEL) +- handler = new QCustomTPanelHandlerPrivate(mouseProtocol,mouseDev); +-#elif defined(QT_QWS_TSLIB) +- handler = new QTSLibHandlerPrivate(); +-#elif defined(QT_QWS_YOPY) +- handler = new QYopyTPanelHandlerPrivate(mouseProtocol,mouseDev); +-#elif defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700) || defined(QT_QWS_SIMPAD) +- handler = new QTPanelHandlerPrivate(mouseProtocol,mouseDev); +-#elif defined(QT_QWS_CASSIOPEIA) +- handler = new QVrTPanelHandlerPrivate( mouseProtocol, mouseDev ); +-#endif +- break; +- +- default: +- qDebug( "Mouse type %s unsupported", spec.latin1() ); +- } +- +- return handler; ++ return new QInputEventHandler( mouseProtocol, mouseDev ); + } + + #include "qwsmouse_qws.moc" +--- qt-2.3.10/src/kernel/qwsmouse_qws.h~ramses-touchscreen ++++ qt-2.3.10/src/kernel/qwsmouse_qws.h +@@ -1,5 +1,5 @@ + /**************************************************************************** +-** $Id: qt/src/kernel/qwsmouse_qws.h 2.3.10 edited 2005-01-24 $ ++** $Id: qt/src/kernel/qwsmouse_qws.h 2.3.7 edited 2001-10-03 $ + ** + ** Definition of Qt/FB central server classes + ** +@@ -70,6 +70,7 @@ + virtual void clearCalibration(); + virtual void calibrate( QWSPointerCalibrationData * ); + virtual void getCalibration( QWSPointerCalibrationData * ); ++ virtual void setCalibration(int aa, int bb, int cc, int dd, int ee, int ff, int ss); + + protected: + void readCalibration(); diff --git a/packages/qte/qte-2.3.10/deprecated/mnci.patch b/packages/qte/qte-2.3.10/deprecated/mnci.patch new file mode 100644 index 0000000000..c2e0e079d9 --- /dev/null +++ b/packages/qte/qte-2.3.10/deprecated/mnci.patch @@ -0,0 +1,125 @@ + +# +# Patch managed by http://www.holgerschurig.de/patcher.html +# + +--- qt-2.3.10/src/kernel/qgfxlinuxfb_qws.cpp~ramses.patch ++++ qt-2.3.10/src/kernel/qgfxlinuxfb_qws.cpp +@@ -249,20 +249,12 @@ + + static void writeTerm(const char* termctl, int sizeof_termctl) + { +-#ifdef QT_QWS_DEVFS +- const char* tt[]={"/dev/vc/1","/dev/console","/dev/tty",0}; +-#else +- const char* tt[]={"/dev/console","/dev/tty","/dev/tty0",0}; +-#endif +- const char** dev=tt; +- while (*dev) { +- int tty=::open(*dev,O_WRONLY); ++qWarning("writeTerm"); ++ int tty=::open("/dev/vc/2", O_WRONLY); + if ( tty>=0 ) { + ::write(tty,termctl,sizeof_termctl); + ::close(tty); + } +- dev++; +- } + } + + /*! +@@ -275,6 +267,7 @@ + + bool QLinuxFbScreen::initDevice() + { ++qWarning("QLinuxFbScreen::initDevice"); + /* Setting up the VT parameters is done in qapplication_qws.cpp + const char termctl[]="\033[9;0]\033[?33l\033[?25l"; + writeTerm(termctl,sizeof(termctl)); */ +@@ -765,9 +758,12 @@ + } + */ + ++qWarning("QLinuxFbScreen::shutdownDevice"); ++/* + // Blankin' screen, blinkin' cursor! + const char termctl[] = "\033[9;15]\033[?33h\033[?25h\033[?0c"; + writeTerm(termctl,sizeof(termctl)); ++*/ + } + + /*! +--- qt-2.3.10/src/kernel/qapplication_qws.cpp~ramses.patch ++++ qt-2.3.10/src/kernel/qapplication_qws.cpp +@@ -1756,8 +1756,6 @@ + */ + if ( qws_daemon ) + { +- qWarning( "qt_init() - starting in daemon mode..." ); +- + int pid1 = fork(); + if ( pid1 == -1 ) + { +@@ -1791,7 +1789,6 @@ + } + if ( pid2 ) + { +- syslog( 4, "qt_init() [%d] - successfully entered daemon mode", pid2 ); + _exit( 0 ); // ok, second fork performed + } + } +@@ -1828,9 +1825,12 @@ + #if defined(_OS_LINUX_) + if ( qws_terminal_id ) + { +- qDebug( "qt_init() - terminal specification is '%d'.", qws_terminal_id ); + struct vt_stat console_stat; ++#ifdef QT_QWS_DEVFS ++ int console_fd = ::open( QString().sprintf( "/dev/vc/%d", qws_terminal_id ).latin1(), O_RDWR ); ++#else + int console_fd = ::open( QString().sprintf( "/dev/tty%d", qws_terminal_id ).latin1(), O_RDWR ); ++#endif + if ( console_fd == -1) + { + qWarning( "qt_init() - can't open tty: %s", strerror( errno ) ); +@@ -1927,7 +1927,11 @@ + { + qDebug( "qt_cleanup() - switching back to virtual terminal #%d", qws_terminal_old ); + ++#ifdef QT_QWS_DEVFS ++ int console_fd = ::open( "/dev/vc/0", O_RDWR ); ++#else + int console_fd = ::open( "/dev/tty0", O_RDWR ); ++#endif + if ( console_fd == -1) + { + qWarning( "qt_init() - can't open tty: %s", strerror( errno ) ); +--- qt-2.3.10/src/kernel/qwindowsystem_qws.cpp~ramses.patch ++++ qt-2.3.10/src/kernel/qwindowsystem_qws.cpp +@@ -1791,6 +1791,7 @@ + } + + #ifndef QT_NO_QWS_KEYBOARD ++#ifndef QT_QWS_RAMSES + static int keyUnicode(int keycode) + { + const QWSServer::KeyMap *km = QWSServer::keyMap(); +@@ -1803,6 +1804,7 @@ + return 0xffff; + } + #endif ++#endif + /*! + Send a key event. You can use this to send key events generated by + "virtual keyboards". +@@ -1845,8 +1847,10 @@ + + event.simpleData.unicode = + #ifndef QT_NO_QWS_KEYBOARD ++#ifndef QT_QWS_RAMSES + unicode < 0 ? keyUnicode(keycode) : + #endif ++#endif + unicode; + event.simpleData.keycode = keycode; + event.simpleData.modifiers = modifiers; diff --git a/packages/qte/qte-2.3.10/deprecated/openmn/.mtn2git_empty b/packages/qte/qte-2.3.10/deprecated/openmn/.mtn2git_empty new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/packages/qte/qte-2.3.10/deprecated/openmn/.mtn2git_empty diff --git a/packages/qte/qte-2.3.10/deprecated/openmn/qkeyboard_qws.cpp b/packages/qte/qte-2.3.10/deprecated/openmn/qkeyboard_qws.cpp new file mode 100644 index 0000000000..9917675a43 --- /dev/null +++ b/packages/qte/qte-2.3.10/deprecated/openmn/qkeyboard_qws.cpp @@ -0,0 +1,584 @@ +/**************************************************************************** +** $Id: qt/src/kernel/qkeyboard_qws.cpp 2.3.7 edited 2003-05-30 $ +** +** Implementation of Qt/Embedded keyboard drivers +** +** Created : 991025 +** +** Copyright (C) 1992-2000 Trolltech AS. All rights reserved. +** +** This file is part of the kernel module of the Qt GUI Toolkit. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition +** licenses for Qt/Embedded may use this file in accordance with the +** Qt Embedded Commercial License Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about Qt Commercial License Agreements. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#include "qwindowsystem_qws.h" +#include "qwsutils_qws.h" +#include "qgfx_qws.h" + +#include <qapplication.h> +#include <qsocketnotifier.h> +#include <qnamespace.h> +#include <qtimer.h> + +#include <stdlib.h> +#include <stdio.h> +#include <ctype.h> + +#include <unistd.h> +#include <linux/kd.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <errno.h> +#include <signal.h> + +#ifndef QT_NO_QWS_KEYBOARD + +#include <termios.h> +#include <sys/kd.h> +#include <sys/vt.h> +#include <sys/wait.h> +#include <linux/keyboard.h> + +#define VTSWITCHSIG SIGUSR2 + +static bool vtActive = true; +static int vtQws = 0; +static int kbdFD = -1; + +static QIntDict<QWSServer::KeyMap> *overrideMap = 0; + +/*! + Changes the mapping of the keyboard; adding the scancode to Unicode + mappings from \a map. The server takes over ownership of \a map + and will delete it. Use QCollection::setAutoDelete() to control + whether the contents of \a map should be deleted. + + Passing a null pointer for \a map will revert to the default keymap. +*/ + +void QWSServer::setOverrideKeys( QIntDict<QWSServer::KeyMap> *map ) +{ + delete overrideMap; + overrideMap = map; +} + +/*! + \class QWSKeyboardHandler qkeyboard_qws.h + \brief Keyboard driver/handler for Qt/Embedded + + The keyboard driver/handler handles events from system devices and + generates key events. + + A QWSKeyboardHandler will usually open some system device in its + constructor, create a QSocketNotifier on that opened device and when + it receives data, it will call processKeyEvent() to send the event + to Qt/Embedded for relaying to clients. +*/ + +/*! + Subclasses call this to send a key event. The server may additionally + filter it before sending it on to applications. + + <ul> + <li>\a unicode is the Unicode value for the key, or 0xffff if none is appropriate. + <li>\a keycode is the Qt keycode for the key (see Qt::Key). + for the list of codes). + <li>\a modifiers is the set of modifier keys (see Qt::Modifier). + <li>\a isPress says whether this is a press or a release. + <li>\a autoRepeat says whether this event was generated by an auto-repeat + mechanism, or an actual key press. + </ul> +*/ +void QWSKeyboardHandler::processKeyEvent(int unicode, int keycode, int modifiers, + bool isPress, bool autoRepeat) +{ + qwsServer->processKeyEvent( unicode, keycode, modifiers, isPress, autoRepeat ); +} + + +bool qwsSetKeyboardAutoRepeat( int /* delay */ , int /* period */ ) +{ + return FALSE; +} + +bool qwsGetKeyboardAutoRepeat( int /* delay */ , int /* period */ ) +{ + return FALSE; +} + +void qwsRestoreKeyboardLeds() +{ +} + + + + + +/* + * Virtual framebuffer keyboard driver + */ + +class QWSVFbKeyboardHandler : public QWSKeyboardHandler +{ + Q_OBJECT +public: + QWSVFbKeyboardHandler(); + virtual ~QWSVFbKeyboardHandler(); + + bool isOpen() { return fd > 0; } + +private slots: + void readKeyboardData(); + +private: + QString terminalName; + int fd; + int kbdIdx; + int kbdBufferLen; + unsigned char *kbdBuffer; + QSocketNotifier *notifier; +}; + +#ifndef QT_NO_QWS_VFB +#include "qvfbhdr.h" +extern int qws_display_id; +#endif + +QWSVFbKeyboardHandler::QWSVFbKeyboardHandler() +{ + kbdFD = -1; +#ifndef QT_NO_QWS_VFB + kbdIdx = 0; + kbdBufferLen = sizeof( QVFbKeyData ) * 5; + kbdBuffer = new unsigned char [kbdBufferLen]; + + terminalName = QString(QT_VFB_KEYBOARD_PIPE).arg(qws_display_id); + + if ((kbdFD = open( terminalName.local8Bit(), O_RDWR | O_NDELAY)) < 0) { + qDebug( "Cannot open %s (%s)", terminalName.latin1(), + strerror(errno)); + } else { + // Clear pending input + char buf[2]; + while (read(kbdFD, buf, 1) > 0) { } + + notifier = new QSocketNotifier( kbdFD, QSocketNotifier::Read, this ); + connect(notifier, SIGNAL(activated(int)),this, SLOT(readKeyboardData())); + } +#endif +} + +QWSVFbKeyboardHandler::~QWSVFbKeyboardHandler() +{ +#ifndef QT_NO_QWS_VFB + if ( kbdFD >= 0 ) + close( kbdFD ); + delete [] kbdBuffer; +#endif +} + + +void QWSVFbKeyboardHandler::readKeyboardData() +{ +#ifndef QT_NO_QWS_VFB + int n; + do { + n = read(kbdFD, kbdBuffer+kbdIdx, kbdBufferLen - kbdIdx ); + if ( n > 0 ) + kbdIdx += n; + } while ( n > 0 ); + + int idx = 0; + while ( kbdIdx - idx >= (int)sizeof( QVFbKeyData ) ) { + QVFbKeyData *kd = (QVFbKeyData *)(kbdBuffer + idx); + if ( kd->unicode == 0 && kd->modifiers == 0 && kd->press ) { + // magic exit key + qWarning( "Instructed to quit by Virtual Keyboard" ); + qApp->quit(); + } + processKeyEvent( kd->unicode&0xffff, kd->unicode>>16, + kd->modifiers, kd->press, kd->repeat ); + idx += sizeof( QVFbKeyData ); + } + + int surplus = kbdIdx - idx; + for ( int i = 0; i < surplus; i++ ) + kbdBuffer[i] = kbdBuffer[idx+i]; + kbdIdx = surplus; +#endif +} + + + + +struct termios origTermData; + +static void init_kbd(void) +{ + struct termios termdata; + + tcgetattr( kbdFD, &origTermData ); + tcgetattr( kbdFD, &termdata ); + + ioctl(kbdFD, KDSKBMODE, K_XLATE); + + termdata.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP); + termdata.c_oflag = 0; + termdata.c_cflag = CREAD | CS8; + termdata.c_lflag = 0; + termdata.c_cc[VTIME]=0; + termdata.c_cc[VMIN]=1; + cfsetispeed(&termdata, 9600); + cfsetospeed(&termdata, 9600); + tcsetattr(kbdFD, TCSANOW, &termdata); +} + +static void done_kbd(void) +{ + if (kbdFD >= 0) { + tcsetattr(kbdFD, TCSANOW, &origTermData); + } +} + +static void vtSwitchHandler(int /*sig*/) +{ + if (vtActive) { + qwsServer->enablePainting(false); + qt_screen->save(); + if (ioctl(kbdFD, VT_RELDISP, VT_ACKACQ) == 0) { + vtActive = false; + qwsServer->closeMouse(); + done_kbd(); + } + else { + qwsServer->enablePainting(true); + } + usleep(200000); + } + else { + if (ioctl(kbdFD, VT_RELDISP, VT_ACKACQ) == 0) { + init_kbd(); + qwsServer->enablePainting(true); + vtActive = true; + qt_screen->restore(); + qwsServer->openMouse(); + qwsServer->refresh(); + } + } + signal(VTSWITCHSIG, vtSwitchHandler); +} + + + +class QWSRamsesKbPrivate; +class QWSRamsesKeyboardHandler : public QWSKeyboardHandler +{ +public: + QWSRamsesKeyboardHandler( const QString& ); + virtual ~QWSRamsesKeyboardHandler(); + + virtual void processKeyEvent(int unicode, int keycode, int modifiers, + bool isPress, bool autoRepeat); + +private: + QWSRamsesKbPrivate *d; +}; + + +class QWSRamsesKbPrivate : public QObject +{ + Q_OBJECT +public: + QWSRamsesKbPrivate( QWSRamsesKeyboardHandler *, const QString &device ); + ~QWSRamsesKbPrivate(); + +private slots: + void readKeyboardData(); + +private: + void handleKey(unsigned char code, int n); + + QWSRamsesKeyboardHandler *handler; + char rbuf[255]; + int rptr; +}; + +QWSRamsesKbPrivate::QWSRamsesKbPrivate( QWSRamsesKeyboardHandler *h, const QString &device ) + : handler(h), rptr(0) +{ +#ifdef QT_QWS_DEVFS + kbdFD = ::open(device.isEmpty()?"/dev/vc/2":device.latin1(), O_RDWR|O_NDELAY, 0); +#else + kbdFD = ::open(device.isEmpty()?"/dev/tty2":device.latin1(), O_RDWR|O_NDELAY, 0); +#endif + + if ( kbdFD >= 0 ) { + QSocketNotifier *notifier; + notifier = new QSocketNotifier( kbdFD, QSocketNotifier::Read, this ); + connect( notifier, SIGNAL(activated(int)),this, SLOT(readKeyboardData()) ); + } else { + qDebug( "Cannot open keyboard" ); + } + init_kbd(); + + struct vt_mode vtMode; + ioctl(kbdFD, VT_GETMODE, &vtMode); + + // let us control VT switching + vtMode.mode = VT_PROCESS; + vtMode.relsig = VTSWITCHSIG; + vtMode.acqsig = VTSWITCHSIG; + ioctl(kbdFD, VT_SETMODE, &vtMode); + + struct vt_stat vtStat; + ioctl(kbdFD, VT_GETSTATE, &vtStat); + vtQws = vtStat.v_active; + + signal(VTSWITCHSIG, vtSwitchHandler); +} + +QWSRamsesKbPrivate::~QWSRamsesKbPrivate() +{ + signal(VTSWITCHSIG, 0); + + done_kbd(); + + struct vt_mode vtMode; + ioctl(kbdFD, VT_GETMODE, &vtMode); + /* Mickey says: "Better give up control of VT switching. + * Hey, I really hate that OS-will-reacquire-resources on process-death + * kind of thinking! + */ + vtMode.mode = VT_AUTO; + vtMode.relsig = 0; + vtMode.acqsig = 0; + ioctl(kbdFD, VT_SETMODE, &vtMode); + + ::close(kbdFD); + kbdFD = -1; +} + + +static inline int map_to_modif(int current_map) +{ + int modifiers = 0; + + if (current_map & KG_ALT) + modifiers |= Qt::ALT; + else if (current_map & KG_CTRL) + modifiers |= Qt::CTRL; + else if (current_map & KG_SHIFT) + modifiers |= Qt::SHIFT; + + return modifiers; +} + +struct { + const char *code; + unsigned short qtcode; +} qtesc_lookup[] = { + { "\e[A", Qt::Key_Up }, + { "\e[B", Qt::Key_Down }, + { "\e[C", Qt::Key_Right }, + { "\e[D", Qt::Key_Left }, + { "\e[1~", Qt::Key_Home }, + { "\e[4~", Qt::Key_End }, + { "\e[5~", Qt::Key_PageUp }, + { "\e[6~", Qt::Key_PageDown }, + + { "\e[[A", Qt::Key_F1 }, + { "\e[[B", Qt::Key_F2 }, + { "\e[[C", Qt::Key_F3 }, + { "\e[[D", Qt::Key_F4 }, + { "\e[[E", Qt::Key_F5 }, + { "\e[17~", Qt::Key_F6 }, + { "\e[18~", Qt::Key_F7 }, + { "\e[19~", Qt::Key_F8 }, + { "\e[20~", Qt::Key_F9 }, + { "\e[21~", Qt::Key_F10 }, + { "\e[23~", Qt::Key_F11 }, + { "\e[24~", Qt::Key_F12 }, + + // { "\ex", Qt::FieldExit }, + // { "\er", Qt::FieldReset }, + +}; + +struct { + unsigned char code; + unsigned short qtcode; +} qtkey_lookup[] = { + { 0x08, Qt::Key_Backspace }, + { 0x09, Qt::Key_Tab }, + { 0x0d, Qt::Key_Enter }, + { 0x1b, Qt::Key_Escape }, +}; + +void QWSRamsesKbPrivate::handleKey(unsigned char code, int n) +{ + int qtKeyCode = Qt::Key_unknown; + unsigned int i; + + //qDebug("\nhandleKey %02x %d %c", code, n, code >= ' ' ? code : ' '); + + // Single keys + if ((n==1) && (rptr==0)) { + qtKeyCode = code; + for (i=0; i < sizeof(qtkey_lookup)/sizeof(qtkey_lookup[0]); i++) { + if (qtkey_lookup[i].code == code) { + qtKeyCode = qtkey_lookup[i].qtcode; + code = 0; + break; + } + } + } else + + // Alt-<KEY> sequence + if ((n==1) && (rptr==1) && (rbuf[0] == '\e')) { + //qDebug("alt-key %d", code); + handler->processKeyEvent(0, Qt::Key_Alt, 0, 1, 0); + handler->processKeyEvent(0, code-32, Qt::ALT, 1, 0); + handler->processKeyEvent(0, code-32, Qt::ALT, 0, 0); + handler->processKeyEvent(0, Qt::Key_Alt, 0, 0, 0); + rptr = 0; + return; + } else + + // End of a function key sequence + if ((n==1) && (rptr!=0)) { + rbuf[rptr++] = code; + rbuf[rptr] = 0; + for (i=0; i < sizeof(qtesc_lookup)/sizeof(qtesc_lookup[0]); i++) { + if (strncmp(rbuf, qtesc_lookup[i].code, sizeof(rbuf)) == 0) { + qtKeyCode = qtesc_lookup[i].qtcode; + code = 0; + break; + } + } + if (code != 0) { + //qWarning("no entry in key sequence table for %s", &rbuf[1]); + int oldrptr = rptr; + rptr = 0; + for (i=0; i <= oldrptr; i++) { + handleKey(rbuf[i], 1); + } + return; + } + rptr = 0; + } else + + // Middle of a function key sequence + { + if (rptr < sizeof(rbuf)) + rbuf[rptr++] = code; + return; + } + + //qDebug(" code 0x%2x %d -> qtKeyCode 0x%04x", code, code, qtKeyCode); + + handler->processKeyEvent(code, qtKeyCode, 0, 1, 0); + handler->processKeyEvent(code, qtKeyCode, 0, 0, 0); +} + + +void QWSRamsesKbPrivate::readKeyboardData() +{ + unsigned char buf[81]; + int n = read(kbdFD, buf, 80 ); + for ( int loop = 0; loop < n; loop++ ) { + handleKey(buf[loop], n-loop); + } +} + + + + + +QWSRamsesKeyboardHandler::QWSRamsesKeyboardHandler( const QString &device ) +{ + d = new QWSRamsesKbPrivate( this, device ); +} + +QWSRamsesKeyboardHandler::~QWSRamsesKeyboardHandler() +{ + delete d; +} + +void QWSRamsesKeyboardHandler::processKeyEvent(int unicode, int keycode, + int modifiers, bool isPress, bool autoRepeat) +{ + // Virtual console switching + int term = 0; + bool ctrl = modifiers & Qt::ControlButton; + bool alt = modifiers & Qt::AltButton; + if (ctrl && alt && keycode >= Qt::Key_F1 && keycode <= Qt::Key_F10) + term = keycode - Qt::Key_F1 + 1; + else if (ctrl && alt && keycode == Qt::Key_Left) + term = QMAX(vtQws - 1, 1); + else if (ctrl && alt && keycode == Qt::Key_Right) + term = QMIN(vtQws + 1, 10); + if (term && !isPress) { + ioctl(kbdFD, VT_ACTIVATE, term); + return; + } + + QWSKeyboardHandler::processKeyEvent( unicode, keycode, modifiers, isPress, autoRepeat ); +} + + + +/* + * keyboard driver instantiation + */ + +QWSKeyboardHandler *QWSServer::newKeyboardHandler( const QString &spec ) +{ + QWSKeyboardHandler *handler = 0; + + QString device; + QString type; + int colon=spec.find(':'); + if ( colon>=0 ) { + type = spec.left(colon); + device = spec.mid(colon+1); + } else { + type = spec; + } + + if ( type == "QVFbKeyboard" ) { + handler = new QWSVFbKeyboardHandler(); + } else if ( type == "TTY" ) { + handler = new QWSRamsesKeyboardHandler(device); + } else { + qWarning( "Keyboard type %s:%s unsupported", spec.latin1(), device.latin1() ); + } + + return handler; +} + +#include "qkeyboard_qws.moc" + +#endif // QT_NO_QWS_KEYBOARD + + diff --git a/packages/qte/qte-2.3.10/deprecated/openmn/qkeyboard_qws.h b/packages/qte/qte-2.3.10/deprecated/openmn/qkeyboard_qws.h new file mode 100644 index 0000000000..aa459d1448 --- /dev/null +++ b/packages/qte/qte-2.3.10/deprecated/openmn/qkeyboard_qws.h @@ -0,0 +1,56 @@ +/**************************************************************************** +** $Id: qt/src/kernel/qkeyboard_qws.h 2.3.10 edited 2005-01-24 $ +** +** Definition of Qt/Embedded keyboards +** +** Created : 991025 +** +** Copyright (C) 1992-2000 Trolltech AS. All rights reserved. +** +** This file is part of the kernel module of the Qt GUI Toolkit. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition +** licenses for Qt/Embedded may use this file in accordance with the +** Qt Embedded Commercial License Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about Qt Commercial License Agreements. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef QKEYBOARD_QWS_H +#define QKEYBOARD_QWS_H + +#ifndef QT_H +#include "qobject.h" +#endif // QT_H + +#ifndef QT_NO_QWS_KEYBOARD +class Q_EXPORT QWSKeyboardHandler : public QObject { + Q_OBJECT +public: + QWSKeyboardHandler(); + virtual ~QWSKeyboardHandler(); + +protected: + virtual void processKeyEvent(int unicode, int keycode, int modifiers, + bool isPress, bool autoRepeat); +}; +#endif + +Q_EXPORT bool qwsSetKeyboardAutoRepeat( int delay, int period ); +Q_EXPORT bool qwsGetKeyboardAutoRepeat( int *delay, int *period ); + +#endif |