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

**

** 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 "qmouse_qws.h"

#include "qwindowsystem_qws.h"

#include "qscreen_qws.h"

#include "qapplication.h"

#include "qtextstream.h"

#include "qfile.h"

#include "qdebug.h"

#include "qscreen_qws.h"

QT_BEGIN_NAMESPACE

/*!

    \class QWSPointerCalibrationData

    \ingroup qws

    \brief The QWSPointerCalibrationData class is a container for

    mouse calibration data in Qt for Embedded Linux.

    Note that this class is only available in \l{Qt for Embedded Linux}.

    QWSPointerCalibrationData stores device and screen coordinates in

    the devPoints and screenPoints variables, respectively.

    A calibration program should create a QWSPointerCalibrationData

    object, fill the devPoints and screenPoints variables with its

    device and screen coordinates, and pass the object to the mouse

    driver using the QWSMouseHandler::calibrate() function.

    \sa QWSCalibratedMouseHandler, {Mouse Calibration Example}

*/

/*!

    \variable QWSPointerCalibrationData::devPoints

    \brief the raw device coordinates for each value of the Location enum.

*/

/*!

    \variable QWSPointerCalibrationData::screenPoints

    \brief the logical screen coordinates for each value of the Location enum.

*/

/*!

    \enum QWSPointerCalibrationData::Location

    This enum describes the various logical positions that can be

    specified by the devPoints and screenPoints variables.

    \value TopLeft           Index of the top left corner of the screen.

    \value BottomLeft     Index of the bottom left corner of the screen.

    \value BottomRight   Index of the bottom right corner of the screen.

    \value TopRight         Index of the top right corner of the screen.

    \value Center            Index of the center of the screen.

    \value LastLocation   Last index in the pointer arrays.

*/

class QWSMouseHandlerPrivate

{

public:

    QWSMouseHandlerPrivate() : screen(qt_screen) {}

    const QScreen *screen;

};

/*!

    \class QWSMouseHandler

    \ingroup qws

    \brief The QWSMouseHandler class is a base class for mouse drivers in

    Qt for Embedded Linux.

    Note that this class is only available in \l{Qt for Embedded Linux}.

    \l{Qt for Embedded Linux} provides ready-made drivers for several mouse

    protocols, see the \l{Qt for Embedded Linux Pointer Handling}{pointer

    handling} documentation for details. Custom mouse drivers can be

    implemented by subclassing the QWSMouseHandler class and creating

    a mouse driver plugin (derived from QMouseDriverPlugin).

    The default implementation of the QMouseDriverFactory class

    will automatically detect the plugin, and load the driver into the

    server application at run-time using Qt's \l {How to Create Qt

    Plugins}{plugin system}.

    The mouse driver receives mouse events from the system device and

    encapsulates each event with an instance of the QWSEvent class

    which it then passes to the server application (the server is

    responsible for propagating the event to the appropriate

    client). To receive mouse events, a QWSMouseHandler object will

    usually create a QSocketNotifier object for the given device. The

    QSocketNotifier class provides support for monitoring activity on

    a file descriptor. When the socket notifier receives data, it will

    call the mouse driver's mouseChanged() function to send the event

    to the \l{Qt for Embedded Linux} server application for relaying to

    clients.

    If you are creating a driver for a device that needs calibration

    or noise reduction, such as a touchscreen, use the

    QWSCalibratedMouseHandler subclass instead to take advantage of

    the calibrate() and clearCalibration() functions. The \l

    {qws/mousecalibration}{Mouse Calibration}

    demonstrates how to write a simple program using the mechanisms

    provided by the QWSMouseHandler class to calibrate a mouse driver.

    Note that when deriving from the QWSMouseHandler class, the

    resume() and suspend() functions must be reimplemented to control

    the flow of mouse input, i.e., the default implementation does

    nothing. Reimplementations of these functions typically call the

    QSocketNotifier::setEnabled() function to enable or disable the

    socket notifier, respectively.

    In addition, QWSMouseHandler provides the setScreen() function

    that allows you to specify a screen for your mouse driver and the

    limitToScreen() function that ensures that a given position is

    within this screen's boundaries (changing the position if

    necessary). Finally, QWSMouseHandler provides the pos() function

    returning the current mouse position.

    \sa QMouseDriverPlugin, QMouseDriverFactory, {Qt for Embedded Linux Pointer

    Handling}

*/

/*!

    \fn void QWSMouseHandler::suspend()

    Implement this function to suspend reading and handling of mouse

    events, e.g., call the QSocketNotifier::setEnabled() function to

    disable the socket notifier.

    \sa resume()

*/

/*!

    \fn void QWSMouseHandler::resume()

    Implement this function to resume reading and handling mouse

    events, e.g., call the QSocketNotifier::setEnabled() function to

    enable the socket notifier.

    \sa suspend()

*/

/*!

    \fn const QPoint &QWSMouseHandler::pos() const

    Returns the current mouse position.

    \sa mouseChanged(), limitToScreen()

*/

/*!

    Constructs a mouse driver. The \a driver and \a device arguments

    are passed by the QWS_MOUSE_PROTO environment variable.

    Call the QWSServer::setMouseHandler() function to make the newly

    created mouse driver, the primary driver. Note that the primary

    driver is controlled by the system, i.e., the system will delete

    it upon exit.

*/

QWSMouseHandler::QWSMouseHandler(const QString &, const QString &)

    : mousePos(QWSServer::mousePosition), d_ptr(new QWSMouseHandlerPrivate)

{

}

/*!

    Destroys this mouse driver.

    Do not call this function if this driver is the primary mouse

    driver, i.e., if QWSServer::setMouseHandler() function has been

    called passing this driver as argument. The primary mouse

    driver is deleted by the system.

*/

QWSMouseHandler::~QWSMouseHandler()

{

    delete d_ptr;

}

/*!

    Ensures that the given \a position is within the screen's

    boundaries, changing the \a position if necessary.

    \sa pos(), setScreen()

*/

void QWSMouseHandler::limitToScreen(QPoint &position)

{

    position.setX(qMin(d_ptr->screen->deviceWidth() - 1, qMax(0, position.x())));

    position.setY(qMin(d_ptr->screen->deviceHeight() - 1, qMax(0, position.y())));

}

/*!

    \since 4.2

    Sets the screen for this mouse driver to be the given \a screen.

    \sa limitToScreen()

*/

void QWSMouseHandler::setScreen(const QScreen *screen)

{

    d_ptr->screen = (screen ? screen : qt_screen);

}

/*!

    Notifies the system of a new mouse event.

    This function updates the current mouse position and sends the

    event to the \l{Qt for Embedded Linux} server application for

    delivery to the correct widget. Note that a custom mouse driver must call

    this function whenever it wants to deliver a new mouse event.

    The given \a position is the global position of the mouse cursor.

    The \a state parameter is a bitmask of the Qt::MouseButton enum's

    values, indicating which mouse buttons are pressed. The \a wheel

    parameter is the delta value of the mouse wheel as returned by

    QWheelEvent::delta().

    \sa pos()

*/

void QWSMouseHandler::mouseChanged(const QPoint &position, int state, int wheel)

{

    mousePos = position + d_ptr->screen->offset();

    QWSServer::sendMouseEvent(mousePos, state, wheel);

}

/*!

    \fn QWSMouseHandler::clearCalibration()

    This virtual function allows subclasses of QWSMouseHandler to

    clear the calibration information. Note that the default

    implementation does nothing.

    \sa QWSCalibratedMouseHandler::clearCalibration(), calibrate()

*/

/*!

    \fn QWSMouseHandler::calibrate(const QWSPointerCalibrationData *data)

    This virtual function allows subclasses of QWSMouseHandler to set

    the calibration information passed in the given \a data. Note that

    the default implementation does nothing.

    \sa QWSCalibratedMouseHandler::calibrate(), clearCalibration()

*/

/*! \fn QWSMouseHandler::getCalibration(QWSPointerCalibrationData *data) const

    This virtual function allows subclasses of QWSMouseHandler

    to fill in the device coordinates in \a data with values

    that correspond to screen coordinates that are already in

    \a data. Note that the default implementation does nothing.

 */

/*!

    \class QWSCalibratedMouseHandler

    \ingroup qws

    \brief The QWSCalibratedMouseHandler class provides mouse

    calibration and noise reduction in Qt for Embedded Linux.

    Note that this class is only available in \l{Qt for Embedded Linux}.

    \l{Qt for Embedded Linux} provides ready-made drivers for several mouse

    protocols, see the \l{Qt for Embedded Linux Pointer Handling}{pointer

    handling} documentation for details. In general, custom mouse

    drivers can be implemented by subclassing the QWSMouseHandler

    class. But when the system device does not have a fixed mapping

    between device and screen coordinates and/or produces noisy events

    (e.g., a touchscreen), you should derive from the

    QWSCalibratedMouseHandler class instead to take advantage of its

    calibration functionality. As always, you must also create a mouse

    driver plugin (derived from QMouseDriverPlugin);

    the implementation of the QMouseDriverFactory class will then

    automatically detect the plugin, and load the driver into the

    server application at run-time using Qt's

    \l{How to Create Qt Plugins}{plugin system}.

    QWSCalibratedMouseHandler provides an implementation of the

    calibrate() function to update the calibration parameters based on

    coordinate mapping of the given calibration data. The calibration

    data is represented by an QWSPointerCalibrationData object. The

    linear transformation between device coordinates and screen

    coordinates is performed by calling the transform() function

    explicitly on the points passed to the

    QWSMouseHandler::mouseChanged() function. Use the

    clearCalibration() function to make the mouse driver return mouse

    events in raw device coordinates and not in screen coordinates.

    The calibration parameters are recalculated whenever calibrate()

    is called, and they can be stored using the writeCalibration()

    function. Previously written parameters can be retrieved at any

    time using the readCalibration() function (calibration parameters

    are always read when the class is instantiated). Note that the

    calibration parameters is written to and read from the file

    currently specified by the POINTERCAL_FILE environment variable;

    the default file is \c /etc/pointercal.

    To achieve noise reduction, QWSCalibratedMouseHandler provides the

    sendFiltered() function. Use this function instead of

    mouseChanged() whenever a mouse event occurs. The filter's size

    can be manipulated using the setFilterSize() function.

    \sa QWSMouseHandler, QWSPointerCalibrationData,

    {Mouse Calibration Example}

*/

/*!

    \internal

 */

QWSCalibratedMouseHandler::QWSCalibratedMouseHandler(const QString &, const QString &)

    : samples(5), currSample(0), numSamples(0)

{

    clearCalibration();

    readCalibration();

}

/*!

    Fills \a cd with the device coordinates corresponding to the given

    screen coordinates.

    \internal

*/

void QWSCalibratedMouseHandler::getCalibration(QWSPointerCalibrationData *cd) const

{

    const qint64 scale = qint64(a) * qint64(e) - qint64(b) * qint64(d);

    const qint64 xOff = qint64(b) * qint64(f) - qint64(c) * qint64(e);

    const qint64 yOff = qint64(c) * qint64(d) - qint64(a) * qint64(f);

    for (int i = 0; i <= QWSPointerCalibrationData::LastLocation; ++i) {

        const qint64 sX = cd->screenPoints[i].x();

        const qint64 sY = cd->screenPoints[i].y();

        const qint64 dX = (s*(e*sX - b*sY) + xOff) / scale;

        const qint64 dY = (s*(a*sY - d*sX) + yOff) / scale;

        cd->devPoints[i] = QPoint(dX, dY);

    }

}

/*!

    Clears the current calibration, i.e., makes the mouse

    driver return mouse events in raw device coordinates instead of

    screen coordinates.

    \sa calibrate()

*/

void QWSCalibratedMouseHandler::clearCalibration()

{

    a = 1;

    b = 0;

    c = 0;

    d = 0;

    e = 1;

    f = 0;

    s = 1;

}

/*!

    Saves the current calibration parameters in \c /etc/pointercal

    (separated by whitespace and in alphabetical order).

    You can override the default \c /etc/pointercal by specifying

    another file using the POINTERCAL_FILE environment variable.

    \sa readCalibration()

*/

void QWSCalibratedMouseHandler::writeCalibration()

{

    QString calFile;

    calFile = QString::fromLocal8Bit(qgetenv("POINTERCAL_FILE"));

    if (calFile.isEmpty())

        calFile = QLatin1String("/etc/pointercal");

#ifndef QT_NO_TEXTSTREAM

    QFile file(calFile);

    if (file.open(QIODevice::WriteOnly)) {

        QTextStream t(&file);

        t << a << ' ' << b << ' ' << c << ' ';

        t << d << ' ' << e << ' ' << f << ' ' << s << endl;

    } else

#endif

    {

        qCritical("QWSCalibratedMouseHandler::writeCalibration: "

                  "Could not save calibration into %s", qPrintable(calFile));

    }

}

/*!

    Reads previously written calibration parameters which are stored

    in \c /etc/pointercal (separated by whitespace and in alphabetical

    order).

    You can override the default \c /etc/pointercal by specifying

    another file using the POINTERCAL_FILE environment variable.

    \sa writeCalibration()

*/

void QWSCalibratedMouseHandler::readCalibration()

{

    QString calFile = QString::fromLocal8Bit(qgetenv("POINTERCAL_FILE"));

    if (calFile.isEmpty())

        calFile = QLatin1String("/etc/pointercal");

#ifndef QT_NO_TEXTSTREAM

    QFile file(calFile);

    if (file.open(QIODevice::ReadOnly)) {

        QTextStream t(&file);

        t >> a >> b >> c >> d >> e >> f >> s;

        if (s == 0 || t.status() != QTextStream::Ok) {

            qCritical("Corrupt calibration data");

            clearCalibration();

        }

    } else

#endif

    {

        qDebug() << "Could not read calibration:" <<calFile;

    }

}

static int ilog2(quint32 n)

{

    int result = 0;

    if (n & 0xffff0000) {

        n >>= 16;

        result += 16;

    }

    if (n & 0xff00) {

        n >>= 8;

        result += 8;}

    if (n & 0xf0) {

        n >>= 4;

        result += 4;

    }

    if (n & 0xc) {

        n >>= 2;

        result += 2;

    }

    if (n & 0x2)

        result += 1;

    return result;

}

/*!

    Updates the calibration parameters based on coordinate mapping of

    the given \a data.

    Create an instance of the QWSPointerCalibrationData class, fill in

    the device and screen coordinates and pass that object to the mouse

    driver using this function.

    \sa clearCalibration(), transform()

*/

void QWSCalibratedMouseHandler::calibrate(const QWSPointerCalibrationData *data)

{

    // Algorithm derived from

    // "How To Calibrate Touch Screens" by Carlos E. Vidales,

    // printed in Embedded Systems Programming, Vol. 15 no 6, June 2002

    // URL: http://www.embedded.com/showArticle.jhtml?articleID=9900629

    const QPoint pd0 = data->devPoints[QWSPointerCalibrationData::TopLeft];

    const QPoint pd1 = data->devPoints[QWSPointerCalibrationData::TopRight];

    const QPoint pd2 = data->devPoints[QWSPointerCalibrationData::BottomRight];

    const QPoint p0 = data->screenPoints[QWSPointerCalibrationData::TopLeft];

    const QPoint p1 = data->screenPoints[QWSPointerCalibrationData::TopRight];

    const QPoint p2 = data->screenPoints[QWSPointerCalibrationData::BottomRight];

    const qint64 xd0 = pd0.x();

    const qint64 xd1 = pd1.x();

    const qint64 xd2 = pd2.x();

    const qint64 yd0 = pd0.y();

    const qint64 yd1 = pd1.y();

    const qint64 yd2 = pd2.y();

    const qint64 x0 = p0.x();

    const qint64 x1 = p1.x();

    const qint64 x2 = p2.x();

    const qint64 y0 = p0.y();

    const qint64 y1 = p1.y();

    const qint64 y2 = p2.y();

    qint64 scale = ((xd0 - xd2)*(yd1 - yd2) - (xd1 - xd2)*(yd0 - yd2));

    int shift = 0;

    qint64 absScale = qAbs(scale);

    // use maximum 16 bit precision to reduce risk of integer overflow

    if (absScale > (1 << 16)) {

        shift = ilog2(absScale >> 16) + 1;

        scale >>= shift;

    }