git.zerfleddert.de Git - proxmark3-svn/blob

1 //-----------------------------------------------------------------------------

3 //

4 // This code is licensed to you under the terms of the GNU GPL, version 2 or,

5 // at your option, any later version. See the LICENSE.txt file for the text of

6 // the license.

7 //-----------------------------------------------------------------------------

8 // GUI (QT)

9 //-----------------------------------------------------------------------------

11 #include <iostream>

12 #include <QPainterPath>

13 #include <QBrush>

14 #include <QPen>

15 #include <QTimer>

16 #include <QCloseEvent>

17 #include <QMouseEvent>

18 #include <QKeyEvent>

19 #include <math.h>

20 #include <limits.h>

21 #include <stdio.h>

22 #include "proxguiqt.h"

23 #include "proxgui.h"

25 int GridOffset= 0;

26 bool GridLocked= 0;

27 int startMax;

28 int PageWidth;

 void ProxGuiQT::ShowGraphWindow(void)

31 {

32 emit ShowGraphWindowSignal();

33 }

 void ProxGuiQT::RepaintGraphWindow(void)

36 {

37 emit RepaintGraphWindowSignal();

38 }

 void ProxGuiQT::HideGraphWindow(void)

41 {

42 emit HideGraphWindowSignal();

43 }

 void ProxGuiQT::_ShowGraphWindow(void)

46 {

47 if(!plotapp)

48 return;

50 if (!plotwidget)

51 plotwidget = new ProxWidget();

53 plotwidget->show();

54 }

 void ProxGuiQT::_RepaintGraphWindow(void)

57 {

58 if (!plotapp || !plotwidget)

59 return;

61 plotwidget->update();

62 }

 void ProxGuiQT::_HideGraphWindow(void)

65 {

66 if (!plotapp || !plotwidget)

67 return;

69 plotwidget->hide();

70 }

 void ProxGuiQT::MainLoop()

73 {

         plotapp = new QApplication(argc, argv);

         connect(this, SIGNAL(ShowGraphWindowSignal()), this, SLOT(_ShowGraphWindow()));

         connect(this, SIGNAL(RepaintGraphWindowSignal()), this, SLOT(_RepaintGraphWindow()));

         connect(this, SIGNAL(HideGraphWindowSignal()), this, SLOT(_HideGraphWindow()));

80 plotapp->exec();

81 }

 ProxGuiQT::ProxGuiQT(int argc, char **argv) : plotapp(NULL), plotwidget(NULL),

         argc(argc), argv(argv)

85 {

86 }

 ProxGuiQT::~ProxGuiQT(void)

89 {

90 if (plotwidget) {

91 delete plotwidget;

92 plotwidget = NULL;

93 }

95 if (plotapp) {

96 plotapp->quit();

97 delete plotapp;

98 plotapp = NULL;

99 }

100 }

101

 void ProxWidget::paintEvent(QPaintEvent *event)

103 {

104 QPainter painter(this);

         QPainterPath penPath, whitePath, greyPath, lightgreyPath, cursorAPath, cursorBPath, cursorCPath, cursorDPath;

106 QRect r;

         QBrush brush(QColor(100, 255, 100));

         QPen pen(QColor(100, 255, 100));

109

         painter.setFont(QFont("Arial", 10));

111

         if(GraphStart < 0) {

113 GraphStart = 0;

114 }

115

116 if (CursorAPos > GraphTraceLen)

117 CursorAPos= 0;

118 if(CursorBPos > GraphTraceLen)

119 CursorBPos= 0;

120 if(CursorCPos > GraphTraceLen)

121 CursorCPos= 0;

122 if(CursorDPos > GraphTraceLen)

123 CursorDPos= 0;

124

125 r = rect();

126

         painter.fillRect(r, QColor(0, 0, 0));

128

         whitePath.moveTo(r.left() + 40, r.top());

         whitePath.lineTo(r.left() + 40, r.bottom());

131

         int zeroHeight = r.top() + (r.bottom() - r.top()) / 2;

133

         greyPath.moveTo(r.left(), zeroHeight);

         greyPath.lineTo(r.right(), zeroHeight);

         painter.setPen(QColor(100, 100, 100));

137 painter.drawPath(greyPath);

138

         PageWidth= (int)((r.right() - r.left() - 40) / GraphPixelsPerPoint);

140

141 // plot X and Y grid lines

142 int i;

         if ((PlotGridX > 0) && ((PlotGridX * GraphPixelsPerPoint) > 1)) {

                 for(i = 40 + (GridOffset * GraphPixelsPerPoint); i < r.right(); i += (int)(PlotGridX * GraphPixelsPerPoint)) {

145 //SelectObject(hdc, GreyPenLite);

146 //MoveToEx(hdc, r.left + i, r.top, NULL);

147 //LineTo(hdc, r.left + i, r.bottom);

                         lightgreyPath.moveTo(r.left()+i,r.top());

                         lightgreyPath.lineTo(r.left()+i,r.bottom());

150 painter.drawPath(lightgreyPath);

151 }

152 }

         if ((PlotGridY > 0) && ((PlotGridY * GraphPixelsPerPoint) > 1)){

                 for(i = 0; i < ((r.top() + r.bottom())>>1); i += (int)(PlotGridY * GraphPixelsPerPoint)) {

                         lightgreyPath.moveTo(r.left() + 40,zeroHeight + i);

                         lightgreyPath.lineTo(r.right(),zeroHeight + i);

157 painter.drawPath(lightgreyPath);

                         lightgreyPath.moveTo(r.left() + 40,zeroHeight - i);

                         lightgreyPath.lineTo(r.right(),zeroHeight - i);

160 painter.drawPath(lightgreyPath);

161 }

162 }

163

         startMax = (GraphTraceLen - (int)((r.right() - r.left() - 40) / GraphPixelsPerPoint));

         if(startMax < 0) {

166 startMax = 0;

167 }

168 if(GraphStart > startMax) {

169 GraphStart = startMax;

170 }

171

172 int absYMax = 1;

173

         for(i = GraphStart; ; i++) {

175 if(i >= GraphTraceLen) {

176 break;

177 }

                 if(fabs((double)GraphBuffer[i]) > absYMax) {

                         absYMax = (int)fabs((double)GraphBuffer[i]);

180 }

                 int x = 40 + (int)((i - GraphStart)*GraphPixelsPerPoint);

                 if(x > r.right()) {

183 break;

184 }

185 }

186

         absYMax = (int)(absYMax*1.2 + 1);

188

189 // number of points that will be plotted

         int span = (int)((r.right() - r.left()) / GraphPixelsPerPoint);

191 // one label every 100 pixels, let us say

         int labels = (r.right() - r.left() - 40) / 100;

         if(labels <= 0) labels = 1;

194 int pointsPerLabel = span / labels;

         if(pointsPerLabel <= 0) pointsPerLabel = 1;

196

197 int yMin = INT_MAX;

198 int yMax = INT_MIN;

199 int yMean = 0;

200 int n = 0;

201

         for(i = GraphStart; ; i++) {

203 if(i >= GraphTraceLen) {

204 break;

205 }

                 int x = 40 + (int)((i - GraphStart)*GraphPixelsPerPoint);

                 if(x > r.right() + GraphPixelsPerPoint) {

208 break;

209 }

210

211 int y = GraphBuffer[i];

212 if(y < yMin) {

213 yMin = y;

214 }

215 if(y > yMax) {

216 yMax = y;

217 }

218 yMean += y;

219 n++;

220

                 y = (y * (r.top() - r.bottom()) / (2*absYMax)) + zeroHeight;

222 if(i == GraphStart) {

                         penPath.moveTo(x, y);

224 } else {

                         penPath.lineTo(x, y);

226 }

227

                 if(GraphPixelsPerPoint > 10) {

                         QRect f(QPoint(x - 3, y - 3),QPoint(x + 3, y + 3));

                         painter.fillRect(f, brush);

231 }

232

                 if(((i - GraphStart) % pointsPerLabel == 0) && i != GraphStart) {

                         whitePath.moveTo(x, zeroHeight - 3);

                         whitePath.lineTo(x, zeroHeight + 3);

236

237 char str[100];

                         sprintf(str, "+%d", (i - GraphStart));

239

                         painter.setPen(QColor(255, 255, 255));

241 QRect size;

                         QFontMetrics metrics(painter.font());

                         size = metrics.boundingRect(str);

                         painter.drawText(x - (size.right() - size.left()), zeroHeight + 9, str);

245

                         penPath.moveTo(x,y);

247 }

248

                 if(i == CursorAPos || i == CursorBPos || i == CursorCPos || i == CursorDPos) {

250 QPainterPath *cursorPath;

251

252 if(i == CursorAPos) {

253 cursorPath = &cursorAPath;

                         } else if (i == CursorBPos) {

255 cursorPath = &cursorBPath;

                         } else if (i == CursorCPos) {

257 cursorPath = &cursorCPath;

258 } else {

259 cursorPath = &cursorDPath;

260 }

                         cursorPath->moveTo(x, r.top());

                         cursorPath->lineTo(x, r.bottom());

                         penPath.moveTo(x, y);

264 }

265 }

266

         if(n != 0) {

268 yMean /= n;

269 }

270

         painter.setPen(QColor(255, 255, 255));

272 painter.drawPath(whitePath);

273 painter.setPen(pen);

274 painter.drawPath(penPath);

         painter.setPen(QColor(255, 255, 0));

276 painter.drawPath(cursorAPath);

         painter.setPen(QColor(255, 0, 255));

278 painter.drawPath(cursorBPath);

         painter.setPen(QColor(255, 153, 0)); //orange

280 painter.drawPath(cursorCPath);

         painter.setPen(QColor(0, 0, 205)); //light blue

282 painter.drawPath(cursorDPath);

283

284 char str[200];

         sprintf(str, "@%d   max=%d min=%d mean=%d n=%d/%d    dt=%d [%.3f] zoom=%.3f CursorA=%d [%d] CursorB=%d [%d]    GridX=%d GridY=%d (%s)",

                         GraphStart, yMax, yMin, yMean, n, GraphTraceLen,

                         CursorBPos - CursorAPos, (CursorBPos - CursorAPos)/CursorScaleFactor,GraphPixelsPerPoint,CursorAPos,GraphBuffer[CursorAPos],CursorBPos,GraphBuffer[CursorBPos],PlotGridXdefault,PlotGridYdefault,GridLocked?"Locked":"Unlocked");

288

         painter.setPen(QColor(255, 255, 255));

         painter.drawText(50, r.bottom() - 20, str);

291 }

292

 ProxWidget::ProxWidget(QWidget *parent) : QWidget(parent), GraphStart(0), GraphPixelsPerPoint(1)

294 {

         resize(600, 300);

296

         QPalette palette(QColor(0,0,0,0));

         palette.setColor(QPalette::WindowText, QColor(255,255,255));

         palette.setColor(QPalette::Text, QColor(255,255,255));

         palette.setColor(QPalette::Button, QColor(100, 100, 100));

301 setPalette(palette);

302 setAutoFillBackground(true);

303 CursorAPos = 0;

304 CursorBPos = 0;

305 }

306

 void ProxWidget::closeEvent(QCloseEvent *event)

308 {

309 event->ignore();

310 this->hide();

311 }

312

 void ProxWidget::mouseMoveEvent(QMouseEvent *event)

314 {

         int x = event->x();

316 x -= 40;

         x = (int)(x / GraphPixelsPerPoint);

318 x += GraphStart;

         if((event->buttons() & Qt::LeftButton)) {

320 CursorAPos = x;

         } else if (event->buttons() & Qt::RightButton) {

322 CursorBPos = x;

323 }

324

325

326 this->update();

327 }

328

 void ProxWidget::keyPressEvent(QKeyEvent *event)

330 {

331 int offset;

332 int gridchanged;

333

334 gridchanged= 0;

335

         if(event->modifiers() & Qt::ShiftModifier) {

337 if (PlotGridX)

338 offset= PageWidth - (PageWidth % PlotGridX);

339 else

340 offset= PageWidth;

341 } else

                 if(event->modifiers() & Qt::ControlModifier)

343 offset= 1;

344 else

                         offset= (int)(20 / GraphPixelsPerPoint);

346

         switch(event->key()) {

348 case Qt::Key_Down:

                         if(GraphPixelsPerPoint <= 50) {

350 GraphPixelsPerPoint *= 2;

351 }

352 break;

353

354 case Qt::Key_Up:

                         if(GraphPixelsPerPoint >= 0.02) {

356 GraphPixelsPerPoint /= 2;

357 }

358 break;

359

360 case Qt::Key_Right:

                         if(GraphPixelsPerPoint < 20) {

                                 if (PlotGridX && GridLocked && GraphStart < startMax){

363 GridOffset -= offset;

364 GridOffset %= PlotGridX;

365 gridchanged= 1;

366 }

367 GraphStart += offset;

368 } else {

                                 if (PlotGridX && GridLocked && GraphStart < startMax){

370 GridOffset--;

371 GridOffset %= PlotGridX;

372 gridchanged= 1;

373 }

374 GraphStart++;

375 }

                         if(GridOffset < 0) {

377 GridOffset += PlotGridX;

378 }

379 if (gridchanged)

380 if (GraphStart > startMax) {

381 GridOffset += (GraphStart - startMax);

382 GridOffset %= PlotGridX;

383 }

384 break;

385

386 case Qt::Key_Left:

                         if(GraphPixelsPerPoint < 20) {

                                 if (PlotGridX && GridLocked && GraphStart > 0){

389 GridOffset += offset;

390 GridOffset %= PlotGridX;

391 gridchanged= 1;

392 }

393 GraphStart -= offset;

394 } else {

                                 if (PlotGridX && GridLocked && GraphStart > 0){

396 GridOffset++;

397 GridOffset %= PlotGridX;

398 gridchanged= 1;

399 }

400 GraphStart--;

401 }

402 if (gridchanged){

                                 if (GraphStart < 0)

404 GridOffset += GraphStart;

                                 if(GridOffset < 0)

406 GridOffset += PlotGridX;

407 GridOffset %= PlotGridX;

408 }

409 break;

410

411 case Qt::Key_G:

412 if(PlotGridX || PlotGridY) {

413 PlotGridX= 0;

414 PlotGridY= 0;

415 } else {

416 PlotGridX= PlotGridXdefault;

417 PlotGridY= PlotGridYdefault;

418 }

419 break;

420

421 case Qt::Key_H:

                         puts("Plot Window Keystrokes:\n");

                         puts(" Key                      Action\n");

424 puts(" DOWN Zoom in");

425 puts(" G Toggle grid display");

426 puts(" H Show help");

427 puts(" L Toggle lock grid relative to samples");

428 puts(" LEFT Move left");

429 puts(" <CTL>LEFT Move left 1 sample");

430 puts(" <SHIFT>LEFT Page left");

431 puts(" LEFT-MOUSE-CLICK Set yellow cursor");

432 puts(" Q Hide window");

433 puts(" RIGHT Move right");

434 puts(" <CTL>RIGHT Move right 1 sample");

435 puts(" <SHIFT>RIGHT Page right");

436 puts(" RIGHT-MOUSE-CLICK Set purple cursor");

437 puts(" UP Zoom out");

438 puts("");

                         puts("Use client window 'data help' for more plot commands\n");

440 break;

441

442 case Qt::Key_L:

443 GridLocked= !GridLocked;

444 break;

445

446 case Qt::Key_Q:

447 this->hide();

448 break;

449

450 default:

                         QWidget::keyPressEvent(event);

452 return;

453 break;

454 }

455

456 this->update();

457 }