1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 *

     5 * This program is free software: you can redistribute it and/or modify

     6 * it under the terms of the GNU Lesser General Public License as published by

     7 * the Free Software Foundation, version 2.1 of the License.

     8 * 

     9 * This program is distributed in the hope that it will be useful,

    10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12 * GNU Lesser General Public License for more details.

    13 *

    14 * You should have received a copy of the GNU Lesser General Public License

    15 * along with this program.  If not, 

    16 * see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

    17 *

    18 * Description:

    19 *

    20 */

    21 

    22 #include <QDebug>

    23 #include <QApplication>

    24 #include <QKeyEvent>

    25 #include <QLabel>

    26 #include <QVBoxLayout>

    27 #include <QStackedWidget>

    28 #include <QImageReader>

    29 #include <QDebug>

    30 #include <QTimer>

    31 #include <QPushButton>

    32 #include <QLineEdit>

    33 #include <QDebug>

    34 #include <QString>

    35 #include <QCheckBox>

    36 #include <QPlainTextEdit>

    37 #include <QString>

    38 #include <QMenu>

    39 #include <QMenuBar>

    40 #include <QAction>

    41 #include <QEvent>

    42 

    43 #include "keycapturetestapp.h"

    44 #include "txlogger.h"

    45 

    46 

    47 KeyCaptureTestApp::KeyCaptureTestApp( QWidget *parent) : QMainWindow(parent)

    48 {

    49     TX_ENTRY

    50     

    51 //    qApp->installEventFilter(this);

    52 //    QCoreApplication::instance()->installEventFilter(this);

    53     

    54     

    55 	setWindowTitle(tr("KeyCaptureTestApp"));

    56     

    57     mKeyCapture = new XqKeyCapture();

    58     

    59     mKeysMap.insert("Up", Qt::Key_Up);

    60     mKeysMap.insert("Down", Qt::Key_Down);

    61     mKeysMap.insert("Manu", Qt::Key_Launch0);

    62     

    63     

    64     mKeysMenu = new QMenu(this);

    65     foreach (QString value, mKeysMap.keys())

    66         mKeysMenu->addAction(value)->setData( QVariant(value) );

    67     

    68     mLongFlagsMap.insert("LongNormal", XqKeyCapture::LongNormal);

    69     mLongFlagsMap.insert("LongRepeatEvents", XqKeyCapture::LongRepeatEvents);

    70     mLongFlagsMap.insert("LongShortEventImmediately", XqKeyCapture::LongShortEventImmediately);

    71     mLongFlagsMap.insert("LongWaitNotApplicable", XqKeyCapture::LongWaitNotApplicable);

    72     mLongFlagsMap.insert("LongWaitShort", XqKeyCapture::LongWaitShort);

    73     

    74     mLongFlagsMenu = new QMenu(this);

    75     foreach (QString value, mLongFlagsMap.keys())

    76         mLongFlagsMenu->addAction(value)->setData( QVariant(value) );

    77     

    78 	QMenu *captureMenu = menuBar()->addMenu(QString("Capture"));

    79     connect(captureMenu, SIGNAL(triggered(QAction*)), this, SLOT(triggered(QAction*)));

    80 	captureMenu->addAction(QString("Key"))->setData( QVariant(1) );

    81 	captureMenu->addAction(QString("Long Key"))->setData( QVariant(2) );

    82 	captureMenu->addAction(QString("Up and Down Key"))->setData( QVariant(3) );

    83 

    84 	QMenu *cancelCaptureMenu = menuBar()->addMenu(QString("Cancel Capture"));

    85     connect(cancelCaptureMenu, SIGNAL(triggered(QAction*)), this, SLOT(triggered(QAction*)));

    86 	cancelCaptureMenu->addAction(QString("Cancel Key"))->setData( QVariant(4) );

    87 	cancelCaptureMenu->addAction(QString("Cancel Long Key"))->setData( QVariant(5) );

    88 	cancelCaptureMenu->addAction(QString("Cancel Up and Down Key"))->setData( QVariant(6) );

    89 

    90     connect(menuBar()->addAction(QString("Clear Log")), SIGNAL(triggered()), this, SLOT(cleanLog()));

    91     connect(menuBar()->addAction(QString("Exit")), SIGNAL(triggered()), qApp, SLOT(quit()));

    92 

    93 

    94     QWidget *window = new QWidget;

    95     QVBoxLayout* layout = new QVBoxLayout;

    96 

    97 	mTextArea = new QPlainTextEdit("Log area\n");

    98 	layout->addWidget(mTextArea);

    99 	

   100     window->setLayout(layout);

   101     setCentralWidget(window);

   102     window->show();;

   103 

   104     

   105     TX_EXIT

   106 }

   107 	

   108 KeyCaptureTestApp::~KeyCaptureTestApp()

   109 {

   110 	

   111 }

   112 

   113 void KeyCaptureTestApp::triggered(QAction* aAction)

   114 {

   115     CaptureRequest request;

   116     if (!request.setType(aAction)){

   117         return;

   118     }

   119     if (!request.setKey(mKeysMenu->exec(), &mKeysMap)){

   120         return;

   121     }

   122 //TODO: add modifiersMap selection menu;

   123 //TODO: add modifier selection menu;

   124     if ( request.mRequestType == CaptureRequest::RequestTypeLongKey || request.mRequestType == CaptureRequest::RequestTypeCancelLongKey){

   125         if (!request.setLongFlags(mLongFlagsMenu->exec(), &mLongFlagsMap)){

   126             return;

   127         }

   128     }

   129     procesAction(request);

   130 }

   131 

   132 void KeyCaptureTestApp::cleanLog()

   133 {

   134     mTextArea->setPlainText("");

   135 }

   136 

   137 void KeyCaptureTestApp::procesAction(CaptureRequest request)

   138 {

   139     TX_ENTRY

   140     switch (request.mRequestType){

   141         case CaptureRequest::RequestTypeKey :

   142             mKeyCapture->captureKey(request.mKey, request.mModifiersMap, request.mModifier );

   143             addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString()));

   144             break;

   145         case CaptureRequest::RequestTypeLongKey :

   146             mKeyCapture->captureLongKey(request.mKey, request.mModifiersMap, request.mModifier, request.mLongFlags);

   147             addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString()));

   148             break;

   149         case CaptureRequest::RequestTypeKeyUpAndDowns :

   150             mKeyCapture->captureKeyUpAndDowns(request.mKey, request.mModifiersMap, request.mModifier );

   151             addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString()));

   152             break;

   153         case CaptureRequest::RequestTypeCancelKey :

   154             mKeyCapture->cancelCaptureKey(request.mKey, request.mModifiersMap, request.mModifier );

   155             addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString()));

   156             break;

   157         case CaptureRequest::RequestTypeCancelLongKey :

   158             mKeyCapture->cancelCaptureLongKey(request.mKey, request.mModifiersMap, request.mModifier, request.mLongFlags);

   159             addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString()));

   160             break;

   161         case CaptureRequest::RequestTypeCancelKeyUpAndDowns :

   162             mKeyCapture->cancelCaptureKeyUpAndDowns(request.mKey, request.mModifiersMap, request.mModifier );

   163             addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString()));

   164             break;

   165         default:

   166             break;

   167     }

   168 

   169 

   170     TX_EXIT    

   171 }

   172 

   173 void KeyCaptureTestApp::addTextLine(QString aText)

   174 {

   175     TX_LOG_ARGS( QString("aText=%1").arg(aText));

   176 	if ( !aText.endsWith("\n"))

   177 		aText = aText + "\n";

   178 	QString msg = mTextArea->toPlainText();

   179 	msg = aText + msg;

   180 	mTextArea->setPlainText(msg);

   181 }

   182 

   183 bool KeyCaptureTestApp::event(QEvent *ev)

   184 {

   185     processEvent(ev);

   186     return QMainWindow::event(ev);

   187 }

   188 

   189 bool KeyCaptureTestApp::eventFilter(QObject *o, QEvent *ev)

   190 {

   191     processEvent(ev);

   192     return QMainWindow::eventFilter(o, ev);

   193 }

   194 

   195 void KeyCaptureTestApp::processEvent(QEvent *ev)

   196 {

   197     if (ev){

   198        if (ev->type() == QEvent::KeyPress){

   199            QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);

   200            addTextLine(QString("KeyPress:%1\n").arg(keyEvent->key(), 0, 16) );

   201        }else if (ev->type() == QEvent::KeyRelease){

   202            QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);

   203            addTextLine(QString("KeyRelease:%1\n").arg(keyEvent->key(), 0, 16) );

   204        }

   205     }

   206 }

   207 

   208 CaptureRequest::CaptureRequest()

   209 {

   210     mRequestType = RequestTypeUndefined;

   211     mKey = Qt::Key_unknown;    

   212     mModifiersMap = Qt::NoModifier;

   213     mModifier = Qt::NoModifier;

   214     mLongFlags = XqKeyCapture::LongNormal; 

   215 }

   216 

   217 CaptureRequest::~CaptureRequest()

   218 {

   219     

   220 }

   221 

   222 QString CaptureRequest::toString()

   223 {

   224     QString res = "Request ";

   225     switch (mRequestType){

   226         case CaptureRequest::RequestTypeKey :

   227             res +="Key(";

   228             break;

   229         case CaptureRequest::RequestTypeLongKey :

   230             res +="LongKey(";            

   231             break;

   232         case CaptureRequest::RequestTypeKeyUpAndDowns :

   233             res +="UpAndDowns(";  

   234             break;

   235         case CaptureRequest::RequestTypeCancelKey :

   236             res +="CancelKey(";

   237             break;

   238         case CaptureRequest::RequestTypeCancelLongKey :

   239             res +="CancelLongKey(";

   240             break;

   241         case CaptureRequest::RequestTypeCancelKeyUpAndDowns :

   242             res +="CancelUpAndDowns(";

   243             break;

   244         default:

   245             res +="Unknown";

   246             break;

   247     }

   248     if ( mRequestType == RequestTypeUndefined)

   249         return res;

   250     res +=QString("%1").arg(mKey, 0, 16);

   251     //TODO::put to res mModifiersMap    

   252     //TODO::put to res mModifier

   253     if ( mRequestType == RequestTypeLongKey || mRequestType == RequestTypeCancelLongKey)

   254         res +=QString(",%1)").arg(mLongFlags, 0, 16);

   255     else

   256         res +=")";

   257     

   258     return res;

   259 }

   260 

   261 bool CaptureRequest::setType(QAction* action)

   262 {

   263     if (!action)

   264         return false;

   265     bool ok;

   266     int act = action->data().toInt(&ok);

   267     if (ok){

   268         switch (act){

   269             case 1 : mRequestType = RequestTypeKey; break;

   270             case 2 : mRequestType = RequestTypeLongKey; break;

   271             case 3 : mRequestType = RequestTypeKeyUpAndDowns; break;

   272             case 4 : mRequestType = RequestTypeCancelKey; break;

   273             case 5 : mRequestType = RequestTypeCancelLongKey; break;

   274             case 6 : mRequestType = RequestTypeCancelKeyUpAndDowns; break;

   275         }

   276         return mRequestType!=RequestTypeUndefined;

   277     }else{

   278         return false;

   279     }

   280 }

   281 

   282 bool CaptureRequest::setKey(QAction* action, QMap<QString, Qt::Key> *map)

   283 {

   284     if (!action || !map || map->count()==0)

   285         return false;

   286     QString key = action->data().toString();

   287     if ( !key.isNull() && map->contains(key)){

   288         mKey = map->value(key);

   289         return true;

   290     }

   291     return false;

   292 }

   293 

   294 bool CaptureRequest::setLongFlags(QAction* action, QMap<QString, XqKeyCapture::LongFlags> *map)

   295 {

   296     if (!action || !map || map->count()==0)

   297         return false;

   298     QString flag = action->data().toString();

   299     if ( !flag.isNull() && map->contains(flag)){

   300         mLongFlags = map->value(flag);

   301         return true;

   302     }

   303     return false;

   304 }