MNE-CPP  beta 0.1
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
newrealtimemultisamplearraywidget.cpp
1 //=============================================================================================================
36 //ToDo Paint to render area
37 
38 //*************************************************************************************************************
39 //=============================================================================================================
40 // INCLUDES
41 //=============================================================================================================
42 
43 #include "newrealtimemultisamplearraywidget.h"
44 //#include "annotationwindow.h"
45 
47 
48 
49 //*************************************************************************************************************
50 //=============================================================================================================
51 // Eigen INCLUDES
52 //=============================================================================================================
53 
54 #include <Eigen/Core>
55 
56 
57 //*************************************************************************************************************
58 //=============================================================================================================
59 // STL INCLUDES
60 //=============================================================================================================
61 
62 #include <math.h>
63 
64 
65 //*************************************************************************************************************
66 //=============================================================================================================
67 // QT INCLUDES
68 //=============================================================================================================
69 
70 #include <QPaintEvent>
71 #include <QPainter>
72 #include <QTimer>
73 #include <QTime>
74 
75 #include <QMessageBox>
76 
77 #include <QDebug>
78 
79 //*************************************************************************************************************
80 //=============================================================================================================
81 // USED NAMESPACES
82 //=============================================================================================================
83 
84 using namespace XDISPLIB;
85 using namespace XMEASLIB;
86 
87 
88 //=============================================================================================================
92 enum Tool
93 {
94  Freeze = 0,
95  Annotation = 1
96 };
97 
98 
99 //*************************************************************************************************************
100 //=============================================================================================================
101 // DEFINE MEMBER METHODS
102 //=============================================================================================================
103 
104 NewRealTimeMultiSampleArrayWidget::NewRealTimeMultiSampleArrayWidget(QSharedPointer<NewRealTimeMultiSampleArray> pRTMSA_New, QSharedPointer<QTime> &pTime, QWidget* parent)
105 : NewMeasurementWidget(parent)
106 , m_pRTMSA_New(pRTMSA_New)
107 , m_uiMaxNumChannels(10)
108 , m_uiFirstChannel(0)
109 , m_bMeasurement(false)
110 , m_bPosition(true)
111 , m_bFrozen(false)
112 , m_bScaling(false)
113 , m_bToolInUse(false)
114 , m_dSampleWidth(1.0)
115 , m_dPosX(0.0)
116 , m_dPosY(0)
117 , m_bStartFlag(true)
118 , m_ucToolIndex(0)
119 , m_pTimerToolDisplay(0)
120 , m_pTimerUpdate(new QTimer(this))
121 , m_pTime(pTime)
122 , m_pTimeCurrentDisplay(0)
123 {
124  ui.setupUi(this);
125  ui.m_qLabel_Tool->hide();
126 
127  // Add tool names to vector
128  m_vecTool.push_back("Freeze");
129  m_vecTool.push_back("Annotation");
130 
131  // Start timer
132  connect(m_pTimerUpdate.data(), SIGNAL(timeout()), this, SLOT(update())); //ToDo Qt5 syntax
133 
134  m_pTimerUpdate->start(25);
135 
136  //connect(ui.m_qSpinBox_Max, SIGNAL(valueChanged(int)), this, SLOT(maxValueChanged(int)));
137  //connect(ui.m_qSpinBox_Min, SIGNAL(valueChanged(int)), this, SLOT(minValueChanged(int)));
138 
139  setMouseTracking(true);
140 }
141 
142 
143 //*************************************************************************************************************
144 
146 {
147  // Clear sampling rate vector
148  NewRealTimeMultiSampleArrayWidget::s_listSamplingRates.clear();
149 }
150 
151 
152 //*************************************************************************************************************
153 
154 void NewRealTimeMultiSampleArrayWidget::actualize()
155 {
156  m_dPosY = ui.m_qFrame->pos().y();//+0.5*ui.m_qFrame->height();
157 
158 
159  // Compute scaling factor
160  m_fScaleFactor = ui.m_qFrame->height()/static_cast<float>(m_pRTMSA_New->chInfo()[0].getMaxValue()-m_pRTMSA_New->chInfo()[0].getMinValue());
161 
162  // Compute the middle of RTSA values
163  m_dMiddle = 0.5*(m_pRTMSA_New->chInfo()[0].getMinValue()+m_pRTMSA_New->chInfo()[0].getMaxValue())*m_fScaleFactor;
164 
165  //*********************************************************************************************************
166  //=========================================================================================================
167  // Compute new sample width in order to synchronize all RTSA
168  //=========================================================================================================
169 
170 // if((m_pRTMSA_New->getSamplingRate() == 0) || (DisplayManager::getRTSAWidgets().size() == 0))
171 // return;
172  if((m_pRTMSA_New->getSamplingRate() == 0))
173  return;
174 
175  // Add current sampling rate to s_listSamplingRates
176  NewRealTimeMultiSampleArrayWidget::s_listSamplingRates << m_pRTMSA_New->getSamplingRate();
177 
178  // Find maximal sampling rate in s_listSamplingRates
179  double dMax = 0;
180  foreach (double value, s_listSamplingRates)
181  dMax = value > dMax ? value : dMax;
182 
183 // // Set new sample widths
184 // foreach(NewRealTimeMultiSampleArrayWidget* pRTMSAW, DisplayManager::getRTMSANewWidgets().values())
185 // pRTMSAW->m_dSampleWidth = dMax/pRTMSAW->m_pRTMSA_New->getSamplingRate();
186 }
187 
188 
189 //*************************************************************************************************************
190 
191 void NewRealTimeMultiSampleArrayWidget::stopAnnotation()
192 {
193  m_bToolInUse = !m_bToolInUse;
194 }
195 
196 
197 //*************************************************************************************************************
198 
199 void NewRealTimeMultiSampleArrayWidget::maxValueChanged(double maxValue)
200 {
201 // m_pRTMSA_New->setMaxValue(maxValue);
202  for(quint32 i = 0; i < m_pRTMSA_New->getNumChannels(); ++i)
203  m_pRTMSA_New->chInfo()[i].setMaxValue(maxValue);
204 
205 // ui.m_qLabel_MaxValue->setText(QString::number(maxValue));
206  actualize();
207 }
208 
209 
210 //*************************************************************************************************************
211 
212 void NewRealTimeMultiSampleArrayWidget::minValueChanged(double minValue)
213 {
214 // m_pRTMSA_New->setMinValue(minValue);
215  for(quint32 i = 0; i < m_pRTMSA_New->getNumChannels(); ++i)
216  m_pRTMSA_New->chInfo()[i].setMaxValue(minValue);
217 
218 // ui.m_qLabel_MinValue->setText(QString::number(minValue));
219  actualize();
220 }
221 
222 
223 //*************************************************************************************************************
224 
226 {
227  //ToDo put most of this in a parallel thread -> to big for process in notifier
228  if(m_pRTMSA_New->getMultiSampleArray().size() > 0)
229  {
230  VectorXd vecValue;
231  QVector< VectorXd > matSamples = m_pRTMSA_New->getMultiSampleArray();
232 
233  if(m_bStartFlag)
234  {
235  m_qMutex.lock();
236  m_iSamples = (qint32)floor((ui.m_qFrame->width() - m_dPosX) / m_dSampleWidth);
237 
238  for(unsigned int k = 0; k < m_uiNumChannels; ++k)
239  {
240  m_qVecPolygonF[k].clear();
241 
242  for(qint32 l = 0; l < m_iSamples; ++l)
243  m_qVecPolygonF[k].append(QPointF(m_dPosition+l*m_dSampleWidth, 0));
244  }
245  m_qMutex.unlock();
246  m_bStartFlag = false;
247 
248  m_pTimeCurrentDisplay->setHMS(m_pTime->hour(),m_pTime->minute(),m_pTime->second(),m_pTime->msec());
249  }
250 
251 
252  //Move all samples forward
253  qint32 t_iSamplesToMove = m_pRTMSA_New->getMultiArraySize();
254 
255  if(m_iSamples - t_iSamplesToMove > 0)
256  for(quint32 k = 0; k < m_uiNumChannels; ++k)
257  for(qint32 i = 0; i < m_iSamples - t_iSamplesToMove; ++i)
258  m_qVecPolygonF[k][i].setY(m_qVecPolygonF[k][i+t_iSamplesToMove].ry());
259 
260 
261  qint32 t_iNewSampleStart = m_iSamples - m_pRTMSA_New->getMultiArraySize();
262 
263  for(unsigned char i = 0; i < m_pRTMSA_New->getMultiArraySize(); ++i)//ToDo maybe downsampling here increase step size
264  {
265  vecValue = (matSamples[i].block(m_uiFirstChannel,0,m_uiNumChannels,1).array()*m_fScaleFactor);
266 
267  m_qMutex.lock();
268  for(unsigned int k = 0; k < m_uiNumChannels; ++k)
269  m_qVecPolygonF[k][t_iNewSampleStart+i].setY(vecValue[k]);
270  m_qMutex.unlock();
271 
272  if(!m_bFrozen)
273  m_pTimeCurrentDisplay->setHMS(m_pTime->hour(),m_pTime->minute(),m_pTime->second(),m_pTime->msec());
274 
275  // if((dPositionDifference >= 0) || m_bStartFlag)
276  // {
277  // if(m_bStartFlag)
278  // dPositionDifference = 0;
279 
280  // m_qMutex.lock();
283 
284  // m_dPosition = m_dPosX + dPositionDifference;
285 
288 
289  // for(unsigned int k = 0; k < m_uiNumChannels; ++k)
290  // {
291  // m_qVecPainterPath[k] = QPainterPath();
292  // m_qVecPainterPath[k].moveTo(m_dPosition, m_dPosY-vecValue[k]-k*10); // ToDo offset over PosY has to be relative
293  // }
294  // m_qMutex.unlock();
295  // m_bStartFlag = false;
296 
297  // if(!m_bFrozen)
298  // m_pTimeCurrentDisplay->setHMS(m_pTime->hour(),m_pTime->minute(),m_pTime->second(),m_pTime->msec());
299  // }
300 
301  // else
302  // {
303  // m_qMutex.lock();
306  // for(unsigned int k = 0; k < m_uiNumChannels; ++k)
307  // m_qVecPainterPath[k].lineTo(m_dPosition, m_dPosY-vecValue[k]-k*10); // ToDo offset over PosY vec has to be relative
308  // m_qMutex.unlock();
309  // }
310 
311  // m_dPosition = m_dPosition + m_dSampleWidth;
312  }
313  }
314  else
315  qWarning() << "NewRealTimeMultiSampleArrayWidget::update; getMultiArraySize():" << m_pRTMSA_New->getMultiArraySize() << "getMultiSampleArray():" << m_pRTMSA_New->getMultiSampleArray().size();
316 }
317 
318 
319 //*************************************************************************************************************
320 
322 {
323  ui.m_qLabel_Caption->setText(m_pRTMSA_New->getName());
324 // ui.m_qLabel_MinValue->setText(QString::number(m_pRTSM->getMinValue()));
325 // ui.m_qLabel_MaxValue->setText(QString::number(m_pRTSM->getMaxValue()));
326 
327  m_uiNumChannels = m_pRTMSA_New->getNumChannels() > m_uiMaxNumChannels ? m_uiMaxNumChannels : m_pRTMSA_New->getNumChannels();
328 
329  m_dMinValue_init = m_pRTMSA_New->chInfo()[0].getMinValue();
330  m_dMaxValue_init = m_pRTMSA_New->chInfo()[0].getMaxValue();
331 
332 
333  // Set drawing start position in X and Y direction
334  m_dPosX = ui.m_qFrame->pos().x()+1;
335  m_dPosition = m_dPosX;
336 // m_dPosY = ui.m_qFrame->pos().y()+0.5*ui.m_qFrame->height();// set to actualize
337 
338 // m_qPainterPath = QPainterPath();
339 // m_qPainterPathTest = QPainterPath();
340 
341 
342 
343 
344 // m_qVecPainterPath.clear();
345 // for(unsigned int i = 0; i < m_uiNumChannels; ++i)
346 // m_qVecPainterPath.push_back(QPainterPath());
347 
348 
349  m_qVecPolygonF.clear();
350  for(unsigned int i = 0; i < m_uiNumChannels; ++i)
351  m_qVecPolygonF.push_back(QPolygonF());
352 
353 
354  m_bStartFlag = true;
355 
356  m_pTimeCurrentDisplay = QSharedPointer<QTime>(new QTime(0, 0));
357 
358  actualize();
359 }
360 
361 
362 //*************************************************************************************************************
363 
365 {
366  QPainter painter(this);
367 
368 
369 // //*************************************************************************************************************
370 // //=============================================================================================================
371 // // Draw white background
372 // //=============================================================================================================
373 //
374 // painter.setBrush(Qt::white);
375 // painter.drawRect(0, 0, width(), height());
376 
377 
378  painter.setPen(QPen(Qt::gray, 1, Qt::DashLine));
379 
380  //*************************************************************************************************************
381  //=============================================================================================================
382  // Draw grid in X direction (each 100ms)
383  //=============================================================================================================
384 
385  double dNumPixelsX = m_pRTMSA_New->getSamplingRate()/10.0f;
386  double dMinMaxDifference = static_cast<double>(m_pRTMSA_New->chInfo()[0].getMaxValue()-m_pRTMSA_New->chInfo()[0].getMinValue());
387  double dActualPosX = 0.0;
388  unsigned short usNumOfGridsX = (unsigned short)(ui.m_qFrame->width()/dNumPixelsX);
389  unsigned short usPosY = ui.m_qFrame->pos().y()+1;
390  unsigned short usPosX = ui.m_qFrame->pos().x()+1;
391  unsigned short usHeight = ui.m_qFrame->height()-2;
392  unsigned short usWidth = ui.m_qFrame->width()-2;
393 
394  for(unsigned short i = 1; i <= usNumOfGridsX; ++i)
395  {
396  dActualPosX = m_dPosX+i*dNumPixelsX;
397  painter.drawLine((int)dActualPosX, usPosY, (int)dActualPosX, usPosY+usHeight);
398  }
399 
400 
401  //*************************************************************************************************************
402  //=============================================================================================================
403  // Draw grid in Y direction
404  //=============================================================================================================
405 
406  double exponent = (int)floor(log10(dMinMaxDifference))-1;//math.h
407  double dim = pow(10.0, exponent);//respectively at 0.001; 0.01, 0.1, 1, 10, 100
408 
409  int NumOfLines = (int)floor(dMinMaxDifference/(dim*5));
410 
411  double dDifferenceToFirstLine = (m_pRTMSA_New->chInfo()[0].getMaxValue()-floor(m_pRTMSA_New->chInfo()[0].getMaxValue()/dim)*dim);
412 
413  double dNumPixelsY = usHeight/NumOfLines;//10.0f;
414  double dActualPosY = usPosY + dDifferenceToFirstLine * (usHeight/dMinMaxDifference);
415 
416  for(unsigned char i = 1; i <= NumOfLines; ++i)
417  {
418  painter.drawLine((int)m_dPosX, (int)dActualPosY, usWidth, (int)dActualPosY);
419  dActualPosY += dNumPixelsY;
420  }
421 
422  //Paint middle value
423 // painter.setPen(QPen(Qt::gray, 1, Qt::SolidLine));
424 // painter.drawText(usWidth-75, usHeight/2, tr("%1%2").arg(m_dMiddle, 0, 'f', 2).arg(m_pRTSM->getUnit()));
425 // painter.setPen(QPen(Qt::gray, 1, Qt::DotLine));
426 // painter.drawLine(m_dPosX, usHeight/2, usWidth, usHeight/2);
427 
428  painter.setPen(QPen(Qt::darkBlue, 1, Qt::SolidLine));
429  painter.setRenderHint(QPainter::Antialiasing);
430 
431 
432  //*************************************************************************************************************
433  //=============================================================================================================
434  // Draw real time curve respectively frozen curve
435  //=============================================================================================================
436 
437  painter.save();
438  qint32 t_iDist = ui.m_qFrame->height() / (m_uiNumChannels+1);
439 
440  if(m_bFrozen)
441  {
442  painter.setPen(QPen(Qt::darkGray, 1, Qt::SolidLine));
443 
444  for(quint32 k = 0; k < m_uiNumChannels; ++k)
445  {
446  painter.translate(0, t_iDist);
447  painter.drawPolyline(m_qVecPolygonF_Freeze[k]);
448  painter.drawText(0, -t_iDist/2, m_pRTMSA_New->chInfo()[m_uiFirstChannel+k].getChannelName());
449  }
450  }
451  else
452  {
453  m_qMutex.lock();
454  for(quint32 k = 0; k < m_uiNumChannels; ++k)
455  {
456  painter.translate(0, t_iDist);
457  painter.drawPolyline(m_qVecPolygonF[k]);
458  painter.drawText(0, -t_iDist/2, m_pRTMSA_New->chInfo()[m_uiFirstChannel+k].getChannelName());
459  }
460  m_qMutex.unlock();
461  }
462 
463  painter.restore();
464 
465  //*************************************************************************************************************
466  //=============================================================================================================
467  // Calculates zoom with the help of new minimum/maximum factors.
468  //=============================================================================================================
469 
470  if(m_bScaling)
471  {
472  int iStartX = m_qPointMouseStartPosition.x();
473 
474  int iEndY = m_qPointMouseEndPosition.y();
475  int iStartY = m_qPointMouseStartPosition.y();
476 
477  // Compute pixel difference
478  int iPixelDifferenceY = abs(iStartY - iEndY);
479 
480  double scale = (m_dMaxValue_init-m_dMinValue_init)/usHeight;
481 
482  if(iStartY>iEndY)
483  {
484  double changeValue = scale * iPixelDifferenceY;
485 
486  if(changeValue*2 < m_dMaxValue_init - m_dMinValue_init)
487  {
488  minValueChanged(m_dMinValue_init + changeValue);
489  maxValueChanged(m_dMaxValue_init - changeValue);
490  }
491  else
492  {
493  double maxChange = (m_dMaxValue_init - m_dMinValue_init)*0.499999;
494  minValueChanged(m_dMinValue_init + maxChange);
495  maxValueChanged(m_dMaxValue_init - maxChange);
496  }
497  }
498  else
499  {
500  double changeValue = scale * iPixelDifferenceY*10;
501 
502  minValueChanged(m_dMinValue_init - changeValue);
503  maxValueChanged(m_dMaxValue_init + changeValue);
504  }
505 
506  double factor = (m_dMaxValue_init-m_dMinValue_init)/(m_pRTMSA_New->chInfo()[0].getMaxValue()-m_pRTMSA_New->chInfo()[0].getMinValue());
507  // Draw text
508  painter.setPen(QPen(Qt::darkCyan, 1, Qt::SolidLine));
509  painter.drawText(iStartX+8, iEndY, tr("Zoom %1x").arg(factor, 0, 'f', 2));
510 
511  }
512 
513  //*************************************************************************************************************
514  //=============================================================================================================
515  // Draw coordinates at mouse position
516  //=============================================================================================================
517 
518  if(m_bPosition && m_pRTMSA_New->getSamplingRate())
519  {
520  int iPosX = mapFromGlobal(QCursor::pos()).x();
521 
522  int iPosY = mapFromGlobal(QCursor::pos()).y();
523 
524  if(iPosX > usPosX && iPosX < (usPosX + usWidth) && iPosY > usPosY && iPosY < usPosY + usHeight )
525  {
526  //Vertical Measuring
527  painter.setPen(QPen(Qt::gray, 1, Qt::DashLine));
528 
529  QPoint start(usPosX, iPosY);//iStartY-5);//paint measure line vertical direction
530  QPoint end(usPosX + usWidth, iPosY);//iStartY+5);
531 
532  painter.drawLine(start, end);
533 
534  start.setX(iPosX); start.setY(usPosY);//iStartY - 5);
535  end.setX(iPosX); end.setY(usPosY + usHeight);//iStartY + 5);
536  painter.drawLine(start, end);
537 
538  // Compute time between MouseStartPosition and MouseEndPosition
539  QTime t = m_pTimeCurrentDisplay->addMSecs((int)(1000*(iPosX-usPosX)/(float)m_pRTMSA_New->getSamplingRate()));
540 
541  // Draw text
542  painter.setPen(QPen(Qt::darkGray, 1, Qt::SolidLine));
543 
544  painter.drawText(iPosX+8, iPosY-8, tr("%1").arg(t.toString("hh:mm:ss.zzz")));// ToDo Precision should be part of preferences
545  }
546  }
547 
548 
549 
550  //*************************************************************************************************************
551  //=============================================================================================================
552  // Draw the measurement tools of the curve
553  //=============================================================================================================
554 
555  if(m_bMeasurement && m_pRTMSA_New->getSamplingRate())
556  {
557  int iEndX = m_qPointMouseEndPosition.x();
558  int iStartX = m_qPointMouseStartPosition.x();
559 
560  int iEndY = m_qPointMouseEndPosition.y();
561  int iStartY = m_qPointMouseStartPosition.y();
562 
563 
564  // Compute pixel difference
565  double iPixelDifferenceX = abs(iStartX - iEndX);
566  double iPixelDifferenceY = abs(iStartY - iEndY);
567 
568  if(iPixelDifferenceX < 5 && iPixelDifferenceY < 5)
569  return;
570 
571  //Vertical Measuring
572  painter.setPen(QPen(Qt::darkCyan, 1, Qt::DashLine));
573  if(iPixelDifferenceX > iPixelDifferenceY)
574  {
575  // Draw measuring line
576 // QPoint endPosY(iEndX, iStartY);
577 // painter.drawLine(m_qPointMouseStartPosition, endPosY);
578 
579  QPoint start(iStartX, usPosY);//iStartY-5);//paint measure line vertical direction
580  QPoint end(iStartX, usPosY+usHeight);//iStartY+5);
581  painter.drawLine(start, end);
582 
583  start.setX(iEndX); start.setY(usPosY);//iStartY - 5);
584  end.setX(iEndX); end.setY(usPosY+usHeight);//iStartY + 5);
585  painter.drawLine(start, end);
586 
587  // Compute text position
588  if(iEndX > iStartX)
589  iEndX = iEndX + 9;
590  else
591  iEndX = iEndX - 67;
592 
593  // Compute time between MouseStartPosition and MouseEndPosition
594  float iTime = 1000.0f*(float)iPixelDifferenceX/(float)m_pRTMSA_New->getSamplingRate();
595  float iHz = 1000.0f/(float)iTime;
596 
597  // Draw text
598  painter.setPen(QPen(Qt::darkCyan, 1, Qt::SolidLine));
599 
600  painter.drawText(iEndX, iEndY-18, tr("%1ms").arg(iTime, 0, 'f', 2));// ToDo Precision should be part of preferences
601  painter.drawText(iEndX, iEndY-4, tr("%1Hz").arg(iHz, 0, 'f', 2));
602  }
603  else
604  {
605  // Draw measuring line
606 // QPoint endPosX(iStartX, iEndY);
607 // painter.drawLine(endPosX, m_qPointMouseStartPosition);
608 
609  QPoint start(usPosX, iStartY);//iStartY-5);//paint measure line vertical direction
610  QPoint end(usPosX+usWidth, iStartY);//iStartY+5);
611  painter.drawLine(start, end);
612 
613  start.setX(usPosX); start.setY(iEndY);//iStartY - 5);
614  end.setX(usPosX+usWidth); end.setY(iEndY);//iStartY + 5);
615  painter.drawLine(start, end);
616 
617 
618  // Compute text position
619  if(iEndY > iStartY)
620  iEndY = iEndY + 1;
621  else
622  iEndY = iEndY + 23 ;
623 
624  // Compute time between MouseStartPosition and MouseEndPosition
625  float fMagnitude = (float)iPixelDifferenceY * (dMinMaxDifference/usHeight) ;
626 
627  // Draw text
628  painter.setPen(QPen(Qt::darkCyan, 1, Qt::SolidLine));
629  painter.drawText(iEndX+14, iEndY-8, tr("%1%2").arg(fMagnitude, 0, 'e', 3).arg(m_pRTMSA_New->chInfo()[0].getUnit()));// ToDo Precision should be part of preferences
630  }
631  }
632 }
633 
634 
635 //*************************************************************************************************************
636 
638 {
639  m_bStartFlag = true; //start new painting
640  actualize();
641 }
642 
643 
644 //*************************************************************************************************************
645 
647 {
648  Q_UNUSED(keyEvent);
649 // if(keyEvent->key() == Qt::UpArrow)
650 // {
651 // if(m_uiFirstChannel + m_uiNumChannels < m_pRTMSA_New->getNumChannels())
652 // m_uiFirstChannel += m_uiNumChannels;
653 // }
654 // else if(keyEvent->key() == Qt::DownArrow)
655 // {
656 // if(m_uiFirstChannel - m_uiNumChannels >= 0)
657 // m_uiFirstChannel -= m_uiNumChannels;
658 // }
659 
660 // QWidget::keyPressEvent(keyEvent);
661 
662  Q_UNUSED(keyEvent);
663 }
664 
665 
666 //*************************************************************************************************************
667 
669 {
670  m_qPointMouseStartPosition = m_qPointMouseEndPosition = mouseEvent->pos();
671  if(mouseEvent->button() == Qt::LeftButton)
672  {
673  m_bMeasurement = true;
674  m_bPosition = false;
675  }
676  else if(mouseEvent->button() == Qt::RightButton)
677  {
678  m_bScaling = true;
679  m_bPosition = false;
680  }
681 }
682 
683 
684 //*************************************************************************************************************
685 
687 {
688  if(m_bMeasurement || m_bScaling)
689  m_qPointMouseEndPosition = mouseEvent->pos();
690 }
691 
692 
693 //*************************************************************************************************************
694 
696 {
697  m_bMeasurement = false;
698  m_bPosition = true;
699  m_bScaling = false;
700 }
701 
702 
703 //*************************************************************************************************************
704 
706 {
707  switch((Tool)m_ucToolIndex)
708  {
709  case Freeze:
710  m_bFrozen = !m_bFrozen;
711  if(m_bFrozen)
712  {
713 // m_qPainterPath_Freeze = m_qPainterPath;
714 // m_qPainterPath_FreezeTest = m_qPainterPathTest;
715 // m_qVecPainterPath_Freeze = m_qVecPainterPath;
716  m_qVecPolygonF_Freeze = m_qVecPolygonF;
717 
718  }
719  else
720  {
721  m_pTimeCurrentDisplay->setHMS(m_pTime->hour(),m_pTime->minute(),m_pTime->second(),m_pTime->msec());
722  }
723  break;
724 
725  case Annotation:
726  break;
727  }
728 
729  m_bToolInUse = !m_bToolInUse;
730 }
731 
732 
733 //*************************************************************************************************************
734 
736 {
737  if(wheelEvent->delta() < 0)
738  {
739  if((qint32)m_uiFirstChannel - (qint32)m_uiNumChannels >= 0)
740  m_uiFirstChannel -= m_uiNumChannels;
741  else
742  m_uiFirstChannel = 0;
743  }
744  else
745  {
746  if(((qint32)m_uiFirstChannel + (qint32)m_uiNumChannels) < ((qint32)m_pRTMSA_New->getNumChannels()-(qint32)m_uiNumChannels))
747  m_uiFirstChannel += m_uiNumChannels;
748  else
749  m_uiFirstChannel = m_pRTMSA_New->getNumChannels()- m_uiNumChannels;
750  }
751 
752  m_bStartFlag = true;
753 
754 // if(m_bToolInUse)
755 // return;
756 
757 // if(wheelEvent->delta() < 0)
758 // {
759 // if(m_ucToolIndex == 0)
760 // m_ucToolIndex = m_vecTool.size()-1;
761 // else
762 // --m_ucToolIndex;
763 // }
764 // else
765 // {
766 // if(m_ucToolIndex == m_vecTool.size()-1)
767 // m_ucToolIndex = 0;
768 // else
769 // ++m_ucToolIndex;
770 // }
771 
772 // QString text = QString("%1/%2 Tool: %3").arg(m_ucToolIndex+1).arg(m_vecTool.size()).arg(m_vecTool[m_ucToolIndex]);
773 // ui.m_qLabel_Tool->setText(text);
774 // ui.m_qLabel_Tool->show();
775 
776 // if(m_pTimerToolDisplay)
777 // delete m_pTimerToolDisplay;
778 
779 // m_pTimerToolDisplay = new QTimer(this);
780 
781 // connect( m_pTimerToolDisplay, SIGNAL(timeout()), ui.m_qLabel_Tool, SLOT(hide()));
782 // m_pTimerToolDisplay->start(2000);
783 
784 }
785 
786 
787 //*************************************************************************************************************
788 //=============================================================================================================
789 // STATIC DEFINITIONS
790 //=============================================================================================================
791 
792 QList<double> NewRealTimeMultiSampleArrayWidget::s_listSamplingRates;
Free surfer annotation.
Definition: annotation.h:97
NewRealTimeMultiSampleArrayWidget(QSharedPointer< NewRealTimeMultiSampleArray > pRTMSA_New, QSharedPointer< QTime > &pTime, QWidget *parent=0)
virtual void update(XMEASLIB::NewMeasurement::SPtr pMeasurement)
QSharedPointer< NewMeasurement > SPtr
Contains the declaration of the NewRealTimeMultiSampleArray class.
The MeasurementWidget class is the base class of all measurement widgets.