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 |
|
44 #include <QFont> |
|
45 |
|
46 #include "keycapturetestapp.h" |
|
47 #include "txlogger.h" |
|
48 |
|
49 #include "mapping.h" |
|
50 #include "capturerequest.h" |
|
51 |
|
52 KeyCaptureTestApp::KeyCaptureTestApp( QWidget *parent) : QMainWindow(parent) |
|
53 { |
|
54 TX_ENTRY |
|
55 |
|
56 qApp->installEventFilter(this); |
|
57 QCoreApplication::instance()->installEventFilter(this); |
|
58 |
|
59 |
|
60 setWindowTitle(tr("KeyCaptureTestApp")); |
|
61 |
|
62 mKeyCapture = new XQKeyCapture(); |
|
63 |
|
64 mKeysMap.insert("Up", Qt::Key_Up); |
|
65 mKeysMap.insert("Down", Qt::Key_Down); |
|
66 mKeysMap.insert("Menu", Qt::Key_Menu); |
|
67 |
|
68 |
|
69 mKeysMenu = new QMenu(this); |
|
70 foreach (QString value, mKeysMap.keys()) |
|
71 mKeysMenu->addAction(value)->setData( QVariant(value) ); |
|
72 |
|
73 mLongFlagsMap.insert("LongNormal", XQKeyCapture::LongNormal); |
|
74 mLongFlagsMap.insert("LongRepeatEvents", XQKeyCapture::LongRepeatEvents); |
|
75 mLongFlagsMap.insert("LongShortEventImmediately", XQKeyCapture::LongShortEventImmediately); |
|
76 mLongFlagsMap.insert("LongWaitNotApplicable", XQKeyCapture::LongWaitNotApplicable); |
|
77 mLongFlagsMap.insert("LongWaitShort", XQKeyCapture::LongWaitShort); |
|
78 |
|
79 mLongFlagsMenu = new QMenu(this); |
|
80 foreach (QString value, mLongFlagsMap.keys()) |
|
81 mLongFlagsMenu->addAction(value)->setData( QVariant(value) ); |
|
82 |
|
83 QMenu *captureMenu = menuBar()->addMenu(QString("Capture")); |
|
84 connect(captureMenu, SIGNAL(triggered(QAction*)), this, SLOT(triggered(QAction*))); |
|
85 captureMenu->addAction(QString("Key"))->setData( QVariant(1) ); |
|
86 captureMenu->addAction(QString("Long Key"))->setData( QVariant(2) ); |
|
87 captureMenu->addAction(QString("Up and Down Key"))->setData( QVariant(3) ); |
|
88 |
|
89 QMenu *cancelCaptureMenu = menuBar()->addMenu(QString("Cancel Capture")); |
|
90 connect(cancelCaptureMenu, SIGNAL(triggered(QAction*)), this, SLOT(triggered(QAction*))); |
|
91 cancelCaptureMenu->addAction(QString("Cancel Key"))->setData( QVariant(4) ); |
|
92 cancelCaptureMenu->addAction(QString("Cancel Long Key"))->setData( QVariant(5) ); |
|
93 cancelCaptureMenu->addAction(QString("Cancel Up and Down Key"))->setData( QVariant(6) ); |
|
94 |
|
95 QMenu *remoteMenu = menuBar()->addMenu(QString("Remote")); |
|
96 |
|
97 // *** remcon *** |
|
98 |
|
99 remoteAllOn = remoteMenu->addAction(QString("Turn on all")); |
|
100 remoteAllOff = remoteMenu->addAction(QString("Turn off all")); |
|
101 |
|
102 toggleRemoteBasic = remoteMenu->addAction(QString("Basic Remote")); |
|
103 toggleRemoteBasic->setCheckable(true); |
|
104 |
|
105 toggleRemoteCallHandlingEx = remoteMenu->addAction(QString("Call Handl. Ex Remote")); |
|
106 toggleRemoteCallHandlingEx->setCheckable(true); |
|
107 |
|
108 toggleRemoteExtEvents = remoteMenu->addAction(QString("Extended Remote Events")); |
|
109 toggleRemoteExtEvents->setCheckable(true); |
|
110 |
|
111 connect(toggleRemoteBasic, SIGNAL(toggled(bool)), this, SLOT(enableRemBasic(bool))); |
|
112 connect(toggleRemoteCallHandlingEx, SIGNAL(toggled(bool)), this, SLOT(enableRemCallHandlingEx(bool))); |
|
113 connect(toggleRemoteExtEvents, SIGNAL(toggled(bool)), this, SLOT(enableRemoteExtEvents(bool))); |
|
114 |
|
115 connect(remoteAllOn, SIGNAL(triggered(bool)), this, SLOT(remoteAll(bool))); |
|
116 connect(remoteAllOff, SIGNAL(triggered(bool)), this, SLOT(remoteNone(bool))); |
|
117 |
|
118 // *** utilities *** |
|
119 |
|
120 connect(menuBar()->addAction(QString("Clear Log")), SIGNAL(triggered()), this, SLOT(cleanLog())); |
|
121 connect(menuBar()->addAction(QString("Exit")), SIGNAL(triggered()), qApp, SLOT(quit())); |
|
122 |
|
123 QWidget *window = new QWidget; |
|
124 QVBoxLayout* layout = new QVBoxLayout; |
|
125 |
|
126 mTextArea = new QPlainTextEdit(""); |
|
127 mTextArea->setTextInteractionFlags(Qt::NoTextInteraction); |
|
128 QFont font = QFont(mTextArea->font()); |
|
129 font.setPixelSize(10); |
|
130 mTextArea->setFont(font); |
|
131 |
|
132 layout->addWidget(mTextArea); |
|
133 |
|
134 window->setLayout(layout); |
|
135 setCentralWidget(window); |
|
136 window->show();; |
|
137 |
|
138 mappingPtr = new Mapping(); |
|
139 |
|
140 TX_EXIT |
|
141 } |
|
142 |
|
143 KeyCaptureTestApp::~KeyCaptureTestApp() |
|
144 { |
|
145 delete mappingPtr; |
|
146 } |
|
147 |
|
148 void KeyCaptureTestApp::triggered(QAction* aAction) |
|
149 { |
|
150 CaptureRequest request(mappingPtr); |
|
151 if (!request.setType(aAction)){ |
|
152 return; |
|
153 } |
|
154 if (!request.setKey(mKeysMenu->exec(), &mKeysMap)){ |
|
155 return; |
|
156 } |
|
157 //TODO: add modifiersMap selection menu; |
|
158 //TODO: add modifier selection menu; |
|
159 if ( request.mRequestType == CaptureRequest::RequestTypeLongKey || request.mRequestType == CaptureRequest::RequestTypeCancelLongKey){ |
|
160 if (!request.setLongFlags(mLongFlagsMenu->exec(), &mLongFlagsMap)){ |
|
161 return; |
|
162 } |
|
163 } |
|
164 procesAction(request); |
|
165 } |
|
166 |
|
167 void KeyCaptureTestApp::cleanLog() |
|
168 { |
|
169 mTextArea->setPlainText(""); |
|
170 } |
|
171 |
|
172 void KeyCaptureTestApp::procesAction(CaptureRequest request) |
|
173 { |
|
174 TX_ENTRY |
|
175 switch (request.mRequestType) { |
|
176 case CaptureRequest::RequestTypeKey : |
|
177 mKeyCapture->captureKey(request.mKey, request.mModifiersMap, request.mModifier ); |
|
178 addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString())); |
|
179 break; |
|
180 case CaptureRequest::RequestTypeLongKey : |
|
181 mKeyCapture->captureLongKey(request.mKey, request.mModifiersMap, request.mModifier, request.mLongFlags); |
|
182 addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString())); |
|
183 break; |
|
184 case CaptureRequest::RequestTypeKeyUpAndDowns : |
|
185 mKeyCapture->captureKeyUpAndDowns(request.mKey, request.mModifiersMap, request.mModifier ); |
|
186 addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString())); |
|
187 break; |
|
188 case CaptureRequest::RequestTypeCancelKey : |
|
189 mKeyCapture->cancelCaptureKey(request.mKey, request.mModifiersMap, request.mModifier ); |
|
190 addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString())); |
|
191 break; |
|
192 case CaptureRequest::RequestTypeCancelLongKey : |
|
193 mKeyCapture->cancelCaptureLongKey(request.mKey, request.mModifiersMap, request.mModifier, request.mLongFlags); |
|
194 addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString())); |
|
195 break; |
|
196 case CaptureRequest::RequestTypeCancelKeyUpAndDowns : |
|
197 mKeyCapture->cancelCaptureKeyUpAndDowns(request.mKey, request.mModifiersMap, request.mModifier ); |
|
198 addTextLine(QString("%1:%2\n").arg(request.toString()).arg(mKeyCapture->errorString())); |
|
199 break; |
|
200 default: |
|
201 break; |
|
202 } |
|
203 |
|
204 TX_EXIT |
|
205 } |
|
206 |
|
207 void KeyCaptureTestApp::addTextLine(QString aText) |
|
208 { |
|
209 TX_LOG_ARGS( QString("aText=%1").arg(aText)); |
|
210 if ( !aText.endsWith("\n")) |
|
211 aText = aText + "\n"; |
|
212 QString msg = mTextArea->toPlainText(); |
|
213 msg = aText + msg; |
|
214 mTextArea->setPlainText(msg); |
|
215 } |
|
216 |
|
217 bool KeyCaptureTestApp::event(QEvent *ev) |
|
218 { |
|
219 processEvent(ev); |
|
220 return QMainWindow::event(ev); |
|
221 } |
|
222 |
|
223 bool KeyCaptureTestApp::eventFilter(QObject *o, QEvent *ev) |
|
224 { |
|
225 processEvent(ev); |
|
226 return QMainWindow::eventFilter(o, ev); |
|
227 } |
|
228 |
|
229 void KeyCaptureTestApp::processEvent(QEvent *ev) |
|
230 { |
|
231 if (ev){ |
|
232 if (ev->type() == QEvent::KeyPress){ |
|
233 QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev); |
|
234 QString keyName = mappingPtr->name(static_cast<Qt::Key>(keyEvent->key())); |
|
235 |
|
236 addTextLine(QString("KeyPress:%1\n").arg(keyName)); |
|
237 } else if (ev->type() == QEvent::KeyRelease){ |
|
238 QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev); |
|
239 QString keyName = mappingPtr->name(static_cast<Qt::Key>(keyEvent->key())); |
|
240 |
|
241 addTextLine(QString("KeyRelease:%1\n").arg(keyName)); |
|
242 } else if (ev->type() == XQKeyCapture::remoteEventType_KeyPress()){ |
|
243 QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev); |
|
244 |
|
245 QString keyName = mappingPtr->name(static_cast<Qt::Key>(keyEvent->key())); |
|
246 |
|
247 addTextLine(QString("KeyPress:%1\n").arg(keyName)); |
|
248 addTextLine(QString("Native virtual key:%1\n").arg((int)keyEvent->nativeVirtualKey())); |
|
249 } else if (ev->type() == XQKeyCapture::remoteEventType_KeyRelease()){ |
|
250 QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev); |
|
251 |
|
252 QString keyName = mappingPtr->name(static_cast<Qt::Key>(keyEvent->key())); |
|
253 |
|
254 addTextLine(QString("KeyRelease:%1\n").arg(keyName)); |
|
255 addTextLine(QString("Native virtual key:%1\n").arg((int)keyEvent->nativeVirtualKey())); |
|
256 } |
|
257 } |
|
258 } |
|
259 |
|
260 void KeyCaptureTestApp::enableRemBasic(bool enable) |
|
261 { |
|
262 if (enable) { |
|
263 addTextLine("Remote Basic enabled"); |
|
264 QFlags<XQKeyCapture::CapturingFlag> flags = XQKeyCapture::CaptureNone; |
|
265 if (toggleRemoteExtEvents->isChecked()) |
|
266 flags = XQKeyCapture::CaptureEnableRemoteExtEvents; |
|
267 if (toggleRemoteCallHandlingEx->isChecked()) |
|
268 flags |= XQKeyCapture::CaptureCallHandlingExt; |
|
269 mKeyCapture->captureRemoteKeys(flags |= XQKeyCapture::CaptureBasic); |
|
270 } else { |
|
271 addTextLine("Remote Basic disabled"); |
|
272 mKeyCapture->cancelCaptureRemoteKeys(XQKeyCapture::CaptureBasic); |
|
273 } |
|
274 } |
|
275 |
|
276 void KeyCaptureTestApp::enableRemCallHandlingEx(bool enable) |
|
277 { |
|
278 if (enable) { |
|
279 addTextLine("Remote Call Handling Ext. enabled"); |
|
280 QFlags<XQKeyCapture::CapturingFlag> flags = XQKeyCapture::CaptureNone; |
|
281 if (toggleRemoteExtEvents->isChecked()) |
|
282 flags = XQKeyCapture::CaptureEnableRemoteExtEvents; |
|
283 if (toggleRemoteBasic->isChecked()) |
|
284 flags |= XQKeyCapture::CaptureBasic; |
|
285 mKeyCapture->captureRemoteKeys(flags | XQKeyCapture::CaptureCallHandlingExt); |
|
286 } else { |
|
287 addTextLine("Remote Call Handling Ext. disabled"); |
|
288 mKeyCapture->cancelCaptureRemoteKeys(XQKeyCapture::CaptureCallHandlingExt); |
|
289 } |
|
290 } |
|
291 |
|
292 void KeyCaptureTestApp::enableRemoteExtEvents(bool enable) |
|
293 { |
|
294 if (enable) { |
|
295 addTextLine("Remote Events Ext. enabled"); |
|
296 QFlags<XQKeyCapture::CapturingFlag> flags = XQKeyCapture::CaptureNone; |
|
297 if (toggleRemoteCallHandlingEx->isChecked()) |
|
298 flags = XQKeyCapture::CaptureCallHandlingExt; |
|
299 if (toggleRemoteBasic->isChecked()) |
|
300 flags |= XQKeyCapture::CaptureBasic; |
|
301 mKeyCapture->captureRemoteKeys(flags | XQKeyCapture::CaptureEnableRemoteExtEvents); |
|
302 } else { |
|
303 addTextLine("Remote Events Ext. disabled"); |
|
304 mKeyCapture->cancelCaptureRemoteKeys(XQKeyCapture::CaptureEnableRemoteExtEvents); |
|
305 } |
|
306 } |
|
307 |
|
308 void KeyCaptureTestApp::remoteAll(bool enable) |
|
309 { |
|
310 Q_UNUSED(enable); |
|
311 toggleRemoteBasic->setChecked(true); |
|
312 toggleRemoteCallHandlingEx->setChecked(true); |
|
313 toggleRemoteExtEvents->setChecked(true); |
|
314 addTextLine("Remote: enable all"); |
|
315 mKeyCapture->captureRemoteKeys(XQKeyCapture::CaptureCallHandlingExt | XQKeyCapture::CaptureBasic | |
|
316 XQKeyCapture::CaptureEnableRemoteExtEvents); |
|
317 } |
|
318 |
|
319 void KeyCaptureTestApp::remoteNone(bool enable) |
|
320 { |
|
321 Q_UNUSED(enable); |
|
322 toggleRemoteBasic->setChecked(false); |
|
323 toggleRemoteCallHandlingEx->setChecked(false); |
|
324 toggleRemoteExtEvents->setChecked(false); |
|
325 addTextLine("Remote: disable all"); |
|
326 mKeyCapture->cancelCaptureRemoteKeys(XQKeyCapture::CaptureCallHandlingExt | XQKeyCapture::CaptureBasic | |
|
327 XQKeyCapture::CaptureEnableRemoteExtEvents); |
|
328 } |
|