/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qmousepc_qws.h"

#ifndef QT_NO_QWS_MOUSE_PC

#include "qwindowsystem_qws.h"

#include "qsocketnotifier.h"

#include "qwsevent_qws.h"

#include "qwscommand_qws_p.h"

#include "qwsutils_qws.h"

#include "qapplication.h"

#include "qpolygon.h"

#include "qtimer.h"

#include "qfile.h"

#include "qtextstream.h"

#include "qstringlist.h"

#include <private/qcore_unix_p.h> // overrides QT_OPEN

#include <unistd.h>

#include <stdlib.h>

#include <stdio.h>

#include <sys/ioctl.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <errno.h>

#include <termios.h>

#include <qscreen_qws.h>

QT_BEGIN_NAMESPACE

//#define QWS_MOUSE_DEBUG

/*

 * Automatic-detection mouse driver

 */

class QWSPcMouseSubHandler {

protected:

    enum { max_buf=32 };

    int fd;

    uchar buffer[max_buf];

    int nbuf;

    QPoint motion;

    int bstate;

    int wheel;

    int goodness;

    int badness;

    virtual int tryData()=0;

public:

    QWSPcMouseSubHandler(int f) : fd(f)

    {

        initState();

    }

    virtual ~QWSPcMouseSubHandler() {}

    int file() const { return fd; }

    void closeIfNot(int& f)

    {

        if (fd != f) {

            f = fd;

            QT_CLOSE(fd);

        }

    }

    void initState() { nbuf = bstate = goodness = badness = 0; }

    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; }

    int takeWheel() { int result = wheel; wheel = 0; return result; }

    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();

#ifdef QWS_MOUSE_DEBUG

        if (n) {

            fprintf(stderr, "QWSPcMouseSubHandler tryData read %d bytes:", n);

            for (int i=0; i<n; ++i)

                fprintf(stderr, " %02x", buffer[i]);

            fprintf(stderr, "\n");

        }

#endif

        if (n > 0) {

            if (n<nbuf)

                memmove(buffer, buffer+n, nbuf-n);

            nbuf -= n;

            return (wheel || pbstate != bstate) ? Button : Motion;

        }

        return Insufficient;

    }

};

class QWSPcMouseSubHandler_intellimouse : public QWSPcMouseSubHandler {

    int packetsize;

public:

    QWSPcMouseSubHandler_intellimouse(int f) : QWSPcMouseSubHandler(f)

    {

        init();

    }

    void init()

    {

        int n;

        uchar reply[20];

        if (tcflush(fd,TCIOFLUSH) == -1) {

#ifdef QWS_MOUSE_DEBUG

            perror("QWSPcMouseSubHandler_intellimouse: pre-init tcflush");

#endif

        }

        static const uchar initseq[] = { 243, 200, 243, 100, 243, 80 };

        static const uchar query[] = { 0xf2 };

        if (QT_WRITE(fd, initseq, sizeof(initseq))!=sizeof(initseq)) {

            badness = 100;

            return;

        }

        usleep(10000);

        if (tcflush(fd,TCIOFLUSH) == -1) {

#ifdef QWS_MOUSE_DEBUG

            perror("QWSPcMouseSubHandler_intellimouse: post-init tcflush");

#endif

        }

        if (QT_WRITE(fd, query, sizeof(query))!=sizeof(query)) {

            badness = 100;

            return;

        }

        usleep(10000);

        n = QT_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)) {

#ifdef QWS_MOUSE_DEBUG

                qDebug("Intellimouse: skipping (overflow)");

#endif

                badness++;

                return 1;

            } else {

                QPoint delta((buffer[0] & 0x10) ? buffer[1]-256 : buffer[1],

                       (buffer[0] & 0x20) ? 256-buffer[2] : -buffer[2]);

                motion += delta;

                int nbstate = buffer[0] & 0x7;

#ifdef QWS_MOUSE_DEBUG

                int debugwheel =

#endif

                wheel = packetsize > 3 ? -(signed char)buffer[3] : 0;

                if (wheel < -2 || wheel > 2)

                    wheel = 0;

                wheel *= 120; // WHEEL_DELTA?

#ifdef QWS_MOUSE_DEBUG

                qDebug("Intellimouse: motion %d,%d, state %d, raw wheel %d, wheel %d", motion.x(), motion.y(), nbstate, debugwheel, wheel);

#endif

                if (motion.x() || motion.y() || bstate != nbstate || wheel) {

                    bstate = nbstate;

                    goodness++;

                } else {

                    badness++;

                    return 1;

                }

            }

            return packetsize;

        }

        return 0;

    }

};

class QWSPcMouseSubHandler_mouseman : public QWSPcMouseSubHandler {

    int packetsize;

public:

    QWSPcMouseSubHandler_mouseman(int f) : QWSPcMouseSubHandler(f)

    {

        init();

    }

    void init()

    {

        if (tcflush(fd,TCIOFLUSH) == -1) {

#ifdef QWS_MOUSE_DEBUG

            perror("QWSPcMouseSubHandler_mouseman: initial tcflush");

#endif

        }

        QT_WRITE(fd,"",1);

        usleep(50000);

        QT_WRITE(fd,"@EeI!",5);

        usleep(10000);

        static const char ibuf[] = { 246, 244 };

        QT_WRITE(fd,ibuf,1);

        QT_WRITE(fd,ibuf+1,1);

        if (tcflush(fd,TCIOFLUSH) == -1) {

#ifdef QWS_MOUSE_DEBUG

            perror("QWSPcMouseSubHandler_mouseman: tcflush");

#endif

        }

        usleep(10000);

        char buf[100];

        while (QT_READ(fd, buf, 100) > 0) { }  // eat unwanted replies

    }

    int tryData()

    {

        if (nbuf >= 3) {

            int nbstate = 0;

            if (buffer[0] & 0x01)

                nbstate |= Qt::LeftButton;

            if (buffer[0] & 0x02)

                nbstate |= Qt::RightButton;

            if (buffer[0] & 0x04)

                nbstate |= Qt::MidButton;

            int overflow = (buffer[0]>>6)& 0x03;

            if (overflow) {

                //### wheel events signalled with overflow bit, ignore for now

                badness++;

                return 1;

            } else {

                bool xs = buffer[0] & 0x10;

                bool ys = buffer[0] & 0x20;

                int dx = xs ? buffer[1]-256 : buffer[1];

                int dy = ys ? buffer[2]-256 : buffer[2];

                motion += QPoint(dx, -dy);

                if (motion.x() || motion.y() || bstate != nbstate) {

                    bstate = nbstate;

                    goodness++;

                } else {

                    badness++;

                    return 1;

                }

            }

            return 3;

        }

        return 0;

    }

};

class QWSPcMouseSubHandler_serial : public QWSPcMouseSubHandler {

public:

    QWSPcMouseSubHandler_serial(int f) : QWSPcMouseSubHandler(f)

    {

        initSerial();

    }

protected:

    void setflags(int f)

    {

        termios tty;

        if (tcgetattr(fd, &tty) == -1) {

#ifdef QWS_MOUSE_DEBUG

            perror("QWSPcMouseSubHandler_serial: tcgetattr");

#endif

        }

        tty.c_iflag     = IGNBRK | IGNPAR;

        tty.c_oflag     = 0;

        tty.c_lflag     = 0;

        tty.c_cflag     = f | CREAD | CLOCAL | HUPCL;

#ifdef Q_OS_LINUX

        tty.c_line      = 0;

#endif

        tty.c_cc[VTIME] = 0;

        tty.c_cc[VMIN]  = 1;

        if (tcsetattr(fd, TCSANOW, &tty) == -1) {

#ifdef QWS_MOUSE_DEBUG

            perror("QWSPcMouseSubHandler_serial: tcgetattr");

#endif

        }

    }

private:

    void initSerial()

    {

        int speed[4] = { B9600, B4800, B2400, B1200 };

        for (int n = 0; n < 4; n++) {

            setflags(CSTOPB | speed[n]);

            QT_WRITE(fd, "*q", 2);

            usleep(10000);

        }

    }

};

class QWSPcMouseSubHandler_mousesystems : public QWSPcMouseSubHandler_serial {

public:

    // ##### This driver has not been tested

    QWSPcMouseSubHandler_mousesystems(int f) : QWSPcMouseSubHandler_serial(f)

    {

        init();

    }

    void init()

    {

        setflags(B1200|CS8|CSTOPB);

        // 60Hz

        if (QT_WRITE(fd, "R", 1)!=1) {

            badness = 100;

            return;

        }

        if (tcflush(fd,TCIOFLUSH) == -1) {

#ifdef QT_QWS_VNC_DEBUG

            perror("QWSPcMouseSubHandler_mousesystems: tcflush");

#endif

        }

    }

    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 QWSPcMouseSubHandler_ms : public QWSPcMouseSubHandler_serial {

    int mman;

public:

    QWSPcMouseSubHandler_ms(int f) : QWSPcMouseSubHandler_serial(f)

    {

        mman=0;

        init();

    }

    void init()

    {

        setflags(B1200|CS7);

        // 60Hz

        if (QT_WRITE(fd, "R", 1)!=1) {

            badness = 100;

            return;

        }

        if (tcflush(fd,TCIOFLUSH) == -1) {

#ifdef QWS_MOUSE_DEBUG

            perror("QWSPcMouseSubHandler_ms: tcflush");

#endif

        }

    }

    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;

    }

};

//===========================================================================

class QWSPcMouseHandlerPrivate : public QObject

{

    Q_OBJECT

public:

    QWSPcMouseHandlerPrivate(QWSPcMouseHandler *h, const QString &, const QString &);

    ~QWSPcMouseHandlerPrivate();

    void suspend();

    void resume();

private:

    enum { max_dev=32 };

    QWSPcMouseSubHandler *sub[max_dev];

    QList<QSocketNotifier*> notifiers;

    int nsub;

    int retries;

private slots:

    void readMouseData(int);

private:

    void openDevices();

    void closeDevices();

    void notify(int fd);

    bool sendEvent(QWSPcMouseSubHandler& h);

private:

    QWSPcMouseHandler *handler;

    QString driver;

    QString device;

    qreal accel;

    int accel_limit;

};

QWSPcMouseHandler::QWSPcMouseHandler(const QString &driver, const QString &device)

    : QWSMouseHandler(driver, device)

{

    d = new QWSPcMouseHandlerPrivate(this, driver, device);

}

QWSPcMouseHandler::~QWSPcMouseHandler()

{

    delete d;

}

void QWSPcMouseHandler::suspend()

{

    d->suspend();

}

void QWSPcMouseHandler::resume()

{