qcontext2dcanvas.cpp

奇趣公司比较新的qt/emd版本

        return  DOM_VK_F24;
    }
    return keyCode;
}

void FakeDomEvent::setupDefaults(QScriptEngine *e)
{
    m_proto.setProperty("timeStamp", QScriptValue(e, QDateTime::currentDateTime().toTime_t()));
    m_proto.setProperty("button", QScriptValue(e, 0));
    m_proto.setProperty("charCode", QScriptValue(e, 0));
    m_proto.setProperty("clientX", QScriptValue(e, 0));
    m_proto.setProperty("clientY", QScriptValue(e, 0));
    m_proto.setProperty("isChar", QScriptValue(e, 0));
    m_proto.setProperty("keyCode", QScriptValue(e, 0));
    m_proto.setProperty("layerX", QScriptValue(e, 0));
    m_proto.setProperty("layerY", QScriptValue(e, 0));
    m_proto.setProperty("pageX", QScriptValue(e, 0));
    m_proto.setProperty("pageY", QScriptValue(e, 0));
    m_proto.setProperty("screenX", QScriptValue(e, 0));
    m_proto.setProperty("screenY", QScriptValue(e, 0));
    m_proto.setProperty("which ", QScriptValue(e, 0));
}

void FakeDomEvent::setup(QScriptEngine *e)
{
    qRegisterMetaType<FakeDomEvent>();

    m_proto = e->newObject();

    setupDefaults(e);

    m_proto.setProperty("bubbles", QScriptValue(e, 0));
    m_proto.setProperty("cancelBubble", QScriptValue(e, 0));
    m_proto.setProperty("cancelable", QScriptValue(e, 0));
    m_proto.setProperty("currentTarget", QScriptValue(e, 0));
    m_proto.setProperty("detail", QScriptValue(e, 0));
    m_proto.setProperty("eventPhase", QScriptValue(e, 0));
    m_proto.setProperty("explicitOriginalTarget", QScriptValue(e, 0));
    m_proto.setProperty("originalTarget", QScriptValue(e, 0));
    m_proto.setProperty("relatedTarget", QScriptValue(e, 0));
    m_proto.setProperty("target", QScriptValue(e, 0));
    m_proto.setProperty("view", QScriptValue(e, 0));
}

QScriptValue FakeDomEvent::m_proto;

static QScriptValue getElementById(QScriptContext *context, QScriptEngine *env)
{
    QString el  = context->argument(0).toString();
    QList<QObject*> lst = qFindChildren<QObject*>(QCoreApplication::instance(), el);
    if (lst.isEmpty()) {
        foreach (QWidget *widget, QApplication::topLevelWidgets()) {
            if (el == widget->objectName() ) {
                lst << widget;
                break;
            } else {
                lst = qFindChildren<QObject*>(widget, el);
            }

            if (lst.count())
                break;
        }
    }

    return env->newQObject(lst[0]);
}

static QScriptValue setInterval(QScriptContext *context, QScriptEngine *env)
{
    QScriptValue func = context->argument(0);
    qsreal interval  = context->argument(1).toNumber();
    QScriptValue val = env->globalObject().property("_qcontext");
    QContext2DCanvas *canvas =
        qobject_cast<QContext2DCanvas*>(val.toQObject());
    if (!canvas) {
        qWarning("Couldn't find a QContext2DCanvas!");
        return env->undefinedValue();
    }
    if (!func.isFunction()) {
        QString funcStr = func.toString();
        if (funcStr.endsWith("()")) {
            funcStr.chop(2);
        }
        func = env->globalObject().property(funcStr);
    }
    if (!func.isFunction()) {
        qWarning("Couldn't find function %s",
                 qPrintable(context->argument(0).toString()));
        return env->undefinedValue();
    }

    canvas->setInterval(func, interval);

    return env->undefinedValue();
}


static QScriptValue setTimeout(QScriptContext *ctx, QScriptEngine *env)
{
    return setInterval(ctx, env);
}

QContext2DCanvas::QContext2DCanvas(QWidget *parent)
    : QWidget(parent),
      m_firstRun(true)
{
    setObjectName("tutorial");
    m_context = new Context2D(this);

    m_self = m_engine.newQObject(this);

    FakeDomEvent::setup(&m_engine);
    DomImage::setup(&m_engine);

    m_doc = m_engine.newObject();
    m_doc.setProperty("getElementById",
                    m_engine.newFunction(::getElementById,
                                            /*argc = */ 1));

    m_engine.globalObject().setProperty("document", m_doc);


    m_engine.globalObject().setProperty(
        "setInterval",
        m_engine.newFunction(::setInterval, 2));
    m_engine.globalObject().setProperty(
        "setTimeout",
        m_engine.newFunction(::setTimeout, 2));
    m_engine.globalObject().setProperty("_qcontext", m_self);

    connect(&m_timer, SIGNAL(timeout()),
            SLOT(update()));
}

QScriptEngine *QContext2DCanvas::engine()
{
    return &m_engine;
}

void QContext2DCanvas::setScriptContents(const QString &txt)
{
    m_timer.stop();
    m_intervalFunc     = QScriptValue();
    m_keyDownHandler   = QScriptValue();
    m_keyUpHandler     = QScriptValue();
    m_mouseDownHandler = QScriptValue();
    m_mouseUpHandler   = QScriptValue();
    m_mouseMoveHandler = QScriptValue();
    m_firstRun = true;
    m_script = txt;
    m_context->clear();
    update();
}

void QContext2DCanvas::paintEvent(QPaintEvent *e)
{
    QPainter p(this);
    p.setClipRect(e->rect());

    QScriptValue ret;
    if (m_intervalFunc.isValid()) {
        m_context->begin();
        ret = m_intervalFunc.call(m_engine.globalObject());
    } else {
        ret = m_engine.evaluate(m_script);
    }
    if (!m_script.isEmpty() && m_engine.hasUncaughtException()) {
        int lineno = m_engine.uncaughtExceptionLineNumber();
        QString msg = ret.toString();
        qWarning("%s, at %d", qPrintable(msg), lineno);
        emit error(msg, lineno);
        m_timer.stop();
        return;
    }
    p.drawImage(0, 0, m_context->end());

    if (m_firstRun) {
        m_keyDownHandler = m_doc.property("onkeydown");
        m_keyUpHandler = m_doc.property("onkeyup");
        m_mouseDownHandler = m_doc.property("onmousedown");
        m_mouseUpHandler = m_doc.property("onmouseup");
        m_mouseMoveHandler = m_doc.property("onmousemove");
        setMouseTracking(m_mouseMoveHandler.isValid());
    }

    m_firstRun = false;
}


void QContext2DCanvas::mouseMoveEvent(QMouseEvent *e)
{
    Q_UNUSED(e);
    if (m_mouseMoveHandler.isValid()) {
        FakeDomEvent event(e, &m_engine);
        QScriptValueList args;
        args << event.m_proto;
        m_mouseMoveHandler.call(m_engine.globalObject(), args);
    }
}


void QContext2DCanvas::mousePressEvent(QMouseEvent *e)
{
    if (m_mouseDownHandler.isValid()) {
        FakeDomEvent event(e, &m_engine);
        QScriptValueList args;
        args << event.m_proto;
        m_mouseDownHandler.call(m_engine.globalObject(), args);
    }
}


void QContext2DCanvas::mouseReleaseEvent(QMouseEvent *e)
{
    if (m_mouseUpHandler.isValid()) {
        FakeDomEvent event(e, &m_engine);
        QScriptValueList args;
        args << event.m_proto;
        m_mouseUpHandler.call(m_engine.globalObject(), args);
    }
}


void QContext2DCanvas::keyPressEvent(QKeyEvent *e)
{
    if (m_keyDownHandler.isValid()) {
        FakeDomEvent event(e, &m_engine);
        QScriptValueList args;
        args << event.m_proto;
        m_keyDownHandler.call(m_engine.globalObject(), args);
    }
}

void QContext2DCanvas::keyReleaseEvent(QKeyEvent *e)
{
    if (m_keyUpHandler.isValid()) {
        FakeDomEvent event(e, &m_engine);
        QScriptValueList args;
        args << event.m_proto;
        m_keyUpHandler.call(m_engine.globalObject(), args);
    }
}


void QContext2DCanvas::resizeEvent(QResizeEvent *e)
{
    Q_UNUSED(e);
    m_context->setSize(e->size().width(), e->size().height());
}

QObject * QContext2DCanvas::getContext(const QString &str) const
{
    if (str != QLatin1String("2d")) {
        qWarning("Passing invalid context %s", qPrintable(str));
    }

    m_context->begin();
    return m_context;
}

QContext2DCanvas::~QContext2DCanvas()
{
}

void QContext2DCanvas::setInterval(const QScriptValue &func,
                                   qreal interval)
{
    m_intervalFunc = func;
    m_timer.setInterval((int)interval);
    m_timer.start();
}

void QContext2DCanvas::resize(int w, int h)
{
    QWidget::resize(w, h);
}