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

**

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

#ifndef QT_NO_QWS_VNC

#include "qscreenvnc_p.h"

#include "qwindowsystem_qws.h"

#include "qwsdisplay_qws.h"

#include "qscreendriverfactory_qws.h"

#include <QtCore/qtimer.h>

#include <QtCore/qregexp.h>

#include <QtGui/qwidget.h>

#include <QtGui/qpolygon.h>

#include <QtGui/qpainter.h>

#include <qdebug.h>

#include <private/qwindowsurface_qws_p.h>

#include <private/qwssignalhandler_p.h>

#include <private/qwidget_p.h>

#include <private/qdrawhelper_p.h>

#include <stdlib.h>

QT_BEGIN_NAMESPACE

//#define QT_QWS_VNC_DEBUG

extern QString qws_qtePipeFilename();

#ifndef QT_NO_QWS_CURSOR

QVNCCursor::QVNCCursor(QVNCScreen *s)

    : screen(s)

{

    if (qt_screencursor)

        setScreenCursor(qt_screencursor);

    else

        hwaccel = true;

}

QVNCCursor::~QVNCCursor()

{

    if (screenCursor())

        qt_screencursor = screenCursor();

}

void QVNCCursor::setDirty(const QRect &r) const

{

    screen->d_ptr->setDirty(r, true);

}

void QVNCCursor::hide()

{

    QProxyScreenCursor::hide();

    if (enable)

        setDirty(boundingRect());

}

void QVNCCursor::show()

{

    QProxyScreenCursor::show();

    if (enable)

        setDirty(boundingRect());

}

void QVNCCursor::set(const QImage &image, int hotx, int hoty)

{

    QRegion dirty = boundingRect();

    QProxyScreenCursor::set(image, hotx, hoty);

    dirty |= boundingRect();

    if (enable && hwaccel && !screen->d_ptr->vncServer->hasClientCursor()) {

        const QVector<QRect> rects = dirty.rects();

        for (int i = 0; i < rects.size(); ++i)

            setDirty(rects.at(i));

    }

}

void QVNCCursor::move(int x, int y)

{

    if (enable && hwaccel && !screen->d_ptr->vncServer->hasClientCursor()) {

        QRegion dirty = boundingRect();

        QProxyScreenCursor::move(x, y);

        dirty |= boundingRect();

        if (enable) {

            const QVector<QRect> rects = dirty.rects();

            for (int i = 0; i < rects.size(); ++i)

                setDirty(rects.at(i));

        }

    } else {

        QProxyScreenCursor::move(x, y);

    }

}

QVNCClientCursor::QVNCClientCursor(QVNCServer *s)

    : server(s)

{

    setScreenCursor(qt_screencursor);

    Q_ASSERT(hwaccel);

    qt_screencursor = this; // hw: XXX

    set(image(), hotspot.x(), hotspot.y());

}

QVNCClientCursor::~QVNCClientCursor()

{

    qt_screencursor = screenCursor();

}

void QVNCClientCursor::set(const QImage &image, int hotx, int hoty)

{

    QScreenCursor::set(image, hotx, hoty);

    server->setDirtyCursor();

}

void QVNCClientCursor::write() const

{

    QTcpSocket *socket = server->clientSocket();

    // FramebufferUpdate header

    {

        const quint16 tmp[6] = { htons(0),

                                 htons(1),

                                 htons(hotspot.x()), htons(hotspot.y()),

                                 htons(cursor.width()),

                                 htons(cursor.height()) };

        socket->write((char*)tmp, sizeof(tmp));

        const quint32 encoding = htonl(-239);

        socket->write((char*)(&encoding), sizeof(encoding));

    }

    if (cursor.isNull())

        return;

    // write pixels

    Q_ASSERT(cursor.hasAlphaChannel());

    const QImage img = cursor.convertToFormat(server->screen()->pixelFormat());

    const int n = server->clientBytesPerPixel() * img.width();

    char *buffer = new char[n];

    for (int i = 0; i < img.height(); ++i) {

        server->convertPixels(buffer, (const char*)img.scanLine(i), img.width());

        socket->write(buffer, n);

    }

    delete[] buffer;

    // write mask

    const QImage bitmap = cursor.createAlphaMask().convertToFormat(QImage::Format_Mono);

    Q_ASSERT(bitmap.depth() == 1);

    Q_ASSERT(bitmap.size() == img.size());

    const int width = (bitmap.width() + 7) / 8;

    for (int i = 0; i < bitmap.height(); ++i)

        socket->write((const char*)bitmap.scanLine(i), width);

}

#endif // QT_NO_QWS_CURSOR

QVNCScreenPrivate::QVNCScreenPrivate(QVNCScreen *parent)

    : dpiX(72), dpiY(72), doOnScreenSurface(false), refreshRate(25),

      vncServer(0), q_ptr(parent), noDisablePainting(false)

{

#ifdef QT_BUILD_INTERNAL

    noDisablePainting = (qgetenv("QT_VNC_NO_DISABLEPAINTING").toInt() > 0);

#endif

#ifndef QT_NO_QWS_SIGNALHANDLER

    QWSSignalHandler::instance()->addObject(this);

#endif

}

QVNCScreenPrivate::~QVNCScreenPrivate()

{

#if defined(QT_NO_QWS_MULTIPROCESS) || defined(QT_NO_SHAREDMEMORY)

    if (q_ptr->screen())

        return;

    delete[] q_ptr->data;

    q_ptr->data = 0;

#else

    shm.detach();

#endif

}

void QVNCScreenPrivate::configure()

{

    if (q_ptr->screen())

        return;

    q_ptr->lstep = q_ptr->dw * ((q_ptr->d + 7) / 8);

    q_ptr->size = q_ptr->h * q_ptr->lstep;

    q_ptr->mapsize = q_ptr->size;

    q_ptr->physWidth = qRound(q_ptr->dw * qreal(25.4) / dpiX);

    q_ptr->physHeight = qRound(q_ptr->dh * qreal(25.4) / dpiY);

    switch (q_ptr->d) {

    case 1:

        q_ptr->setPixelFormat(QImage::Format_Mono); //### LSB???

        break;

    case 8:

        q_ptr->setPixelFormat(QImage::Format_Indexed8);

        break;

    case 12:

        q_ptr->setPixelFormat(QImage::Format_RGB444);

        break;

    case 15:

        q_ptr->setPixelFormat(QImage::Format_RGB555);

        break;

    case 16:

        q_ptr->setPixelFormat(QImage::Format_RGB16);

        break;

    case 18:

        q_ptr->setPixelFormat(QImage::Format_RGB666);

        break;

    case 24:

        q_ptr->setPixelFormat(QImage::Format_RGB888);

        break;

    case 32:

        q_ptr->setPixelFormat(QImage::Format_ARGB32_Premultiplied);

        break;

    }

#if !defined(QT_NO_QWS_MULTIPROCESS) && !defined(QT_NO_SHAREDMEMORY)

    if (q_ptr->size != shm.size()) {

        shm.detach();

        const QString key = qws_qtePipeFilename() +

                            QString().sprintf("_vnc_%d_%d",

                                              q_ptr->displayId, q_ptr->size);

        shm.setKey(key);

        if (QApplication::type() == QApplication::GuiServer) {

            if (!shm.create(q_ptr->size)) {

                qWarning() << "QVNCScreen could not create shared memory:"

                           << shm.errorString();

                if (!shm.attach()) {

                    qWarning() << "QVNCScreen could not attach to shared memory:"

                               << shm.errorString();

                }

            }

        } else if (!shm.attach()) {

            qWarning() << "QVNCScreen could not attach to shared memory:"

                       << shm.errorString();

        }

        q_ptr->data = reinterpret_cast<uchar*>(shm.data());

    }

#else

    if (q_ptr->data)

        delete[] q_ptr->data;

    q_ptr->data = new uchar[q_ptr->size];

#endif

}

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

static const struct {

    int keysym;

    int keycode;

} keyMap[] = {

    { 0xff08, Qt::Key_Backspace },

    { 0xff09, Qt::Key_Tab       },

    { 0xff0d, Qt::Key_Return    },

    { 0xff1b, Qt::Key_Escape    },

    { 0xff63, Qt::Key_Insert    },

    { 0xffff, Qt::Key_Delete    },

    { 0xff50, Qt::Key_Home      },

    { 0xff57, Qt::Key_End       },

    { 0xff55, Qt::Key_PageUp    },

    { 0xff56, Qt::Key_PageDown  },

    { 0xff51, Qt::Key_Left      },

    { 0xff52, Qt::Key_Up        },

    { 0xff53, Qt::Key_Right     },

    { 0xff54, Qt::Key_Down      },

    { 0xffbe, Qt::Key_F1        },

    { 0xffbf, Qt::Key_F2        },

    { 0xffc0, Qt::Key_F3        },

    { 0xffc1, Qt::Key_F4        },

    { 0xffc2, Qt::Key_F5        },

    { 0xffc3, Qt::Key_F6        },

    { 0xffc4, Qt::Key_F7        },

    { 0xffc5, Qt::Key_F8        },

    { 0xffc6, Qt::Key_F9        },

    { 0xffc7, Qt::Key_F10       },

    { 0xffc8, Qt::Key_F11       },

    { 0xffc9, Qt::Key_F12       },

    { 0xffe1, Qt::Key_Shift     },

    { 0xffe2, Qt::Key_Shift     },

    { 0xffe3, Qt::Key_Control   },

    { 0xffe4, Qt::Key_Control   },

    { 0xffe7, Qt::Key_Meta      },

    { 0xffe8, Qt::Key_Meta      },

    { 0xffe9, Qt::Key_Alt       },

    { 0xffea, Qt::Key_Alt       },

    { 0, 0 }

};

void QRfbRect::read(QTcpSocket *s)

{

    quint16 buf[4];

    s->read((char*)buf, 8);

    x = ntohs(buf[0]);

    y = ntohs(buf[1]);

    w = ntohs(buf[2]);

    h = ntohs(buf[3]);

}

void QRfbRect::write(QTcpSocket *s) const

{

    quint16 buf[4];

    buf[0] = htons(x);

    buf[1] = htons(y);

    buf[2] = htons(w);

    buf[3] = htons(h);

    s->write((char*)buf, 8);

}

void QRfbPixelFormat::read(QTcpSocket *s)

{

    char buf[16];

    s->read(buf, 16);

    bitsPerPixel = buf[0];

    depth = buf[1];

    bigEndian = buf[2];

    trueColor = buf[3];

    quint16 a = ntohs(*(quint16 *)(buf + 4));

    redBits = 0;

    while (a) { a >>= 1; redBits++; }

    a = ntohs(*(quint16 *)(buf + 6));

    greenBits = 0;

    while (a) { a >>= 1; greenBits++; }

    a = ntohs(*(quint16 *)(buf + 8));

    blueBits = 0;

    while (a) { a >>= 1; blueBits++; }

    redShift = buf[10];

    greenShift = buf[11];

    blueShift = buf[12];

}

void QRfbPixelFormat::write(QTcpSocket *s)

{

    char buf[16];

    buf[0] = bitsPerPixel;

    buf[1] = depth;

    buf[2] = bigEndian;

    buf[3] = trueColor;

    quint16 a = 0;

    for (int i = 0; i < redBits; i++) a = (a << 1) | 1;

    *(quint16 *)(buf + 4) = htons(a);

    a = 0;

    for (int i = 0; i < greenBits; i++) a = (a << 1) | 1;

    *(quint16 *)(buf + 6) = htons(a);

    a = 0;

    for (int i = 0; i < blueBits; i++) a = (a << 1) | 1;

    *(quint16 *)(buf + 8) = htons(a);

    buf[10] = redShift;

    buf[11] = greenShift;

    buf[12] = blueShift;

    s->write(buf, 16);

}

void QRfbServerInit::setName(const char *n)

{

    delete[] name;

    name = new char [strlen(n) + 1];

    strcpy(name, n);

}

void QRfbServerInit::read(QTcpSocket *s)

{

    s->read((char *)&width, 2);

    width = ntohs(width);

    s->read((char *)&height, 2);

    height = ntohs(height);

    format.read(s);

    quint32 len;

    s->read((char *)&len, 4);

    len = ntohl(len);

    name = new char [len + 1];

    s->read(name, len);

    name[len] = '\0';

}

void QRfbServerInit::write(QTcpSocket *s)

{

    quint16 t = htons(width);

    s->write((char *)&t, 2);

    t = htons(height);

    s->write((char *)&t, 2);

    format.write(s);

    quint32 len = strlen(name);

    len = htonl(len);

    s->write((char *)&len, 4);

    s->write(name, strlen(name));

}

bool QRfbSetEncodings::read(QTcpSocket *s)

{

    if (s->bytesAvailable() < 3)

        return false;

    char tmp;

    s->read(&tmp, 1);        // padding

    s->read((char *)&count, 2);

    count = ntohs(count);

    return true;

}

bool QRfbFrameBufferUpdateRequest::read(QTcpSocket *s)

{

    if (s->bytesAvailable() < 9)

        return false;

    s->read(&incremental, 1);

    rect.read(s);

    return true;

}

bool QRfbKeyEvent::read(QTcpSocket *s)

{

    if (s->bytesAvailable() < 7)

        return false;

    s->read(&down, 1);

    quint16 tmp;

    s->read((char *)&tmp, 2);  // padding

    quint32 key;

    s->read((char *)&key, 4);

    key = ntohl(key);

    unicode = 0;

    keycode = 0;

    int i = 0;

    while (keyMap[i].keysym && !keycode) {

        if (keyMap[i].keysym == (int)key)

            keycode = keyMap[i].keycode;

        i++;

    }

    if (!keycode) {

        if (key <= 0xff) {

            unicode = key;

            if (key >= 'a' && key <= 'z')

                keycode = Qt::Key_A + key - 'a';

            else if (key >= ' ' && key <= '~')

                keycode = Qt::Key_Space + key - ' ';

        }

    }

    return true;

}

bool QRfbPointerEvent::read(QTcpSocket *s)

{

    if (s->bytesAvailable() < 5)

        return false;

    char buttonMask;

    s->read(&buttonMask, 1);

    buttons = 0;

    if (buttonMask & 1)

        buttons |= Qt::LeftButton;

    if (buttonMask & 2)

        buttons |= Qt::MidButton;

    if (buttonMask & 4)

        buttons |= Qt::RightButton;

    quint16 tmp;

    s->read((char *)&tmp, 2);

    x = ntohs(tmp);

    s->read((char *)&tmp, 2);

    y = ntohs(tmp);

    return true;

}

bool QRfbClientCutText::read(QTcpSocket *s)

{

    if (s->bytesAvailable() < 7)

        return false;

    char tmp[3];