/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the tools applications 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 "qvfbview.h"
#include "qvfbshmem.h"
#include "qvfbmmap.h"

#include "qanimationwriter.h"
#include <QApplication>
#include <QPainter>
#include <QImage>
#include <QBitmap>
#include <QMatrix>
#include <QPaintEvent>
#include <QScrollArea>
#include <QFile>
#include <QDebug>

#ifdef Q_WS_X11
#include <QX11EmbedContainer>
#include <QHBoxLayout>
#endif

#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/sem.h>
#include <fcntl.h>
#include <errno.h>
#include <math.h>

QT_BEGIN_NAMESPACE

extern int qvfb_protocol;

QVFbAbstractView::QVFbAbstractView( QWidget *parent )
#ifdef QVFB_USE_GLWIDGET
    : QGLWidget( parent )
#else
    : QWidget( parent )
#endif
{
}

QVFbAbstractView::~QVFbAbstractView()
{
}

QVFbView::QVFbView(int id, int w, int h, int d, Rotation r, QWidget *parent)
        : QVFbAbstractView(parent),
          viewdepth(d), viewFormat(DefaultFormat), rgb_swapped(0), rsh(0), gsh(0), bsh(0), rmax(15), gmax(15), bmax(15),
        contentsWidth(w), contentsHeight(h), gred(1.0), ggreen(1.0), gblue(1.0),
        gammatable(0), refreshRate(30), animation(0),
        hzm(0.0), vzm(0.0), mView(0),
        emulateTouchscreen(false), emulateLcdScreen(false), rotation(r)
#ifdef Q_WS_X11
        , embedContainer(0)
#endif
{
    switch(qvfb_protocol) {
    default:
    case 0:
        mView = new QShMemViewProtocol(id, QSize(w, h), d, this);
        break;
    case 1:
        mView = new QMMapViewProtocol(id, QSize(w, h), d, this);
        break;
    }

    connect(mView, SIGNAL(displayDataChanged(const QRect &)),
            SLOT(refreshDisplay(const QRect &)));
#ifdef Q_WS_X11
    connect(mView, SIGNAL(displayEmbedRequested(WId)),
            this, SLOT(embedDisplay(WId)));
#endif

    setAttribute(Qt::WA_PaintOnScreen, viewFormat != ARGBFormat);
    setMouseTracking(true);
    setFocusPolicy(Qt::StrongFocus);
    setAttribute(Qt::WA_NoSystemBackground);

    setZoom(1.0,1.0);

    setGamma(1.0,1.0,1.0);
    mView->setRate(30);
}

QVFbView::~QVFbView()
{
    stopAnimation();
    sendKeyboardData(0, 0, 0, true, false); // magic die key
#ifdef Q_WS_X11
    delete embedContainer;
#endif
}

QSize QVFbView::sizeHint() const
{
    return QSize(contentsWidth, contentsHeight);
}

void QVFbView::setRate(int i)
{
    mView->setRate(i);
}

void QVFbView::setGamma(double gr, double gg, double gb)
{
    gred = gr; ggreen = gg; gblue = gb;

    switch (viewdepth) {
    case 12:
	rsh = 12;
	gsh = 7;
	bsh = 1;
	rmax = 15;
	gmax = 15;
	bmax = 15;
	break;
    case 15:
        rsh = 10;
        gsh = 5;
        bsh = 0;
        rmax = 31;
        gmax = 31;
        bmax = 31;
        break;
    case 16:
	rsh = 11;
	gsh = 5;
	bsh = 0;
	rmax = 31;
	gmax = 63;
	bmax = 31;
	break;
    case 18:
        rsh = 12;
        gsh = 6;
        bsh = 0;
        rmax = 63;
        gmax = 63;
        bmax = 63;
        break;
    case 24:
    case 32:
	rsh = 16;
	gsh = 8;
	bsh = 0;
	rmax = 255;
	gmax = 255;
	bmax = 255;
    }
    int mm = qMax(rmax,qMax(gmax,bmax))+1;
    if (gammatable)
	delete [] gammatable;
    gammatable = new QRgb[mm];
    for (int i=0; i<mm; i++) {
	int r = int(pow(i,gr)*255/rmax);
	int g = int(pow(i,gg)*255/gmax);
	int b = int(pow(i,gb)*255/bmax);
	if (r > 255) r = 255;
	if (g > 255) g = 255;
	if (b > 255) b = 255;
	gammatable[i] = qRgb(r,g,b);
//qDebug("%d: %d,%d,%d",i,r,g,b);
    }

    mView->flushChanges();
}

void QVFbView::getGamma(int i, QRgb& rgb)
{
    if (i > 255) i = 255;
    if (i < 0) i = 0;
    rgb = qRgb(qRed(gammatable[i*rmax/255]),
               qGreen(gammatable[i*rmax/255]),
               qBlue(gammatable[i*rmax/255]));
}

int QVFbView::displayId() const
{
    return mView->id();
}

int QVFbView::displayWidth() const
{
    return mView->width();
}

int QVFbView::displayHeight() const
{
    return mView->height();
}

int QVFbView::displayDepth() const
{
    return viewdepth;
}

QVFbView::PixelFormat QVFbView::displayFormat() const
{
    return viewFormat;
}

QVFbView::Rotation QVFbView::displayRotation() const
{
    return rotation;
}

void QVFbView::setZoom(double hz, double vz)
{
    if (hzm != hz || vzm != vz) {
	hzm = hz;
	vzm = vz;
        mView->flushChanges();

        contentsWidth = int(displayWidth()*hz);
        contentsHeight = int(displayHeight()*vz);
        if (rotation & 1)
            qSwap(contentsWidth,contentsHeight);
        resize(contentsWidth, contentsHeight);

        if (isVisible()) {
            updateGeometry();
            qApp->sendPostedEvents();
            topLevelWidget()->adjustSize();
            update();
        }
    }
}

void QVFbView::setRotation(QVFbView::Rotation r)
{
    rotation = r;
    // Force update...
    double ohzm = hzm;
    hzm=0.0;
    setZoom(ohzm,vzm);
}

static QRect mapToDevice(const QRect &r, const QSize &s, QVFbView::Rotation rotation)
{
    int x1 = r.x();
    int y1 = r.y();
    int x2 = r.right();
    int y2 = r.bottom();
    int w = s.width();
    int h = s.height();
    switch (rotation) {
    case QVFbView::Rot90:
        return QRect(
            QPoint(y1, w - x1),
            QPoint(y2, w - x2)).normalized();
    case QVFbView::Rot180:
        return QRect(
            QPoint(w - x1, h - y1),
            QPoint(w - x2, h - y2)).normalized();
    case QVFbView::Rot270:
        return QRect(
            QPoint(h - y1, x1),
            QPoint(h - y2, x2)).normalized();
    default:
        break;
    }
    return r;
}

static QRect mapFromDevice(const QRect &r, const QSize &s, QVFbView::Rotation rotation)
{
    return mapToDevice(r,s,QVFbView::Rotation(4-(int)rotation));
}

void QVFbView::sendMouseData(const QPoint &pos, int buttons, int wheel)
{
    QPoint p = mapToDevice(QRect(pos,QSize(1,1)), QSize(int(width()/hzm), int(height()/vzm)), rotation).topLeft();
    mView->sendMouseData(p, buttons, wheel);
}

void QVFbView::sendKeyboardData(QString unicode, int keycode, int modifiers,
				 bool press, bool repeat)
{
    mView->sendKeyboardData(unicode, keycode, modifiers, press, repeat);
}

void QVFbView::refreshDisplay(const QRect &r)
{
    if (animation) {
        if (r.isEmpty()) {
            animation->appendBlankFrame();
        } else {
            int l;
            QImage img = getBuffer(r, l);
            animation->appendFrame(img,QPoint(r.x(),r.y()));
        }
    }
    if (!r.isNull()) {
        if (hzm == 1.0 && vzm == 1.0) // hw: workaround for 4.3.1
            update(mapFromDevice(r, QSize(displayWidth(), displayHeight()), rotation));
        else
            update();
    }
}

static void dim(QRgb* rgb, int n, int brightness)
{
    uchar* b = (uchar*)rgb;
#if Q_BYTE_ORDER == Q_BIG_ENDIAN
    b++;
#endif
    while (n--) {
        b[0] = (uint)b[0] * brightness / 255;
        b[1] = (uint)b[1] * brightness / 255;
        b[2] = (uint)b[2] * brightness / 255;
        b += 4;
    }
}

QImage QVFbView::getBuffer(const QRect &r, int &leading) const
{
    const int brightness = mView->brightness();
    if ( brightness == 0 ) {
        QImage img(r.size(),QImage::Format_RGB32);
        img.fill(0);
        leading = 0;
        return img;
    }

    static QByteArray buffer;

    const int requiredSize = r.width() * r.height() * 4;

    QImage img;
    leading = 0;

    switch (viewdepth) {
    case 1: {
        if (requiredSize > buffer.size())
            buffer.resize(requiredSize);

        // XXX: hw: replace by drawhelper functionality

        const int pixelsPerByte = 8;
        quint8 *src = reinterpret_cast<quint8*>(mView->data())
                      + r.y() * mView->linestep() + r.x() / pixelsPerByte;
        const int align = qMin(r.width(), (8 - (r.x() & 7)) & 7);
        const int doAlign = (align > 0 ? 1 : 0);
        const int tail = qMin(r.width(), (r.width() - align) & 7);
        const int doTail = (tail > 0 ? 1 : 0);
        const int width8 = (r.width() - align) / pixelsPerByte;
        const int stride = mView->linestep() - (width8 + doAlign);

        uchar *b = reinterpret_cast<uchar*>(buffer.data());
	img = QImage(b, r.width(), r.height(), QImage::Format_RGB32);
	for (int y = 0; y < r.height(); ++y) {
            quint32 *dest = reinterpret_cast<quint32*>(img.scanLine(y));
            quint8 c;

            if (doAlign) {
                switch (align) {
                case 7: c = ((*src & 0x40) >> 6) * 0xff;
                        *dest++ = qRgb(c, c, c);
                case 6: c = ((*src & 0x20) >> 5) * 0xff;
                        *dest++ = qRgb(c, c, c);
                case 5: c = ((*src & 0x10) >> 4) * 0xff;
                        *dest++ = qRgb(c, c, c);
                case 4: c = ((*src & 0x08) >> 3) * 0xff;
                        *dest++ = qRgb(c, c, c);
                case 3: c = ((*src & 0x04) >> 2) * 0xff;
                        *dest++ = qRgb(c, c, c);
                case 2: c = ((*src & 0x02) >> 1) * 0xff;
                        *dest++ = qRgb(c, c, c);
                case 1: c = ((*src & 0x01)) * 0xff;
                        *dest++ = qRgb(c, c, c);
                }
                ++src;
            }
            for (int i = 0; i < width8; ++i) {
                c = ((*src & 0x80) >> 7) * 0xff;
                *dest++ = qRgb(c, c, c);
                c = ((*src & 0x40) >> 6) * 0xff;
                *dest++ = qRgb(c, c, c);
                c = ((*src & 0x20) >> 5) * 0xff;
                *dest++ = qRgb(c, c, c);
                c = ((*src & 0x10) >> 4) * 0xff;
                *dest++ = qRgb(c, c, c);
                c = ((*src & 0x08) >> 3) * 0xff;
                *dest++ = qRgb(c, c, c);
                c = ((*src & 0x04) >> 2) * 0xff;
                *dest++ = qRgb(c, c, c);
                c = ((*src & 0x02) >> 1) * 0xff;
                *dest++ = qRgb(c, c, c);
                c = ((*src & 0x01)) * 0xff;
                *dest++ = qRgb(c, c, c);

                ++src;
            }
            if (doTail) {
                switch (tail) {
                case 7: c = ((*src & 0x02) >> 1) * 0xff;
                        dest[6] = qRgb(c, c, c);
                case 6: c = ((*src & 0x04) >> 2) * 0xff;
                        dest[5] = qRgb(c, c, c);
                case 5: c = ((*src & 0x08) >> 3) * 0xff;
                        dest[4] = qRgb(c, c, c);
                case 4: c = ((*src & 0x10) >> 4) * 0xff;
                        dest[3] = qRgb(c, c, c);
                case 3: c = ((*src & 0x20) >> 5) * 0xff;
                        dest[2] = qRgb(c, c, c);
                case 2: c = ((*src & 0x40) >> 6) * 0xff;
                        dest[1] = qRgb(c, c, c);
                case 1: c = ((*src & 0x80) >> 7) * 0xff;
                        dest[0] = qRgb(c, c, c);
                }
            }
            src += stride;
        }
        break;
    }

    case 2: {
        if (requiredSize > buffer.size())
            buffer.resize(requiredSize);

        // XXX: hw: replace by drawhelper functionality

        const int pixelsPerByte = 4;
        quint8 *src = reinterpret_cast<quint8*>(mView->data())
                      + r.y() * mView->linestep() + r.x() / pixelsPerByte;
        const int align = qMin(r.width(), (4 - (r.x() & 3)) & 3);
        const int doAlign = (align > 0 ? 1 : 0);
        const int tail = qMin(r.width(), (r.width() - align) & 3);
        const int doTail = (tail > 0 ? 1 : 0);
        const int width8 = (r.width() - align) / pixelsPerByte;
        const int stride = mView->linestep() - (width8 + doAlign);

        uchar *b = reinterpret_cast<uchar*>(buffer.data());
	img = QImage(b, r.width(), r.height(), QImage::Format_RGB32);
	for (int y = 0; y < r.height(); ++y) {
            quint32 *dest = reinterpret_cast<quint32*>(img.scanLine(y));
            quint8 c;

            if (doAlign) {
                switch (align) {
                case 3: c = ((*src & 0x30) >> 4) * 0x55;
                        *dest++ = qRgb(c, c, c);
                case 2: c = ((*src & 0x0c) >> 2) * 0x55;
                        *dest++ = qRgb(c, c, c);
                case 1: c = ((*src & 0x03)) * 0x55;
                        *dest++ = qRgb(c, c, c);
                }
                ++src;
            }
            for (int i = 0; i < width8; ++i) {
                c = ((*src & 0xc0) >> 6) * 0x55;
                *dest++ = qRgb(c, c, c);
                c = ((*src & 0x30) >> 4) * 0x55;
                *dest++ = qRgb(c, c, c);
                c = ((*src & 0x0c) >> 2) * 0x55;
                *dest++ = qRgb(c, c, c);
                c = ((*src & 0x03)) * 0x55;
                *dest++ = qRgb(c, c, c);

                ++src;
            }
            if (doTail) {
                switch (tail) {
                case 3: c = ((*src & 0x0c) >> 2) * 0x55;
                        dest[2] = qRgb(c, c, c);
                case 2: c = ((*src & 0x30) >> 4) * 0x55;
                        dest[1] = qRgb(c, c, c);
                case 1: c = ((*src & 0xc0) >> 6) * 0x55;
                        dest[0] = qRgb(c, c, c);
                }
            }
            src += stride;
        }
        break;
    }

    case 4: {
        if (requiredSize > buffer.size())
            buffer.resize(requiredSize);

        // XXX: hw: replace by drawhelper functionality

        const int pixelsPerByte = 2;
        const int doAlign = r.x() & 1;
        const int doTail = (r.width() - doAlign) & 1;
        const int width8 = (r.width() - doAlign) / pixelsPerByte;

        uchar *b = reinterpret_cast<uchar*>(buffer.data());
	img = QImage(b, r.width(), r.height(), QImage::Format_RGB32);
	for (int y = 0; y < r.height(); ++y) {
            const quint8 *sptr = mView->data()
                                 + (r.y() + y) * mView->linestep()
                                 + r.x() / pixelsPerByte;
            quint32 *dptr = reinterpret_cast<quint32*>(img.scanLine(y));

            if (doAlign) {
                quint8 c = (*sptr++ & 0x0f);
                c |= (c << 4);
                *dptr++ = qRgb(c, c, c);
            }

            for (int i = 0; i < width8; ++i) {
                quint8 c1 = (*sptr >> 4);
                quint8 c2 = (*sptr & 0x0f);
                c1 |= (c1 << 4);
                c2 |= (c2 << 4);
		*dptr++ = qRgb(c1, c1, c1);
		*dptr++ = qRgb(c2, c2, c2);
                ++sptr;
	    }

            if (doTail) {
                quint8 c = *sptr >> 4;
                c |= (c << 4);
                *dptr = qRgb(c, c, c);
            }
	}
        break;
    }
    case 12:
	img = QImage((const uchar*)(mView->data() + r.y() * mView->linestep() + r.x() * 2),
                     r.width(), r.height(), mView->linestep(),
                     QImage::Format_RGB444);
        break;
    case 15:
	img = QImage((const uchar*)(mView->data() + r.y() * mView->linestep() + r.x() * 2),
                     r.width(), r.height(), mView->linestep(),
                     QImage::Format_RGB555);
        break;
    case 16:
	img = QImage((const uchar*)(mView->data() + r.y() * mView->linestep() + r.x() * 2),
                     r.width(), r.height(), mView->linestep(),
                     QImage::Format_RGB16);
        break;
    case 18:
	img = QImage((const uchar*)(mView->data() + r.y() * mView->linestep() + r.x() * 3),
                     r.width(), r.height(), mView->linestep(),
                     QImage::Format_RGB666);
        break;
    case 24:
	img = QImage((const uchar*)(mView->data() + r.y() * mView->linestep() + r.x() * 3),
                      r.width(), r.height(), mView->linestep(),
                     QImage::Format_RGB888);
        break;
    case 32:
	img = QImage((const uchar*)(mView->data() + r.y() * mView->linestep() + r.x() * 4),
                     r.width(), r.height(), mView->linestep(),
                     viewFormat == ARGBFormat ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32);
        break;
    case 8:
        img = QImage(mView->data() + r.y() * mView->linestep() + r.x(),
                   r.width(), r.height(), mView->linestep(),
                   QImage::Format_Indexed8);
        img.setColorTable(mView->clut());
        if (img.numColors() <= 0)
            img = QImage();
        break;
    }

    if (rgb_swapped)
        img = img.rgbSwapped();

    if ( brightness != 255 ) {
        if (img.format() == QImage::Format_Indexed8) {
            QVector<QRgb> c = img.colorTable();
            dim(c.data(),c.count(),brightness);
            img.setColorTable(c);
        } else {
            if ( img.format() != QImage::Format_ARGB32_Premultiplied )
                img = img.convertToFormat(QImage::Format_RGB32);

            // NOTE: calling bits() may change numBytes(), so do not
            // pass them as parameters (which are evaluated right-to-left).
            QRgb *b = (QRgb*)img.bits();
            int n = img.numBytes()/4;
            dim(b,n,brightness);
        }
    }

    return img;
}

static int findMultiple(int start, double m, int limit, int step)
{
    int r = start;
    while (r != limit) {
	if (int(int(r * m)/m) == r)
	    break;
	r += step;
    }
    return r;
}

void QVFbView::drawScreen(const QRect &rect)
{
    QRect r = QRect(0, 0, mView->width(), mView->height());

    if (hzm == 1.0 && vzm == 1.0) // hw: workaround for 4.3.1
        r &= rect;

    if (int(hzm) != hzm || int(vzm) != vzm) {
        r.setLeft(findMultiple(r.left(),hzm,0,-1));
        r.setTop(findMultiple(r.top(),vzm,0,-1));
        int w = findMultiple(r.width(),hzm,mView->width(),1);
        int h = findMultiple(r.height(),vzm,mView->height(),1);
        r.setRight(r.left()+w-1);
        r.setBottom(r.top()+h-1);
    }

    int leading;
    const QImage img = getBuffer(r, leading);

    QPixmap pm;
    if (hzm == 1.0 && vzm == 1.0) {
        pm = QPixmap::fromImage(img);
    } else if (emulateLcdScreen && hzm == 3.0 && vzm == 3.0) {
        QImage img2(img.width()*3, img.height(), QImage::Format_RGB32);
        for (int row = 0; row < img2.height(); row++) {
            QRgb *dptr = (QRgb*)img2.scanLine(row);
            QRgb *sptr = (QRgb*)img.scanLine(row);
            for (int col = 0; col < img.width(); col++) {
                QRgb s = *sptr++;
                *dptr++ = qRgb(qRed(s),0,0);
                *dptr++ = qRgb(0,qGreen(s),0);
                *dptr++ = qRgb(0,0,qBlue(s));
            }
        }
        QMatrix m;
        m.scale(1.0, 3.0);
        pm = QPixmap::fromImage(img2);
        pm = pm.transformed(m);
    } else if (int(hzm) == hzm && int(vzm) == vzm) {
        QMatrix m;
        m.scale(hzm,vzm);
        pm = QPixmap::fromImage(img);
        pm = pm.transformed(m);
    } else {
        pm = QPixmap::fromImage(img.scaled(int(img.width()*hzm),int(img.height()*vzm), Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
    }

    int x1 = r.x();
    int y1 = r.y();
    int leadingX = leading;
    int leadingY = 0;

    // Do the rotation thing
    int rotX1 = mView->width() - x1 - img.width();
    int rotY1 = mView->height() - y1 - img.height();
    int rotLeadingX = (leading) ? mView->width() - leadingX - img.width() : 0;
    int rotLeadingY = 0;
    switch (rotation) {
    case Rot0:
        break;
    case Rot90:
        leadingY = leadingX;
        leadingX = rotLeadingY;
        y1 = x1;
        x1 = rotY1;
        break;
    case Rot180:
        leadingX = rotLeadingX;
        leadingY = leadingY;
        x1 = rotX1;
        y1 = rotY1;
        break;
    case Rot270:
        leadingX = leadingY;
        leadingY = rotLeadingX;
        x1 = y1;
        y1 = rotX1;
        break;
    default:
        break;
    }
    x1 = int(x1*hzm);
    y1 = int(y1*vzm);
    leadingX = int(leadingX*hzm);
    leadingY = int(leadingY*vzm);
    if (rotation != 0) {
        QMatrix m;
        m.rotate(rotation * 90.0);
        pm = pm.transformed(m);
    }

    QPainter p(this);
    if (viewFormat == ARGBFormat) {
        QPixmap bg(":/res/images/logo-nt.png");
        p.fillRect(x1,y1,pm.width(), pm.height(), QBrush(bg));
    }
    p.drawPixmap(x1, y1, pm, leadingX, leadingY, pm.width(), pm.height());
}

//bool QVFbView::eventFilter(QObject *obj, QEvent *e)
//{
//    if (obj == this &&
//	 (e->type() == QEvent::FocusIn || e->type() == QEvent::FocusOut))
//	return true;
//
//    return QWidgetView::eventFilter(obj, e);
//}

void QVFbView::paintEvent(QPaintEvent *e)
{
    drawScreen(mapToDevice(e->rect(),QSize(int(width()/hzm), int(height()/vzm)),rotation));
}

void QVFbView::mousePressEvent(QMouseEvent *e)
{
    sendMouseData(QPoint(int(e->x()/hzm),int(e->y()/vzm)), e->buttons(), 0);
}

void QVFbView::contextMenuEvent(QContextMenuEvent*)
{

}

void QVFbView::mouseDoubleClickEvent(QMouseEvent *e)
{
    sendMouseData(QPoint(int(e->x()/hzm),int(e->y()/vzm)), e->buttons(), 0);
}

void QVFbView::mouseReleaseEvent(QMouseEvent *e)
{
    sendMouseData(QPoint(int(e->x()/hzm),int(e->y()/vzm)), e->buttons(), 0);
}

void QVFbView::skinMouseEvent(QMouseEvent *e)
{
    sendMouseData(QPoint(int(e->x()/hzm),int(e->y()/vzm)), e->buttons(), 0);
}

void QVFbView::mouseMoveEvent(QMouseEvent *e)
{
    if (!emulateTouchscreen || (e->buttons() & Qt::MouseButtonMask))
	sendMouseData(QPoint(int(e->x()/hzm),int(e->y()/vzm)), e->buttons(), 0);
}

void QVFbView::wheelEvent(QWheelEvent *e)
{
    if (!e)
        return;
    sendMouseData(QPoint(int(e->x()/hzm),int(e->y()/vzm)), e->buttons(), e->delta());
}

void QVFbView::setTouchscreenEmulation(bool b)
{
    emulateTouchscreen = b;
}

void QVFbView::setLcdScreenEmulation(bool b)
{
    emulateLcdScreen = b;
}

void QVFbView::setViewFormat(PixelFormat f)
{
    if (viewFormat == f)
        return;
    viewFormat = f;
    setAttribute(Qt::WA_PaintOnScreen, viewFormat != ARGBFormat);
}

#ifdef Q_WS_X11
void QVFbView::embedDisplay(WId windowId)
{
    if (windowId == 0) {
        delete embedContainer;
        embedContainer = 0;
        return;
    }

    if (!embedContainer) {
        embedContainer = new QX11EmbedContainer(this);
        embedContainer->setGeometry(rect());
        embedContainer->show();
    }
    embedContainer->embedClient(windowId);
}
#endif

bool QVFbView::event(QEvent *e)
{
    if (e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease) {
        QKeyEvent *ke = static_cast<QKeyEvent*>(e);
        sendKeyboardData(ke->text(), ke->key(),
		     ke->modifiers()&(Qt::ShiftModifier|Qt::ControlModifier|Qt::AltModifier),
                         ke->type() == QEvent::KeyPress, ke->isAutoRepeat());
        ke->accept();
        return true;
    }
    return QVFbAbstractView::event(e);
}

void QVFbView::keyPressEvent(QKeyEvent *e)
{
    sendKeyboardData(e->text(), e->key(),
		     e->modifiers()&(Qt::ShiftModifier|Qt::ControlModifier|Qt::AltModifier),
		     true, e->isAutoRepeat());
}

void QVFbView::keyReleaseEvent(QKeyEvent *e)
{
    sendKeyboardData(e->text(), e->key(),
		     e->modifiers()&(Qt::ShiftModifier|Qt::ControlModifier|Qt::AltModifier),
		     false, e->isAutoRepeat());
}


QImage QVFbView::image() const
{
    int l;
    QImage r = getBuffer(QRect(0, 0, mView->width(), mView->height()), l).copy();
    return r;
}

void QVFbView::startAnimation(const QString& filename)
{
    delete animation;
    animation = new QAnimationWriter(filename,"MNG");
    animation->setFrameRate(refreshRate);
    animation->appendFrame(QImage(mView->data(),
                                  mView->width(), mView->height(), QImage::Format_RGB32));
}

void QVFbView::stopAnimation()
{
    delete animation;
    animation = 0;
}


void QVFbView::skinKeyPressEvent(int code, const QString& text, bool autorep)
{
    QKeyEvent e(QEvent::KeyPress,code,0,text,autorep);
    keyPressEvent(&e);
}

void QVFbView::skinKeyReleaseEvent(int code, const QString& text, bool autorep)
{
    QKeyEvent e(QEvent::KeyRelease,code,0,text,autorep);
    keyReleaseEvent(&e);
}

QT_END_NAMESPACE