Try to correct :

Sometimes the application is still running (processes) after a close #7

Add an abort function for the threads

qt_tstools/mainwindow.cpp

@@ -27,40 +27,56 @@ void MainWindow::cleanAll()
     cleanPcr();
     cleanDts();
     cleanPts();
+
+
+    // wait for all thread to be completed
+    if (m_pthreadPool->activeThreadCount())
+    {
+        statusBar()->showMessage(tr("Waiting for threads completion..."));
+        m_pthreadPool->waitForDone();
+    }
 }
 
 void MainWindow::cleanPcr()
 {
     if (m_pcrWorker) {
         m_pthreadPool->cancel(m_pcrWorker);
+        m_pcrWorker->abort();
         delete m_pcrWorker; m_pcrWorker = Q_NULLPTR;
     }
     if (m_pcrDeltaWorker) {
         m_pthreadPool->cancel(m_pcrDeltaWorker);
+        m_pcrDeltaWorker->abort();
         delete m_pcrDeltaWorker; m_pcrDeltaWorker = Q_NULLPTR;
     }
     if (m_jitterPcrWorker) {
         m_pthreadPool->cancel(m_jitterPcrWorker);
+        m_jitterPcrWorker->abort();
         delete m_jitterPcrWorker; m_jitterPcrWorker = Q_NULLPTR;
     }
     if (m_bitratePcrWorker) {
         m_pthreadPool->cancel(m_bitratePcrWorker);
+        m_bitratePcrWorker->abort();
         delete m_bitratePcrWorker; m_bitratePcrWorker = Q_NULLPTR;
     }
     if (m_diffPcrPtsWorker) {
         m_pthreadPool->cancel(m_diffPcrPtsWorker);
+        m_diffPcrPtsWorker->abort();
         delete m_diffPcrPtsWorker; m_diffPcrPtsWorker = Q_NULLPTR;
     }
     if (m_diffPcrDtsWorker) {
         m_pthreadPool->cancel(m_diffPcrDtsWorker);
+        m_diffPcrDtsWorker->abort();
         delete m_diffPcrDtsWorker; m_diffPcrDtsWorker = Q_NULLPTR;
     }
     if (m_buffLevelPtsWorker) {
         m_pthreadPool->cancel(m_buffLevelPtsWorker);
+        m_buffLevelPtsWorker->abort();
         delete m_buffLevelPtsWorker; m_buffLevelPtsWorker = Q_NULLPTR;
     }
     if (m_buffLevelPtsDtsWorker) {
         m_pthreadPool->cancel(m_buffLevelPtsDtsWorker);
+        m_buffLevelPtsDtsWorker->abort();
         delete m_buffLevelPtsDtsWorker; m_buffLevelPtsDtsWorker = Q_NULLPTR;
     }
 }
@@ -69,26 +85,32 @@ void MainWindow::cleanPts()
 {
     if (m_ptsWorker) {
         m_pthreadPool->cancel(m_ptsWorker);
+        m_ptsWorker->abort();
         delete m_ptsWorker; m_ptsWorker = Q_NULLPTR;
     }
     if (m_ptsDeltaWorker) {
         m_pthreadPool->cancel(m_ptsDeltaWorker);
+        m_ptsDeltaWorker->abort();
         delete m_ptsDeltaWorker; m_ptsDeltaWorker = Q_NULLPTR;
     }
     if (m_diffPcrPtsWorker) {
         m_pthreadPool->cancel(m_diffPcrPtsWorker);
+        m_diffPcrPtsWorker->abort();
         delete m_diffPcrPtsWorker; m_diffPcrPtsWorker = Q_NULLPTR;
     }
     if (m_diffPtsDtsWorker) {
         m_pthreadPool->cancel(m_diffPtsDtsWorker);
+        m_diffPtsDtsWorker->abort();
         delete m_diffPtsDtsWorker; m_diffPtsDtsWorker = Q_NULLPTR;
     }
     if (m_buffLevelPtsWorker) {
         m_pthreadPool->cancel(m_buffLevelPtsWorker);
+        m_buffLevelPtsWorker->abort();
         delete m_buffLevelPtsWorker; m_buffLevelPtsWorker = Q_NULLPTR;
     }
     if (m_buffLevelPtsDtsWorker) {
         m_pthreadPool->cancel(m_buffLevelPtsDtsWorker);
+        m_buffLevelPtsDtsWorker->abort();
         delete m_buffLevelPtsDtsWorker; m_buffLevelPtsDtsWorker = Q_NULLPTR;
     }
 }
@@ -97,22 +119,27 @@ void MainWindow::cleanDts()
 {
     if (m_dtsWorker) {
         m_pthreadPool->cancel(m_dtsWorker);
+        m_dtsWorker->abort();
         delete m_dtsWorker; m_dtsWorker = Q_NULLPTR;
     }
     if (m_dtsDeltaWorker) {
         m_pthreadPool->cancel(m_dtsDeltaWorker);
+        m_dtsDeltaWorker->abort();
         delete m_dtsDeltaWorker; m_dtsDeltaWorker = Q_NULLPTR;
     }
     if (m_diffPcrDtsWorker) {
         m_pthreadPool->cancel(m_diffPcrDtsWorker);
+        m_diffPcrDtsWorker->abort();
         delete m_diffPcrDtsWorker; m_diffPcrDtsWorker = Q_NULLPTR;
     }
     if (m_diffPtsDtsWorker) {
         m_pthreadPool->cancel(m_diffPtsDtsWorker);
+        m_diffPtsDtsWorker->abort();
         delete m_diffPtsDtsWorker; m_diffPtsDtsWorker = Q_NULLPTR;
     }
     if (m_buffLevelPtsDtsWorker) {
         m_pthreadPool->cancel(m_buffLevelPtsDtsWorker);
+        m_buffLevelPtsDtsWorker->abort();
         delete m_buffLevelPtsDtsWorker; m_buffLevelPtsDtsWorker = Q_NULLPTR;
     }
 }

qt_tstools/thread.cpp

@@ -46,7 +46,7 @@ double infoWorker::getGlobalDuration()
 ////////////////////////////////
 // Timestamp worker - base class
 timeStampWorker::timeStampWorker(std::string *tsFileName, Chart *chart) :
-   m_nbProgress(0),  m_chart(chart), m_isTimeXaxis(true), m_isRunning(false)
+   m_nbProgress(0),  m_chart(chart), m_isTimeXaxis(true), m_isRunning(false), m_isAborting(false)
 
 {
     // new drawing
@@ -110,15 +110,25 @@ void timeStampWorker::serializeSeries(std::ofstream *outFile)
     }
 }
 
+void timeStampWorker::abort()
+{
+    m_isAborting = true;
+
+    // loop until thread is completed
+    while (m_isRunning == true) {
+        QThread::msleep(10); // 10 milliseconds
+    }
+}
+
 void timeStampWorker::run()
 {
     m_isRunning = true;
 
-    while (m_timestamp->run(m_WindowPacket) == true)
+    while (m_timestamp->run(m_WindowPacket) == true && m_isAborting == false)
     {
         unsigned int index;
         double val;
-        while((m_timestamp->*m_func)(index, val) == true)
+        while((m_timestamp->*m_func)(index, val) == true  && m_isAborting == false)
         {
             if (m_isTimeXaxis)
                 // time for X axis

qt_tstools/thread.h

@@ -2,6 +2,7 @@
 #define THREAD_H
 
 #include <QDebug>
+#include <QThread>
 #include <QRunnable>
 #include <QtCharts/QLineSeries>
 
@@ -77,13 +78,19 @@ class timeStampWorker : public QObject, public QRunnable
     // true if the thread is running
     bool m_isRunning;
 
+    // true if the thread is aborting
+    bool m_isAborting;
+
     // manipulate the series
     void showSeries();
     void hideSeries();
 
     // write the serie of points in file
     void serializeSeries(std::ofstream *outFile);
 
+    // abort the thread
+    void abort();
+
     // run function from QRunnable
     void run();