diff -r cfcbf08528c4 -r 2b40d63a9c3d qtmobileextensions/examples/keycaptureex/keycapturetestapp.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/qtmobileextensions/examples/keycaptureex/keycapturetestapp.cpp Fri Apr 16 15:51:22 2010 +0300 @@ -0,0 +1,304 @@ +/* +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU Lesser General Public License as published by +* the Free Software Foundation, version 2.1 of the License. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public License +* along with this program. If not, +* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/". +* +* Description: +* +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "keycapturetestapp.h" +#include "txlogger.h" + + +KeyCaptureTestApp::KeyCaptureTestApp( QWidget *parent) : QMainWindow(parent) +{ + TX_ENTRY + +// qApp->installEventFilter(this); +// QCoreApplication::instance()->installEventFilter(this); + + + setWindowTitle(tr("KeyCaptureTestApp")); + + mKeyCapture = new XqKeyCapture(); + + mKeysMap.insert("Up", Qt::Key_Up); + mKeysMap.insert("Down", Qt::Key_Down); + mKeysMap.insert("Manu", Qt::Key_Launch0); + + + mKeysMenu = new QMenu(this); + foreach (QString value, mKeysMap.keys()) + mKeysMenu->addAction(value)->setData( QVariant(value) ); + + mLongFlagsMap.insert("LongNormal", XqKeyCapture::LongNormal); + mLongFlagsMap.insert("LongRepeatEvents", XqKeyCapture::LongRepeatEvents); + mLongFlagsMap.insert("LongShortEventImmediately", XqKeyCapture::LongShortEventImmediately); + mLongFlagsMap.insert("LongWaitNotApplicable", XqKeyCapture::LongWaitNotApplicable); + mLongFlagsMap.insert("LongWaitShort", XqKeyCapture::LongWaitShort); + + mLongFlagsMenu = new QMenu(this); + foreach (QString value, mLongFlagsMap.keys()) + mLongFlagsMenu->addAction(value)->setData( QVariant(value) ); + + QMenu *captureMenu = menuBar()->addMenu(QString("Capture")); + connect(captureMenu, SIGNAL(triggered(QAction*)), this, SLOT(triggered(QAction*))); + captureMenu->addAction(QString("Key"))->setData( QVariant(1) ); + captureMenu->addAction(QString("Long Key"))->setData( QVariant(2) ); + captureMenu->addAction(QString("Up and Down Key"))->setData( QVariant(3) ); + + QMenu *cancelCaptureMenu = menuBar()->addMenu(QString("Cancel Capture")); + connect(cancelCaptureMenu, SIGNAL(triggered(QAction*)), this, SLOT(triggered(QAction*))); + cancelCaptureMenu->addAction(QString("Cancel Key"))->setData( QVariant(4) ); + cancelCaptureMenu->addAction(QString("Cancel Long Key"))->setData( QVariant(5) ); + cancelCaptureMenu->addAction(QString("Cancel Up and Down Key"))->setData( QVariant(6) ); + + connect(menuBar()->addAction(QString("Clear Log")), SIGNAL(triggered()), this, SLOT(cleanLog())); + connect(menuBar()->addAction(QString("Exit")), SIGNAL(triggered()), qApp, SLOT(quit())); + + + QWidget *window = new QWidget; + QVBoxLayout* layout = new QVBoxLayout; + + mTextArea = new QPlainTextEdit("Log area\n"); + layout->addWidget(mTextArea); + + window->setLayout(layout); + setCentralWidget(window); + window->show();; + + + TX_EXIT +} + +KeyCaptureTestApp::~KeyCaptureTestApp() +{ + +} + +void KeyCaptureTestApp::triggered(QAction* aAction) +{ + CaptureRequest request; + if (!request.setType(aAction)){ + return; + } + if (!request.setKey(mKeysMenu->exec(), &mKeysMap)){ + return; + } +//TODO: add modifiersMap selection menu; +//TODO: add modifier selection menu; + if ( request.mRequestType == CaptureRequest::RequestTypeLongKey || request.mRequestType == CaptureRequest::RequestTypeCancelLongKey){ + if (!request.setLongFlags(mLongFlagsMenu->exec(), &mLongFlagsMap)){ + return; + } + } + procesAction(request); +} + +void KeyCaptureTestApp::cleanLog() +{ + mTextArea->setPlainText(""); +} + +void KeyCaptureTestApp::procesAction(CaptureRequest request) +{ + TX_ENTRY + switch (request.mRequestType){ + case CaptureRequest::RequestTypeKey : + mKeyCapture->captureKey(request.mKey, request.mModifiersMap, request.mModifier ); + addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString())); + break; + case CaptureRequest::RequestTypeLongKey : + mKeyCapture->captureLongKey(request.mKey, request.mModifiersMap, request.mModifier, request.mLongFlags); + addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString())); + break; + case CaptureRequest::RequestTypeKeyUpAndDowns : + mKeyCapture->captureKeyUpAndDowns(request.mKey, request.mModifiersMap, request.mModifier ); + addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString())); + break; + case CaptureRequest::RequestTypeCancelKey : + mKeyCapture->cancelCaptureKey(request.mKey, request.mModifiersMap, request.mModifier ); + addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString())); + break; + case CaptureRequest::RequestTypeCancelLongKey : + mKeyCapture->cancelCaptureLongKey(request.mKey, request.mModifiersMap, request.mModifier, request.mLongFlags); + addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString())); + break; + case CaptureRequest::RequestTypeCancelKeyUpAndDowns : + mKeyCapture->cancelCaptureKeyUpAndDowns(request.mKey, request.mModifiersMap, request.mModifier ); + addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString())); + break; + default: + break; + } + + + TX_EXIT +} + +void KeyCaptureTestApp::addTextLine(QString aText) +{ + TX_LOG_ARGS( QString("aText=%1").arg(aText)); + if ( !aText.endsWith("\n")) + aText = aText + "\n"; + QString msg = mTextArea->toPlainText(); + msg = aText + msg; + mTextArea->setPlainText(msg); +} + +bool KeyCaptureTestApp::event(QEvent *ev) +{ + processEvent(ev); + return QMainWindow::event(ev); +} + +bool KeyCaptureTestApp::eventFilter(QObject *o, QEvent *ev) +{ + processEvent(ev); + return QMainWindow::eventFilter(o, ev); +} + +void KeyCaptureTestApp::processEvent(QEvent *ev) +{ + if (ev){ + if (ev->type() == QEvent::KeyPress){ + QKeyEvent *keyEvent = static_cast(ev); + addTextLine(QString("KeyPress:%1\n").arg(keyEvent->key(), 0, 16) ); + }else if (ev->type() == QEvent::KeyRelease){ + QKeyEvent *keyEvent = static_cast(ev); + addTextLine(QString("KeyRelease:%1\n").arg(keyEvent->key(), 0, 16) ); + } + } +} + +CaptureRequest::CaptureRequest() +{ + mRequestType = RequestTypeUndefined; + mKey = Qt::Key_unknown; + mModifiersMap = Qt::NoModifier; + mModifier = Qt::NoModifier; + mLongFlags = XqKeyCapture::LongNormal; +} + +CaptureRequest::~CaptureRequest() +{ + +} + +QString CaptureRequest::toString() +{ + QString res = "Request "; + switch (mRequestType){ + case CaptureRequest::RequestTypeKey : + res +="Key("; + break; + case CaptureRequest::RequestTypeLongKey : + res +="LongKey("; + break; + case CaptureRequest::RequestTypeKeyUpAndDowns : + res +="UpAndDowns("; + break; + case CaptureRequest::RequestTypeCancelKey : + res +="CancelKey("; + break; + case CaptureRequest::RequestTypeCancelLongKey : + res +="CancelLongKey("; + break; + case CaptureRequest::RequestTypeCancelKeyUpAndDowns : + res +="CancelUpAndDowns("; + break; + default: + res +="Unknown"; + break; + } + if ( mRequestType == RequestTypeUndefined) + return res; + res +=QString("%1").arg(mKey, 0, 16); + //TODO::put to res mModifiersMap + //TODO::put to res mModifier + if ( mRequestType == RequestTypeLongKey || mRequestType == RequestTypeCancelLongKey) + res +=QString(",%1)").arg(mLongFlags, 0, 16); + else + res +=")"; + + return res; +} + +bool CaptureRequest::setType(QAction* action) +{ + if (!action) + return false; + bool ok; + int act = action->data().toInt(&ok); + if (ok){ + switch (act){ + case 1 : mRequestType = RequestTypeKey; break; + case 2 : mRequestType = RequestTypeLongKey; break; + case 3 : mRequestType = RequestTypeKeyUpAndDowns; break; + case 4 : mRequestType = RequestTypeCancelKey; break; + case 5 : mRequestType = RequestTypeCancelLongKey; break; + case 6 : mRequestType = RequestTypeCancelKeyUpAndDowns; break; + } + return mRequestType!=RequestTypeUndefined; + }else{ + return false; + } +} + +bool CaptureRequest::setKey(QAction* action, QMap *map) +{ + if (!action || !map || map->count()==0) + return false; + QString key = action->data().toString(); + if ( !key.isNull() && map->contains(key)){ + mKey = map->value(key); + return true; + } + return false; +} + +bool CaptureRequest::setLongFlags(QAction* action, QMap *map) +{ + if (!action || !map || map->count()==0) + return false; + QString flag = action->data().toString(); + if ( !flag.isNull() && map->contains(flag)){ + mLongFlags = map->value(flag); + return true; + } + return false; +}