HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/QLop Commit - r11:f1a4e3a7ca04

added missing GPL headers...

jeandet -

r11:f1a4e3a7ca04 default

parent child

Context file:

r11:f1a4e3a7ca04

QLop.pro +1 -1

             #-------------------------------------------------
             #
             # Project created by QtCreator 2015-01-07T02:41:29
             #
             #-------------------------------------------------
             QT       += core gui network xml svg
             CONFIG   += pythonqt
             greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
             DESTDIR =./bin
             TARGET = QLop
             TEMPLATE = app
-            LIBS+=-lfftw3
+            LIBS+=-lfftw3_threads -lfftw3
             INCLUDEPATH += src/QCustomPlot \
                             src src/Cassini \
                             src/Core src/Core/Widgets \
                             src/Core/Widgets/PyWdgt
             QMAKE_CXXFLAGS_RELEASE += -O5 -fopenmp -march=corei7-avx -mtune=corei7-avx -mavx
             QMAKE_LFLAGS_RELEASE += -O5 -fopenmp -march=corei7-avx -mtune=corei7-avx -mavx
             QMAKE_CXXFLAGS_DEBUG += -O0 -fopenmp -march=corei7-avx -mtune=corei7-avx -mavx
             QMAKE_LFLAGS_DEBUG += -O0 -fopenmp -march=corei7-avx -mtune=corei7-avx -mavx
             SOURCES += src/main.cpp\
                     src/mainwindow.cpp \
                 src/SocExplorerPlot.cpp \
                 src/QCustomPlot/qcustomplot.cpp \
                 src/toolbarcontainer.cpp \
                 src/Core/abstractfileloader.cpp \
                 src/Core/filedownloader.cpp \
                 src/Core/filedownloadertask.cpp \
                 src/Core/Widgets/downloadhistory.cpp \
                 src/Core/Widgets/downloadhistoryelement.cpp \
                 src/Core/qlopservice.cpp \
                 src/Cassini/expxmldownloader.cpp \
                 src/Cassini/cassinidatadownloader.cpp \
                 src/Cassini/cassinidatafile.cpp \
                 src/Cassini/cassiniindexfile.cpp \
                 src/Cassini/cassiniindexfileviewer.cpp \
                 src/Cassini/cassinitools.cpp \
                 src/Cassini/cassinitoolsgui.cpp \
                 src/Core/Widgets/qlopplots.cpp \
                 src/Core/qlopdata.cpp \
                 src/Core/Widgets/PyWdgt/pythonconsole.cpp \
                 src/Core/Widgets/PyWdgt/pythonqtscriptingconsoledandd.cpp \
                 src/QCustomPlot/qcpdocumentobject.cpp \
                 src/Core/Widgets/filebrowser.cpp \
                 src/Core/Widgets/filesystemmodel.cpp \
                 src/Core/Widgets/qcustomplotvect.cpp
             HEADERS  += src/mainwindow.h \
                 src/SocExplorerPlot.h \
                 src/QCustomPlot/qcustomplot.h \
                 src/toolbarcontainer.h \
                 src/Core/abstractfileloader.h \
                 src/Core/filedownloader.h \
                 src/Core/filedownloadertask.h \
                 src/Core/Widgets/downloadhistory.h \
                 src/Core/Widgets/downloadhistoryelement.h \
                 src/Core/qlopservice.h \
                 src/Cassini/expxmldownloader.h \
                 src/Cassini/cassinidatadownloader.h \
                 src/Cassini/cassinidatafile.h \
                 src/Cassini/cassiniindexfile.h \
                 src/Cassini/cassiniindexfileviewer.h \
                 src/Cassini/cassinitools.h \
                 src/Cassini/cassinitoolsgui.h \
                 src/Core/Widgets/qlopplots.h \
                 src/Core/qlopdata.h \
                 src/Core/Widgets/PyWdgt/pythonconsole.h \
                 src/Core/Widgets/PyWdgt/pythonqtscriptingconsoledandd.h \
                 src/Core/qlop.h \
                 src/Core/pyqlop.h \
                 src/QCustomPlot/qcpdocumentobject.h \
                 src/Core/Widgets/filebrowser.h \
                 src/Core/Widgets/filesystemmodel.h \
                 src/Core/Widgets/qcustomplotvect.h
             FORMS    += src/mainwindow.ui \
                 src/Core/Widgets/downloadhistory.ui \
                 src/Core/Widgets/downloadhistoryelement.ui \
                 src/Cassini/cassinidatadownloader.ui \
                 src/Cassini/cassiniindexfileviewer.ui \
                 src/Cassini/cassinitoolsgui.ui \
                 src/Core/Widgets/filebrowser.ui
             RESOURCES += \
                 resources/qlop.qrc
             include(src/Core/Widgets/NicePyConsole/NicePyConsole.pri)
             include(src/Core/pythonQtOut/generated_cpp/PyQLop/PyQLop.pri)
             win32 {
                 DEFINES += WIN32
             }
             unix {
                 DEFINES += UNIX
             }
             DISTFILES += \
                 src/Core/pythongenerator.sh \
                 src/Core/pythonQtgeneratorCfg.txt

src/Cassini/cassinidatadownloader.cpp +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "cassinidatadownloader.h"
             #include "ui_cassinidatadownloader.h"
             #include <filedownloader.h>
             #include <QDir>
             #include <QFileDialog>
             #include <QFile>
             CassiniDataDownloader::CassiniDataDownloader(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::CassiniDataDownloader)
             {
                 ui->setupUi(this);
                 m_xmlLoader = new ExpXmlDownLoader();
                 connect(this->ui->calendar,SIGNAL(activated(QDate)),this,SLOT(downloadData(QDate)));
                 connect(this->ui->LoadXmlFileQpb,SIGNAL(clicked()),this,SLOT(loadXmlFile()));
             }
             CassiniDataDownloader::~CassiniDataDownloader()
             {
                 delete ui;
                 delete m_xmlLoader;
             }
             void CassiniDataDownloader::changeEvent(QEvent *e)
             {
                 QWidget::changeEvent(e);
                 switch (e->type()) {
                 case QEvent::LanguageChange:
                     ui->retranslateUi(this);
                     break;
                 default:
                     break;
                 }
             }
             void CassiniDataDownloader::downloadData(const QDate &date)
             {
                 QDate tmpDate;
                 QStringList months=QStringList()<< "JAN" << "FEB" << "MAR" << "APR" << "MAY" << "JUN" << "JUI" << "AUG" << "SEP" << "OCT" << "NOV" << "DEC";
                 tmpDate.setDate(date.year(),date.month(),1);
                 int firstDayOfMonth=tmpDate.dayOfYear();
                 tmpDate.setDate(tmpDate.year(),tmpDate.month(),tmpDate.daysInMonth());
                 int lastDayOfMonth=tmpDate.dayOfYear();
                 QString link="http://ppi.pds.nasa.gov/ditdos/download?id=pds://PPI/CO-E_SW_J_S-MAG-3-RDR-FULL-RES-V1.0/DATA/" \
                     + QString("%1").arg(date.year()) +"/" + QString("%1_%2_").arg(firstDayOfMonth,3).arg(lastDayOfMonth,3).replace(' ','0') \
                     + months.at(date.month()-1) + "/" ;
                 qDebug()<<link;
                 QString dataFileName= QString("%1%2").arg(date.year()-2000,2).arg(date.dayOfYear(),3).replace(' ','0') + "_FGM_KRTP.TAB";
                 QString headerFileName= QString("%1%2").arg(date.year()-2000,2).arg(date.dayOfYear(),3).replace(' ','0') + "_FGM_KRTP.LBL";
             //    "_FGM_KRTP.TAB"
                 FileDownloader::downloadFile(link+dataFileName,QDir::homePath() +"/Téléchargements/"+dataFileName);
                 FileDownloader::downloadFile(link+headerFileName,QDir::homePath() +"/Téléchargements/"+headerFileName);
             }
             void CassiniDataDownloader::loadXmlFile()
             {
                 QString file=QFileDialog::getOpenFileName();
                 if(QFile::exists(file))
                 {
                     if(m_xmlLoader->parseXml(file))
                     {
                         QList<QDate> daysToDl = m_xmlLoader->daysToDownload();
                         for(int i=0;i<daysToDl.count();i++)
                         {
                             downloadData(daysToDl.at(i));
                         }
                     }
                 }
             }

src/Cassini/cassinidatadownloader.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef CASSINIDATADOWNLOADER_H
             #define CASSINIDATADOWNLOADER_H
             #include <QWidget>
             #include <QDate>
             #include <expxmldownloader.h>
             namespace Ui {
             class CassiniDataDownloader;
             }
             class CassiniDataDownloader : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit CassiniDataDownloader(QWidget *parent = 0);
                 ~CassiniDataDownloader();
             protected:
                 void changeEvent(QEvent *e);
             private slots:
                 void downloadData(const QDate & date );
                 void loadXmlFile();
             private:
                 Ui::CassiniDataDownloader *ui;
                 ExpXmlDownLoader* m_xmlLoader;
             };
             #endif // CASSINIDATADOWNLOADER_H

src/Cassini/cassinidatafile.cpp +1 -1

             /*------------------------------------------------------------------------------
             -- This file is a part of the QLop Software
             -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "cassinidatafile.h"
             #include <QFile>
             #include <stdio.h>
             #include <QDateTime>
             #include <QVector>
             #include <QProgressDialog>
             #include <omp.h>
             #include <QTimer>
             #include <QElapsedTimer>
             #include <sys/time.h>
             CassiniDataFile::CassiniDataFile(QObject *parent) : AbstractFileLoader(parent)
             {
             }
             CassiniDataFile::~CassiniDataFile()
             {
             }
             void CassiniDataFile::parseFile(const QString &fileName)
             {
                 this->fileName = fileName;
                 m_Write = false;
                 this->start();
             }
             void CassiniDataFile::saveFile(const QString &fileName, QLopDataList data)
             {
                 this->fileName = fileName;
                 m_Write = true;
                 m_data = data;
                 this->start();
             }
             inline double __decodeVal(int ofset,unsigned char* data)
             {
                 if(data[ofset]=='-')
                     return  -0.001 * (double)(
                                 (10000 * (int)(data[ofset+1] & 0x0F))
                             + (1000 *  (int)(data[ofset+2] & 0x0F))
                             + (100 *   (int)(data[ofset+4] & 0x0F))
                             + (10 *    (int)(data[ofset+5] & 0x0F))
                             + (        (int)(data[ofset+6] & 0x0F))
                             );
                 else
                 {
                     if(data[ofset+1]=='-')
                     {
                         return  -0.001 * (double)(
                                     (1000 * (int)(data[ofset+2] & 0x0F))
                                 + (100 *  (int)(data[ofset+4] & 0x0F))
                                 + (10 *   (int)(data[ofset+5] & 0x0F))
                                 + (       (int)(data[ofset+6] & 0x0F))
                                 );
                     }
                     else
                     {
                         return 0.001 * (double)(
                                     (10000 * (int)(data[ofset+1] & 0x0F))
                                 + (1000 *  (int)(data[ofset+2] & 0x0F))
                                 + (100 *   (int)(data[ofset+4] & 0x0F))
                                 + (10 *    (int)(data[ofset+5] & 0x0F))
                                 + (        (int)(data[ofset+6] & 0x0F))
                                 );
                     }
                 }
             }
             inline QDate __decodeDate(int ofset,unsigned char* data)
             {
                 int y=(1000*(data[ofset] & 0x0F)) + (100*(data[ofset+1] & 0x0F)) + (10*(data[ofset+2] & 0x0F)) + (1*(data[ofset+3] & 0x0F));
                 int m=(10*(data[ofset+5] & 0x0F)) + (1*(data[ofset+6] & 0x0F));
                 int d=(10*(data[ofset+8] & 0x0F)) + (1*(data[ofset+9] & 0x0F));
                 return QDate(y,m,d);
             }
             inline QTime __decodeTime(int ofset,unsigned char* data)
             {
                 int h=(10*(data[ofset] & 0x0F)) + (1*(data[ofset+1] & 0x0F));
                 int m=(10*(data[ofset+3] & 0x0F)) + (1*(data[ofset+4] & 0x0F));
                 int s=(10*(data[ofset+6] & 0x0F)) + (1*(data[ofset+7] & 0x0F));
                 int ms=(100*(data[ofset+9] & 0x0F)) + (10*(data[ofset+10] & 0x0F)) + (1*(data[ofset+11] & 0x0F));
                 return QTime(h,m,s,ms);
             }
             double __decodeTimeFromEpochMs(int ofset,unsigned char* data)
             {
                 struct tm t;
                 time_t t_of_day;
                 t.tm_year=(1000*(data[ofset] & 0x0F)) + (100*(data[ofset+1] & 0x0F)) + (10*(data[ofset+2] & 0x0F)) + ((data[ofset+3] & 0x0F)) -1900;
                 t.tm_mon=(10*(data[ofset+5] & 0x0F)) + ((data[ofset+6] & 0x0F));
                 t.tm_mday=(10*(data[ofset+8] & 0x0F)) + ((data[ofset+9] & 0x0F));
                 t.tm_hour=(10*(data[ofset+11] & 0x0F)) + ((data[ofset+12] & 0x0F));
                 t.tm_min=(10*(data[ofset+14] & 0x0F)) + ((data[ofset+15] & 0x0F));
                 t.tm_sec=(10*(data[ofset+17] & 0x0F)) + ((data[ofset+18] & 0x0F));
                 int ms=(100*(data[ofset+20] & 0x0F)) + (10*(data[ofset+21] & 0x0F)) + ((data[ofset+22] & 0x0F));
                 t_of_day = mktime(&t);
                 return (t_of_day*1000.0)+ms;
             }
             double __decodeTimeFromEpoch(int ofset,unsigned char* data)
             {
                 struct tm t;
                 time_t t_of_day;
                 t.tm_year=(1000*(data[ofset] & 0x0F)) + (100*(data[ofset+1] & 0x0F)) + (10*(data[ofset+2] & 0x0F)) + ((data[ofset+3] & 0x0F)) -1900;
                 t.tm_mon=(10*(data[ofset+5] & 0x0F)) + ((data[ofset+6] & 0x0F));
                 t.tm_mday=(10*(data[ofset+8] & 0x0F)) + ((data[ofset+9] & 0x0F));
                 t.tm_hour=(10*(data[ofset+11] & 0x0F)) + ((data[ofset+12] & 0x0F));
                 t.tm_min=(10*(data[ofset+14] & 0x0F)) + ((data[ofset+15] & 0x0F));
                 t.tm_sec=(10*(data[ofset+17] & 0x0F)) + ((data[ofset+18] & 0x0F));
                 double ms=(100*(data[ofset+20] & 0x0F)) + (10*(data[ofset+21] & 0x0F)) + ((data[ofset+22] & 0x0F));
                 t_of_day = mktime(&t);
                 return (double)t_of_day+((double)ms*(double)0.001);
             }
             double __decodeTimeHMSmS(int ofset,unsigned char* data)
             {
                 int h,m,s;
                 h=(10*(data[ofset+11] & 0x0F)) + ((data[ofset+12] & 0x0F));
                 m=(10*(data[ofset+14] & 0x0F)) + ((data[ofset+15] & 0x0F));
                 s=(10*(data[ofset+17] & 0x0F)) + ((data[ofset+18] & 0x0F));
                 double ms=(100*(data[ofset+20] & 0x0F)) + (10*(data[ofset+21] & 0x0F)) + ((data[ofset+22] & 0x0F));
                 return (double)((h*3600)+(m*60)+s) + (ms*0.001);
             }
             double __decodeTimeDHMSmS(int ofset,unsigned char* data)
             {
                 int d,h,m,s;
                 d=(10*(data[ofset+8] & 0x0F)) + ((data[ofset+9] & 0x0F));
                 h=(10*(data[ofset+11] & 0x0F)) + ((data[ofset+12] & 0x0F));
                 m=(10*(data[ofset+14] & 0x0F)) + ((data[ofset+15] & 0x0F));
                 s=(10*(data[ofset+17] & 0x0F)) + ((data[ofset+18] & 0x0F));
                 double ms=(100*(data[ofset+20] & 0x0F)) + (10*(data[ofset+21] & 0x0F)) + ((data[ofset+22] & 0x0F));
                 return (double)((d*3600*24)+(h*3600)+(m*60)+s) + (ms*0.001);
             }
             double __decodeTimeFromEpochDayOnly(int ofset,unsigned char* data)
             {
                 struct tm t;
                 time_t t_of_day;
             //    t.tm_year=(1000*(data[ofset] & 0x0F)) + (100*(data[ofset+1] & 0x0F)) + (10*(data[ofset+2] & 0x0F)) + ((data[ofset+3] & 0x0F)) -1900;
                 t.tm_year=(1000*(data[ofset] & 0x0F)) + (100*(data[ofset+1] & 0x0F)) + (10*(data[ofset+2] & 0x0F)) + ((data[ofset+3] & 0x0F));
                 t.tm_mon=(10*(data[ofset+5] & 0x0F)) + ((data[ofset+6] & 0x0F));
                 t.tm_mday=(10*(data[ofset+8] & 0x0F)) + ((data[ofset+9] & 0x0F));
                 t.tm_hour=0;
                 t.tm_min=0;
                 t.tm_sec=0;
             //    t_of_day = mktime(&t);
             //    return (double)t_of_day;
                 QDateTime date(QDate(t.tm_year,t.tm_mon,1),QTime(0,0));
             //    date.setDate();
                 return (double)((date.toMSecsSinceEpoch()/1000.0)-(24*3600));
             }
             void CassiniDataFile::run()
             {
                 if(!m_Write)
                 {
                     readFile();
                 }
                 else
                 {
                     writeFile();
                 }
             }
             void CassiniDataFile::readFile()
             {
                 FILE* dataFile;
                 dataFile = fopen(fileName.toStdString().c_str(),"r");
                 if(dataFile != NULL)
                 {
                     fseek(dataFile, 0L, SEEK_END);
                     int FileSize=ftell(dataFile);
                     int lineCnt = FileSize/58;
                     int curLine=0;
                     int lastLineUpdate=0;
                     QVector<QCPData> *ch1=new QVector<QCPData>(lineCnt);
                     QVector<QCPData> *ch2=new QVector<QCPData>(lineCnt);
                     QVector<QCPData> *ch3=new QVector<QCPData>(lineCnt);
                     QLopDataList data;
                     QLopData* ch1V=new QLopData();
                     QLopData* ch2V=new QLopData();
                     QLopData* ch3V=new QLopData();
                     ch1V->data=ch1;
                     ch2V->data=ch2;
                     ch3V->data=ch3;
                     ch1V->name="r";
                     ch2V->name="theta";
                     ch3V->name="phi";
                     ch1V->unit="nT";
                     ch2V->unit="nT";
                     ch3V->unit="nT";
                     data.append(ch1V);
                     data.append(ch2V);
                     data.append(ch3V);
                     QElapsedTimer timr;
                     double _x=0.0,day=0.0;
                     char* line;
                     QCPData data1,data2,data3;
                     char* fileContent=(char*)malloc(FileSize);
                     if(Q_UNLIKELY(fileContent==NULL))return;
                     int threadIndex,numThreads=omp_get_num_threads();
                     int updateTriger=(lineCnt/100)/numThreads;
                     fseek(dataFile, 0L, SEEK_SET);
                     char* svglocale=NULL;
                     setlocale(LC_NUMERIC,svglocale);
                     setlocale(LC_NUMERIC, "en_US");
                     if(fread(fileContent,1,FileSize,dataFile))
                     {
                         line = fileContent;
                         QDateTime date;
                         timr.start();
                         day=__decodeTimeFromEpochDayOnly(0,(unsigned char*)line);
                         //#pragma omp parallel if ((FileSize > 10000000)) private(date,data1,data2,data3,_x,threadIndex,lastLineUpdate) shared(ch1,ch2,ch3,lineCnt)
                         //          {
             #pragma omp parallel for if ((FileSize > 1024*1024*10)) private(date,data1,data2,data3,_x,threadIndex,lastLineUpdate,curLine) shared(ch1,ch2,ch3,lineCnt,updateTriger)
                         for(int i=0;i<lineCnt;i++)
                         {
                             //              _x=  i;
                             _x= day + __decodeTimeDHMSmS((i*58),(unsigned char*)line);
                             //              _x=__decodeTimeFromEpoch((i*58),(unsigned char*)line);
                             data1.key=_x;
                             data2.key=_x;
                             data3.key=_x;
                             data1.value=__decodeVal(((i*58)+27),(unsigned char*)line);
                             data2.value=__decodeVal(((i*58)+38),(unsigned char*)line);
                             data3.value=__decodeVal(((i*58)+49),(unsigned char*)line);
                             (*ch1)[i]=data1;
                             (*ch2)[i]=data2;
                             (*ch3)[i]=data3;
                             curLine++;
                             if(Q_UNLIKELY(lastLineUpdate++>updateTriger))
                             {
                                 lastLineUpdate=0;
                                 int test=((curLine*numThreads *100)/ (lineCnt));
                                 emit updateProgress(omp_get_thread_num(),test);
                             }
                         }
                     }
                     //#pragma omp barrier
                     free(fileContent);
                     //        }
-                    qDebug()<< lineCnt <<" Points loade in "<< timr.elapsed()<<"ms";
+                    qDebug()<< lineCnt <<" Points loaded in "<< timr.elapsed()<<"ms";
                     setlocale(LC_NUMERIC,svglocale);
                     emit dataReady(data);
                 }
             }
             void CassiniDataFile::writeFile()
             {
                 QFile dataFile(fileName);
                 dataFile.open(QIODevice::WriteOnly);
                 QTextStream out(&dataFile);
                 if(dataFile.isOpen())
                 {
                     if(m_data.count()==3)
                     {
                         QLopData* ch1V=m_data.at(0);
                         QLopData* ch2V=m_data.at(1);
                         QLopData* ch3V=m_data.at(2);
                         if(ch1V->data->count()==ch2V->data->count() && ch1V->data->count()==ch3V->data->count())
                         {
                             for(int i=0;i<ch1V->data->count();i++)
                             {
                                 double key = ch1V->data->at(i).key;
                                 QDateTime date = QDateTime::fromMSecsSinceEpoch(key*1000);
                                 out << date.toString(Qt::ISODate)+QString(".%1").arg(date.time().msec(),3);
                                 out << QString("%1%2%3").arg(ch1V->data->at(i).value, 11, 'f', 3).arg(ch2V->data->at(i).value, 11, 'f', 3).arg(ch3V->data->at(i).value, 11, 'f', 3);
                                 out << "\r\n";
                             }
                         }
                         dataFile.flush();
                         m_data.clear();
                         delete ch1V;
                         delete ch2V;
                         delete ch3V;
                     }
                 }
             }

src/Cassini/cassiniindexfile.cpp +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "cassiniindexfile.h"
             #include <QFile>
             #include <stdio.h>
             #include <QStringList>
             CassiniIndexFile::CassiniIndexFile()
             {
             }
             CassiniIndexFile::~CassiniIndexFile()
             {
             }
             QList<CassiniIndexLine> CassiniIndexFile::loadFile(const QString &file)
             {
                 QFile dataFile(file);
                 dataFile.open(QIODevice::ReadOnly);
                 QList<CassiniIndexLine> lines;
                 if(dataFile.isOpen())
                 {
                     QString line;
                     QStringList cels;
                     CassiniIndexLine indexLine;
                     line=dataFile.readLine();
                     while(!dataFile.atEnd())
                     {
                         line=dataFile.readLine();
                         cels= line.split(',');
                         for(int i=0;i<8;i++)
                         {
                             indexLine.cels[i]="";
                         }
                         if(cels.count()<=8)
                         {
                             for(int i=0;i<cels.count();i++)
                             {
                                 indexLine.cels[i]=cels.at(i);
                             }
                             lines.append(indexLine);
                         }
                     }
                 }
                 return lines;
             }

src/Cassini/cassiniindexfile.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef CASSINIINDEXFILE_H
             #define CASSINIINDEXFILE_H
             #include <QObject>
             #define DATA_SET_ID 0
             #define FILE_SPECIFICATION_NAME 1
             #define PRODUCT_ID 2
             #define VOLUME_ID 3
             #define PRODUCT_CREATION_TIME 4
             #define TARGET_NAME 5
             #define START_TIME 6
             #define STOP_TIME 7
             typedef struct CassiniIndexLine
             {
                 QString cels[8];
             }CassiniIndexLine;
             class CassiniIndexFile:QObject
             {
                 Q_OBJECT
             public:
                 CassiniIndexFile();
                 ~CassiniIndexFile();
                 QList<CassiniIndexLine> loadFile(const QString& file);
             signals:
             public slots:
             private:
             };
             #endif // CASSINIINDEXFILE_H

src/Cassini/cassiniindexfileviewer.cpp +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "cassiniindexfileviewer.h"
             #include "ui_cassiniindexfileviewer.h"
             #include <QFileDialog>
             CassiniIndexFileViewer::CassiniIndexFileViewer(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::CassiniIndexFileViewer)
             {
                 ui->setupUi(this);
                 this->indexFile = new CassiniIndexFile();
                 connect(this->ui->loadFileQpb,SIGNAL(clicked()),this,SLOT(loadFile()));
                 connect(this->ui->FilteerInput,SIGNAL(textChanged(QString)),this,SLOT(filterCol(QString)));
             }
             CassiniIndexFileViewer::~CassiniIndexFileViewer()
             {
                 delete this->indexFile;
                 delete ui;
             }
             void CassiniIndexFileViewer::filterCol(const QString &pattern)
             {
                 Qt::MatchFlags flag = Qt::MatchContains | Qt::MatchStartsWith	| Qt::MatchEndsWith  | Qt::MatchRegExp | Qt::MatchWildcard | Qt::MatchWrap |Qt::MatchRecursive;
                 if(this->ui->FilterCaseSensitive->isChecked())
                     flag |= Qt::MatchCaseSensitive;
                 if(pattern.isEmpty())
                 {
                     for(int i=0;i<this->ui->IndexView->rowCount();i++)
                         this->ui->IndexView->setRowHidden(i,false);
                 }
                 else
                 {
                     for(int i=0;i<this->ui->IndexView->rowCount();i++)
                         this->ui->IndexView->setRowHidden(i,true);
                     QList<QTableWidgetItem*> items = this->ui->IndexView->findItems(pattern,flag);
                     for(int i=0;i<items.count();i++)
                         this->ui->IndexView->setRowHidden(items.at(i)->row(),false);
                 }
             }
             void CassiniIndexFileViewer::loadFile()
             {
                 QList<CassiniIndexLine> lines=this->indexFile->loadFile(QFileDialog::getOpenFileName());
                 this->ui->IndexView->clear();
                 this->ui->IndexView->setRowCount(lines.count());
                 this->ui->IndexView->setHorizontalHeaderLabels(QStringList()<<"Dataset ID"<<"File specification name"<<"Product ID"<<"Volume ID"<<"Product Creation Time"<<"Taget name"<<"Start time"<<"Stop time");
                 for(int i=0;i<lines.count();i++)
                 {
                     for(int j=0;j<8;j++)
                     {
                         QString cel=QString(lines.at(i).cels[j]).remove('\n').remove('\r');
                         QTableWidgetItem *newItem = new QTableWidgetItem(cel);
                         newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                         this->ui->IndexView->setItem(i, j, newItem);
                     }
                 }
             }
             void CassiniIndexFileViewer::changeEvent(QEvent *e)
             {
                 QWidget::changeEvent(e);
                 switch (e->type()) {
                 case QEvent::LanguageChange:
                     ui->retranslateUi(this);
                     break;
                 default:
                     break;
                 }
             }

src/Cassini/cassiniindexfileviewer.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef CASSINIINDEXFILEVIEWER_H
             #define CASSINIINDEXFILEVIEWER_H
             #include <QWidget>
             #include <cassiniindexfile.h>
             namespace Ui {
             class CassiniIndexFileViewer;
             }
             class CassiniIndexFileViewer : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit CassiniIndexFileViewer(QWidget *parent = 0);
                 ~CassiniIndexFileViewer();
             public slots:
                 void filterCol(const QString& pattern);
                 void loadFile();
             protected:
                 void changeEvent(QEvent *e);
             private:
                 Ui::CassiniIndexFileViewer *ui;
                 CassiniIndexFile* indexFile;
             };
             #endif // CASSINIINDEXFILEVIEWER_H

src/Cassini/cassinitools.cpp +29 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "cassinitools.h"
             #include <qlopplots.h>
             #include <QPen>
             #include <QAction>
             #include <fftw3.h>
+            #include <omp.h>
             CassiniTools* CassiniTools::_self=NULL;
             QDockWidget* CassiniTools::m_gui=NULL;
             CassiniToolsGUI* CassiniTools::m_CassiniToolsGUI=NULL;
             CassiniDataFile* CassiniTools::m_dataFile=NULL;
             int CassiniTools::m_defaultPlot=-1;
             int CassiniTools::m_fftPlot=-1;
             SocExplorerPlotActions* CassiniTools::ExportAction=NULL;
             Qt::GlobalColor QLopColours[]= {Qt::black,
                                             Qt::red,
                                             Qt::blue,
                                             Qt::green,
                                             Qt::darkGreen,
                                             Qt::cyan,
                                             Qt::darkRed,
                                             Qt::gray,
                                             Qt::yellow,
                                             Qt::darkBlue,
                                             Qt::darkCyan,
                                             Qt::magenta,
                                             Qt::darkMagenta,
                                             Qt::darkYellow,
                                             Qt::darkGray,
                                             Qt::lightGray};
             int QLopColoursCount=16;
             #define _INIT() if(Q_UNLIKELY(_self==NULL)){init();}
             CassiniTools::CassiniTools(bool noGUI,QObject *parent) : QLopService(parent)
             {
                 m_dataFile = new CassiniDataFile();
                 connect(m_dataFile,SIGNAL(dataReady(QLopDataList)),this,SLOT(dataReady(QLopDataList)));
                 m_serviceName="CassiniTools";
                 m_noGui=noGUI;
+                fftw_init_threads();
             }
             CassiniTools::~CassiniTools()
             {
                 delete m_dataFile;
                 delete m_CassiniToolsGUI;
                 delete m_gui;
             }
             void CassiniTools::makePlot()
             {
                 m_defaultPlot = QLopPlots::addPlot();
                 m_fftPlot = QLopPlots::addPlot();
                 SocExplorerPlot* plot=QLopPlots::getPlot(m_defaultPlot);
                 if(plot)
                 {
                     plot->setTitle(_self->m_serviceName + " plot");
                     plot->setXaxisTickLabelType(QCPAxis::ltDateTime);
                     plot->setXaxisDateTimeFormat("hh:mm:ss.zzz");
                     plot->setContextMenuPolicy(Qt::ActionsContextMenu);
                     SocExplorerPlotActions* action=new SocExplorerPlotActions("export view",plot->PID(),_self);
                     plot->addAction(action);
                     QObject::connect(action,SIGNAL(triggered(int)),_self,SLOT(export_view(int)));
                     ExportAction=new SocExplorerPlotActions("export view to "+QString(plot->title()).replace(".TAB","-part.TAB"),plot->PID(),_self);
                     plot->addAction(ExportAction);
                     QObject::connect(ExportAction,SIGNAL(triggered(int)),_self,SLOT(export_view_Predefined_FileName(int)));
                     action=new SocExplorerPlotActions("FFT of the current view",plot->PID(),_self);
                     plot->addAction(action);
                     QObject::connect(action,SIGNAL(triggered(int)),_self,SLOT(compute_fft_on_view(int)));
                 }
             }
             void CassiniTools::init(bool noGUI, QObject *parent)
             {
                 if(Q_UNLIKELY(_self==NULL))
                 {
                     _self=new CassiniTools(noGUI,parent);
                 }
             }
             CassiniTools *CassiniTools::self()
             {
                 _INIT();
                 return _self;
             }
             void CassiniTools::decodeFGMData(const QString &file)
             {
                 _INIT();
                 m_dataFile->parseFile(file);
             }
             void CassiniTools::plotFile(const QString &File)
             {
                 if(!m_dataFile->isRunning())
                 {
                     m_dataFile->parseFile(File);
                     // TODO fixme
                     SocExplorerPlot* plot = QLopPlots::getPlot(m_defaultPlot);
                     if(plot==NULL)
                     {
                         makePlot();
                         plot = QLopPlots::getPlot(m_defaultPlot);
                     }
                     if(plot)
                     {
                         plot->setTitle(File);
                         ExportAction->setText("export view to "+QString(File).replace(".TAB","-part.TAB"));
                     }
                 }
             }
             void CassiniTools::plot_TAB_File(const QString &fileName)
             {
                 //TODO fix: accent not accepted
                 plotFile(fileName);
             }
             void CassiniTools::export_view(int PID)
             {
                 SocExplorerPlot* plot = QLopPlots::getPlot(PID);
                 if(plot==NULL)
                     return;
                 {
                     QString fileName = plot->title();
                     fileName = QFileDialog::getSaveFileName(0,tr("Set filename"),fileName.replace(".TAB","-part.TAB"));
                     if(fileName!="")
                     {
                         QLopDataList vectors;
                         for(int i=0;i<plot->graphCount();i++)
                         {
                             QLopData* vect = new QLopData();
                             vect->data = plot->getVisibleData(i);
                             vectors.append(vect);
                         }
                         m_dataFile->saveFile(fileName,vectors);
                     }
                 }
             }
             void CassiniTools::export_view_Predefined_FileName(int PID)
             {
                 SocExplorerPlot* plot = QLopPlots::getPlot(PID);
                 if(plot==NULL)
                     return;
                 {
                     QString fileName = QString(plot->title()).replace(".TAB","-part.TAB");
                     if(fileName!="")
                     {
                         QLopDataList vectors;
                         for(int i=0;i<plot->graphCount();i++)
                         {
                             QLopData* vect = new QLopData();
                             vect->data = plot->getVisibleData(i);
                             vectors.append(vect);
                         }
                         m_dataFile->saveFile(fileName,vectors);
                     }
                 }
             }
             void CassiniTools::compute_fft_on_view(int PID)
             {
+                QElapsedTimer timr;
                 SocExplorerPlot* plot = QLopPlots::getPlot(PID);
                 if(plot==NULL)
                     return;
                 {
+                    timr.start();
                     QLopDataList vectors;
                     for(int i=0;i<plot->graphCount();i++)
                     {
                         QLopData* vect = new QLopData();
                         vect->data = plot->getVisibleData(i);
                         vectors.append(vect);
                     }
                     if(vectors.count()==3)
                     {
                         QLopData* ch1V=vectors.at(0);
                         QLopData* ch2V=vectors.at(1);
                         QLopData* ch3V=vectors.at(2);
                         QLopData* FFTout=new QLopData();
                         if(ch1V->data->count()==ch2V->data->count() && ch1V->data->count()==ch3V->data->count())
                         {
                             double* in;
                             fftw_complex *out;
                             fftw_plan p;
                             FFTout->data = new QVector<QCPData>(ch1V->data->count()/2);
                             in = (double*) fftw_malloc(sizeof(double) * ch1V->data->count());
                             out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * ch1V->data->count());
                             double av=0;
                             for(int i=0;i<ch1V->data->count();i++)
                             {
                                 in[i]=sqrt((ch1V->data->at(i).value*ch1V->data->at(i).value) + (ch2V->data->at(i).value*ch2V->data->at(i).value) + (ch3V->data->at(i).value*ch3V->data->at(i).value));
                                 av = av+in[i];
                             }
                             av/=ch1V->data->count();
                             for(int i=0;i<ch1V->data->count();i++)
                             {
                                 in[i]=in[i]-av;
                             }
+                            fftw_plan_with_nthreads(4);
                             p = fftw_plan_dft_r2c_1d(ch1V->data->count(),in, out,FFTW_ESTIMATE);
                             fftw_execute(p); /* repeat as needed */
                             fftw_destroy_plan(p);
                             fftw_free(in);
                             for(int i=0;i<ch1V->data->count()/2;i++)
                             {
             //                    (*FFTout->data)[i].value=sqrt((out[i][0] * out[i][0]) + (out[i][1] * out[i][1]))/ch1V->data->count();
                                 (*FFTout->data)[i].value=((out[i][0] * out[i][0]) + (out[i][1] * out[i][1]))/(ch1V->data->count());
                                 (*FFTout->data)[i].key = i;
                             }
                             fftw_free(out);
                             SocExplorerPlot* plot = QLopPlots::getPlot(m_fftPlot);
                             if(plot==NULL)
                                 return;
                             plot->removeAllGraphs();
                             plot->addGraph();
                             plot->setXaxisLog();
                             plot->setYaxisLog();
                             plot->setAdaptativeSampling(0,true);
                             QPen pen = plot->getGraphPen(0);
                             pen.setColor(QLopColours[0%QLopColoursCount]);
                             plot->setGraphPen(0,pen);
                             plot->setGraphData(0,FFTout->data,false);
                             plot->rescaleAxis();
                             plot->replot();
+                            qDebug()<< ch1V->data->count() <<" Points loaded in "<< timr.elapsed()<<"ms";
                         }
                     }
                 }
             }
             QDockWidget *CassiniTools::getGUI()
             {
                 if(!m_noGui && (m_gui==NULL))
                 {
                     m_gui=new QDockWidget("Cassini Tools");
                     m_CassiniToolsGUI = new CassiniToolsGUI();
                     m_gui->setWidget(m_CassiniToolsGUI);
                     m_gui->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable);
                 }
                 return m_gui;
             }
             const QString &CassiniTools::serviceName()
             {
                 _INIT();
                 return m_serviceName;
             }
             void CassiniTools::dataReady(QLopDataList data)
             {
                 SocExplorerPlot* plot = QLopPlots::getPlot(m_defaultPlot);
                 if(plot==NULL)
                 {
                     makePlot();
                     plot = QLopPlots::getPlot(m_defaultPlot);
                 }
                 if(plot)
                 {
                     plot->removeAllGraphs();
                     for(int i=0;i<data.count();i++)
                     {
                         plot->addGraph();
                         plot->setAdaptativeSampling(i,true);
                         plot->setUseFastVector(i,true);
                         QPen pen = plot->getGraphPen(i);
                         pen.setColor(QLopColours[i%QLopColoursCount]);
                         plot->setGraphPen(i,pen);
                         plot->setGraphName(i,data.at(i)->name+"("+data.at(i)->unit+")");
                         plot->setGraphData(i,data.at(i)->data,false);
                     }
                     plot->rescaleAxis();
                     plot->replot();
                 }
             }

src/Cassini/cassinitools.h +21 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef CASSINITOOLS_H
             #define CASSINITOOLS_H
             #include <QObject>
             #include <QWidget>
             #include <qlopservice.h>
             #include <cassinitoolsgui.h>
             #include <cassinidatafile.h>
             #include <qlopdata.h>
             #include <SocExplorerPlot.h>
             class CassiniTools: public QLopService
             {
                 Q_OBJECT
             private:
                 static CassiniTools* _self;
                 static QDockWidget* m_gui;
                 static CassiniToolsGUI* m_CassiniToolsGUI;
                 static CassiniDataFile* m_dataFile;
                 static int m_defaultPlot,m_fftPlot;
                 static SocExplorerPlotActions* ExportAction;
                 CassiniTools(bool noGUI=false, QObject *parent=0);
                 ~CassiniTools();
                 static void makePlot();
             public:
                 static void init(bool noGUI=false,QObject *parent = 0);
                 static CassiniTools *self();
                 static void decodeFGMData(const QString& file);
                 // QLopService methodes
                 QDockWidget* getGUI();
                 const QString& serviceName();
                 static void plotFile(const QString &File);
             public slots:
                 void plot_TAB_File(const QString& fileName);
                 void export_view(int PID);
                 void export_view_Predefined_FileName(int PID);
                 void compute_fft_on_view(int PID);
             private slots:
                 void dataReady(QLopDataList data);
             };
             #endif // CASSINITOOLS_H

src/Cassini/cassinitoolsgui.cpp +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "cassinitoolsgui.h"
             #include "ui_cassinitoolsgui.h"
             #include <cassinitools.h>
             CassiniToolsGUI::CassiniToolsGUI(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::CassiniToolsGUI)
             {
                 ui->setupUi(this);
                 connect(this->ui->addFolderViewQpb,SIGNAL(clicked()),this,SLOT(addFolderView()));
             }
             CassiniToolsGUI::~CassiniToolsGUI()
             {
                 delete ui;
             }
             void CassiniToolsGUI::addFolderView()
             {
                 this->fileBrowsers.append(new FileBrowser());
                 this->ui->folderViews->addDockWidget(Qt::TopDockWidgetArea,this->fileBrowsers.last());
                 this->fileBrowsers.last()->setWindowTitle( QString("Browser %1").arg(this->fileBrowsers.length()));
                 this->fileBrowsers.last()->setAllowedAreas(Qt::AllDockWidgetAreas);
                 this->fileBrowsers.last()->setNameFilters(QStringList()<<"*.TAB");
                 connect(this->fileBrowsers.last(),SIGNAL(fileDoubleClicked(QString)),this,SLOT(plotFile(QString)));
             }
             void CassiniToolsGUI::plotFile(const QString &File)
             {
                 CassiniTools::plotFile(File);
             }
             void CassiniToolsGUI::changeEvent(QEvent *e)
             {
                 QWidget::changeEvent(e);
                 switch (e->type()) {
                 case QEvent::LanguageChange:
                     ui->retranslateUi(this);
                     break;
                 default:
                     break;
                 }
             }

src/Cassini/cassinitoolsgui.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef CASSINITOOLSGUI_H
             #define CASSINITOOLSGUI_H
             #include <QWidget>
             #include <filebrowser.h>
             namespace Ui {
             class CassiniToolsGUI;
             }
             class CassiniToolsGUI : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit CassiniToolsGUI(QWidget *parent = 0);
                 ~CassiniToolsGUI();
             protected:
                 void changeEvent(QEvent *e);
             private slots:
                 void addFolderView();
                 void plotFile(const QString &File);
             private:
                 Ui::CassiniToolsGUI *ui;
                 QList<FileBrowser*> fileBrowsers;
             };
             #endif // CASSINITOOLSGUI_H

src/Cassini/expxmldownloader.cpp +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "expxmldownloader.h"
             #include <QDebug>
             #include <QFile>
             #include <QQueue>
             #include <QDate>
             #include <QDateTime>
             ExpXmlDownLoader::ExpXmlDownLoader(QObject *parent) : QObject(parent)
             {
                 this->m_doc = NULL;
             }
             ExpXmlDownLoader::~ExpXmlDownLoader()
             {
             }
             bool ExpXmlDownLoader::parseXml(const QString &fileName)
             {
                 QQueue<QString> nodes;
                 nodes<<"RESOURCE"<<"TABLE"<<"DATA"<<"TABLEDATA";
                 if(m_doc!=NULL)
                     delete m_doc;
                 m_doc = new QDomDocument(fileName);
                 QFile file(fileName);
                 if (!file.open(QIODevice::ReadOnly))
                     return false;
                 if (!m_doc->setContent(&file)) {
                     file.close();
                     return false;
                 }
                 file.close();
                 if(m_doc->isNull())
                 {
                     delete m_doc;
                     return false;
                 }
                 QDomElement docElem = m_doc->documentElement();
                 QDomNode n = docElem.firstChild();
                 while(!n.isNull() && !nodes.empty())
                 {
                     if(n.toElement().tagName()==nodes.head())
                     {
                         nodes.dequeue();
                         n=n.firstChild();
                     }
                     else
                     {
                         n = n.nextSibling();
                     }
                 }
                 extractIntervals(n);
                 makeDownloadList();
                 return true;
             }
             const QList<QDate> &ExpXmlDownLoader::daysToDownload()
             {
                 return m_FilesToDownload;
             }
             void ExpXmlDownLoader::extractIntervals(QDomNode n)
             {
                 QDomNode inter;
                 m_intervals.clear();
                 while(!n.isNull())
                 {
                     if(n.toElement().tagName()=="TR")
                     {
                         ExpXmlDownLoaderIntervals interval;
                         inter=n.firstChild();
                         if(inter.toElement().tagName()=="TD")
                         {
                             interval.start = inter.toElement().text();
                         }
                         inter=inter.nextSibling();
                         if(inter.toElement().tagName()=="TD")
                         {
                             interval.stop = inter.toElement().text();
                         }
                         m_intervals.append(interval);
                     }
                     n = n.nextSibling();
                 }
             }
             void ExpXmlDownLoader::makeDownloadList()
             {
                 for(int i=0;i<m_intervals.count();i++)
                 {
                     QList<QDate> daysToDl;
                     QDateTime start,stop;
                     start=start.fromString(m_intervals[i].start,Qt::ISODate);
                     stop=stop.fromString(m_intervals[i].stop,Qt::ISODate);
                     int days=start.daysTo(stop);
                     daysToDl.append(start.date());
                     if(days)
                     {
                         for(int j=0;j<days;j++)
                         {
                             daysToDl.append(start.addDays(j+1).date());
                         }
                     }
                     addDaysToDownload(daysToDl);
                 }
                 qDebug()<<m_FilesToDownload.count();
             }
             void ExpXmlDownLoader::addDaysToDownload(QList<QDate> days)
             {
                 for(int i=0;i<days.count();i++)
                 {
                     if(!m_FilesToDownload.contains(days.at(i)))
                     {
                         m_FilesToDownload.append(days.at(i));
                     }
                 }
             }

src/Cassini/expxmldownloader.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef EXPXMLDOWNLOADER_H
             #define EXPXMLDOWNLOADER_H
             #include <QObject>
             #include <QDomDocument>
             #include <QList>
             typedef struct ExpXmlDownLoaderIntervals
             {
                 QString date;
                 QString start;
                 QString stop;
             }ExpXmlDownLoaderIntervals;
             class ExpXmlDownLoader : public QObject
             {
                 Q_OBJECT
             public:
                 explicit ExpXmlDownLoader(QObject *parent = 0);
                 ~ExpXmlDownLoader();
                 bool parseXml(const QString& fileName);
                 const QList<QDate>& daysToDownload();
             signals:
             public slots:
             private:
                 void extractIntervals(QDomNode n);
                 void makeDownloadList();
                 void addDaysToDownload(QList<QDate> days);
                 QDomDocument* m_doc;
                 QList<ExpXmlDownLoaderIntervals> m_intervals;
                 QList<QDate> m_FilesToDownload;
             };
             #endif // EXPXMLDOWNLOADER_H

src/Core/Widgets/downloadhistory.cpp +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "downloadhistory.h"
             #include "ui_downloadhistory.h"
             DownLoadHistory::DownLoadHistory(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::DownLoadHistory)
             {
                 ui->setupUi(this);
                 vblayout = new QVBoxLayout(this->ui->scrollAreaWidgetContents);
                 vblayout->addStretch(1);
             }
             DownLoadHistory::~DownLoadHistory()
             {
                 delete ui;
             }
             void DownLoadHistory::addElement(DownloadHistoryElement *element)
             {
                 if(element)
                     this->vblayout->insertWidget(0,element);
             }
             void DownLoadHistory::changeEvent(QEvent *e)
             {
                 QWidget::changeEvent(e);
                 switch (e->type()) {
                 case QEvent::LanguageChange:
                     ui->retranslateUi(this);
                     break;
                 default:
                     break;
                 }
             }

src/Core/Widgets/downloadhistory.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef DOWNLOADHISTORY_H
             #define DOWNLOADHISTORY_H
             #include <QWidget>
             #include <downloadhistoryelement.h>
             #include <QVBoxLayout>
             namespace Ui {
             class DownLoadHistory;
             }
             class DownLoadHistory : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit DownLoadHistory(QWidget *parent = 0);
                 ~DownLoadHistory();
                 void addElement(DownloadHistoryElement* element);
             protected:
                 void changeEvent(QEvent *e);
             private:
                 Ui::DownLoadHistory *ui;
                 QVBoxLayout* vblayout;
             };
             #endif // DOWNLOADHISTORY_H

src/Core/Widgets/downloadhistoryelement.cpp +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "downloadhistoryelement.h"
             #include "ui_downloadhistoryelement.h"
             DownloadHistoryElement::DownloadHistoryElement(FileDownloaderTask *task, QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::DownloadHistoryElement)
             {
                 ui->setupUi(this);
                 if(task)
                 {
                     this->associatedTask=task;
                     this->ui->DownloadDate->setText(task->startDateTime().toString("yyyy:MM:dd-hh:mm:ss"));
                     this->ui->FileNameLbl->setText(task->fileName());
                     this->ui->linkLbl->setText(task->url());
                     connect(associatedTask,SIGNAL(updateProgress(int)),this,SLOT(updateProgress(int)));
                 }
                 /*this->setStyleSheet("QWidget#DownloadHistoryElement{\
                                     border: 1px solid gray;\
                                     border-radius: 9px;\
                                     margin-top: 0.5em; \
                                 }");*/
             }
             DownloadHistoryElement::~DownloadHistoryElement()
             {
                 delete ui;
             }
             void DownloadHistoryElement::updateProgress(int percent)
             {
                 this->ui->progressBar->setValue(percent);
             }
             void DownloadHistoryElement::changeEvent(QEvent *e)
             {
                 QWidget::changeEvent(e);
                 switch (e->type()) {
                 case QEvent::LanguageChange:
                     ui->retranslateUi(this);
                     break;
                 default:
                     break;
                 }
             }

src/Core/Widgets/downloadhistoryelement.h +21 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef DOWNLOADHISTORYELEMENT_H
             #define DOWNLOADHISTORYELEMENT_H
             #include <QWidget>
             #include <filedownloadertask.h>
             namespace Ui {
             class DownloadHistoryElement;
             }
             class DownloadHistoryElement : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit DownloadHistoryElement(FileDownloaderTask* task, QWidget *parent = 0);
                 ~DownloadHistoryElement();
             public slots:
                 void updateProgress(int percent);
             protected:
                 void changeEvent(QEvent *e);
             private:
                 Ui::DownloadHistoryElement *ui;
                 FileDownloaderTask* associatedTask;
             };
             #endif // DOWNLOADHISTORYELEMENT_H

src/Core/Widgets/filebrowser.cpp +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "filebrowser.h"
             #include "ui_filebrowser.h"
             #include <QListView>
             #include <QTreeView>
             FileBrowser::FileBrowser(QWidget *parent) :
                 QDockWidget(parent),
                 ui(new Ui::FileBrowser)
             {
                 ui->setupUi(this);
                 this->model = new FileSystemModel(this);
                 this->model->setRootPath(QDir::currentPath());
                 this->view = new QTreeView();
                 this->ui->gridLayout->addWidget(this->view,1,0,1,-1);
                 this->view->setModel(this->model);
                 this->cd(model->rootPath());
                 connect(this->view,SIGNAL(clicked(QModelIndex)),this,SLOT(clicked(QModelIndex)));
                 connect(this->view,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(doubleClicked(QModelIndex)));
                 connect(this->ui->ListViewQpb,SIGNAL(clicked()),this,SLOT(changeToListView()));
                 connect(this->ui->TreeViewQpb,SIGNAL(clicked()),this,SLOT(changeToTreeView()));
                 connect(this->ui->parentDirQpb,SIGNAL(clicked()),this,SLOT(parentDir()));
                 view->setSelectionMode(QAbstractItemView::ExtendedSelection);
                 view->setDragEnabled(true);
                 view->setAcceptDrops(true);
                 view->setDropIndicatorShown(true);
                 view->setDragDropMode(QAbstractItemView::DragDrop);
                 this->pathCompleter = new QCompleter(this->model,this);
                 this->ui->pathLineEdit->setCompleter(pathCompleter);
                 this->pathLineEditEnterEditMode(false);
             }
             FileBrowser::~FileBrowser()
             {
                 delete ui;
             }
             void FileBrowser::setNameFilters(const QStringList &filters,bool disables)
             {
                 this->model->setNameFilters(filters);
                 this->model->setNameFilterDisables(disables);
             }
             void FileBrowser::changeToTreeView()
             {
                 this->ui->gridLayout->removeWidget(this->view);
                 delete this->view;
                 this->view = new QTreeView();
                 this->ui->gridLayout->addWidget(this->view,1,0,1,-1);
                 this->view->setModel(this->model);
                 connect(this->view,SIGNAL(clicked(QModelIndex)),this,SLOT(clicked(QModelIndex)));
                 connect(this->view,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(doubleClicked(QModelIndex)));
                 this->cd(model->rootPath());
                 view->setSelectionMode(QAbstractItemView::ExtendedSelection);
                 view->setDragEnabled(true);
                 view->setAcceptDrops(true);
                 view->setDropIndicatorShown(true);
             }
             void FileBrowser::changeToListView()
             {
                 this->ui->gridLayout->removeWidget(this->view);
                 delete this->view;
                 this->view = new QListView();
                 this->ui->gridLayout->addWidget(this->view,1,0,1,-1);
                 this->view->setModel(this->model);
                 connect(this->view,SIGNAL(clicked(QModelIndex)),this,SLOT(clicked(QModelIndex)));
                 connect(this->view,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(doubleClicked(QModelIndex)));
                 this->cd(model->rootPath());
                 view->setSelectionMode(QAbstractItemView::ExtendedSelection);
                 view->setDragEnabled(true);
                 view->setAcceptDrops(true);
                 view->setDropIndicatorShown(true);
             }
             void FileBrowser::clicked(QModelIndex index)
             {
                 QString file=model->filePath(index);
                 if(QFile::exists(file))
                     emit fileClicked(file);
             }
             void FileBrowser::doubleClicked(QModelIndex index)
             {
                 if(model->isDir(index))
                 {
                     this->cd(model->filePath(index));
                 }
                 else
                 {
                     QString file=model->filePath(index);
                     if(QFile::exists(file))
                         emit fileDoubleClicked(file);
                 }
             }
             void FileBrowser::parentDir()
             {
                 this->cd(model->rootPath()+"/..");
             }
             void FileBrowser::cd(const QString &newPath)
             {
                 model->setRootPath(newPath);
                 this->view->setRootIndex(model->index(model->rootPath()));
                 this->ui->pathLineEdit->setText(model->rootPath());
             }
             void FileBrowser::changeEvent(QEvent *e)
             {
                 QDockWidget::changeEvent(e);
                 switch (e->type()) {
                 case QEvent::LanguageChange:
                     ui->retranslateUi(this);
                     break;
                 default:
                     break;
                 }
             }
             void FileBrowser::keyPressEvent(QKeyEvent *e)
             {
                 switch (e->key())
                 {
                 case Qt::Key_L:
                     if(e->modifiers()==Qt::ControlModifier)
                     {
                         pathLineEditEnterEditMode(true);
                         e->accept();
                     }
                     break;
                 case Qt::Key_Return:
                     pathLineEditEnterEditMode(false);
                     if(QFile::exists(this->ui->pathLineEdit->text()))
                     {
                         this->cd(this->ui->pathLineEdit->text());
                         e->accept();
                     }
                     break;
                 default:
                     break;
                 }
                 if(!e->isAccepted())
                     QDockWidget::keyPressEvent(e);
             }
             void FileBrowser::pathLineEditEnterEditMode(bool enter)
             {
                 this->ui->pathLineEdit->setReadOnly(!enter);
                 this->ui->pathLineEdit->setDisabled(!enter);
                 if(enter)
                     this->ui->pathLineEdit->setFocus();
             }

src/Core/Widgets/filebrowser.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef FILEBROWSER_H
             #define FILEBROWSER_H
             #include <QDockWidget>
             #include <QFileSystemModel>
             #include <QAbstractItemView>
             #include <filesystemmodel.h>
             #include <QKeyEvent>
             #include <QCompleter>
             namespace Ui {
             class FileBrowser;
             }
             class FileBrowser : public QDockWidget
             {
                 Q_OBJECT
             public:
                 explicit FileBrowser(QWidget *parent = 0);
                 ~FileBrowser();
                 void setNameFilters(const QStringList & filters, bool disables=false);
             signals:
                 void fileClicked(const QString& file);
                 void fileDoubleClicked(const QString& file);
             private slots:
                 void changeToTreeView();
                 void changeToListView();
                 void clicked(QModelIndex index);
                 void doubleClicked(QModelIndex index);
                 void parentDir();
                 void cd(const QString& newPath);
             protected:
                 void changeEvent(QEvent *e);
                 void keyPressEvent(QKeyEvent *e);
             private:
                 void pathLineEditEnterEditMode(bool enter=true);
                 Ui::FileBrowser *ui;
                 FileSystemModel* model;
                 QAbstractItemView* view;
                 QCompleter* pathCompleter;
             };
             #endif // FILEBROWSER_H

src/Core/Widgets/filesystemmodel.cpp +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "filesystemmodel.h"
             FileSystemModel::FileSystemModel(QObject *parent):QFileSystemModel(parent)
             {
                 this->setReadOnly(false);
             }
             FileSystemModel::~FileSystemModel()
             {
             }
             Qt::DropActions FileSystemModel::supportedDropActions() const
             {
                 return Qt::MoveAction;
             }
             Qt::ItemFlags FileSystemModel::flags(const QModelIndex &index) const
             {
                 Qt::ItemFlags defaultFlags = QFileSystemModel::flags(index);
                 defaultFlags &=  ~Qt::ItemIsEditable;
                 if (index.isValid())
                     return Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | defaultFlags;
                 else
                     return Qt::ItemIsDropEnabled | defaultFlags;
             }

src/Core/Widgets/filesystemmodel.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef FILESYSTEMMODEL_H
             #define FILESYSTEMMODEL_H
             #include <QObject>
             #include <QFileSystemModel>
             class FileSystemModel : public QFileSystemModel
             {
             public:
                 FileSystemModel(QObject* parent=0);
                 ~FileSystemModel();
                 Qt::DropActions supportedDropActions() const;
                 Qt::ItemFlags flags(const QModelIndex &index) const;
             };
             #endif // FILESYSTEMMODEL_H

src/Core/Widgets/qcustomplotvect.cpp +24 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
+            /*
+             * This code is mainly a copy of QCustomPlot's QCPGraph class
+            */
             #include "qcustomplotvect.h"
             #include <QVector>
             #include <QVectorIterator>
             QCustomPlotVect::QCustomPlotVect(QWidget *parent)
                 :QCustomPlot(parent)
             {
             }
             QCustomPlotVect::~QCustomPlotVect()
             {
             }
             QCPGraphVect *QCustomPlotVect::addGraph(QCPAxis *keyAxis, QCPAxis *valueAxis)
             {
                 if (!keyAxis) keyAxis = xAxis;
                 if (!valueAxis) valueAxis = yAxis;
                 if (!keyAxis || !valueAxis)
                   {
                     qDebug() << Q_FUNC_INFO << "can't use default QCustomPlot xAxis or yAxis, because at least one is invalid (has been deleted)";
                     return 0;
                   }
                 if (keyAxis->parentPlot() != this || valueAxis->parentPlot() != this)
                   {
                     qDebug() << Q_FUNC_INFO << "passed keyAxis or valueAxis doesn't have this QCustomPlot as parent";
                     return 0;
                   }
                 QCPGraphVect *newGraph = new QCPGraphVect(keyAxis, valueAxis);
                 if (addPlottable(newGraph))
                   {
                     newGraph->setName(QLatin1String("Graph ")+QString::number(mGraphs.size()));
                     return newGraph;
                   } else
                   {
                     delete newGraph;
                     return 0;
                 }
             }
             QCPGraphVect::QCPGraphVect(QCPAxis *keyAxis, QCPAxis *valueAxis)
                 :QCPGraph(keyAxis,valueAxis)
             {
                 mData = new QVector<QCPData>();
             }
             QCPGraphVect::~QCPGraphVect()
             {
                 delete mData;
             }
             void QCPGraphVect::setData(QVector<QCPData> *data)
             {
                 if(data!=mData)
                   {
                     delete this->mData;
                     this->mData = data;
                 }
             }
             QVector<QCPData> *QCPGraphVect::getVisibleData()
             {
                 QVector<QCPData>* data = new QVector<QCPData>();
                 bool mAdaptiveSampling_save = mAdaptiveSampling;
                 mAdaptiveSampling = false;
                 getPreparedData(data,NULL);
                 mAdaptiveSampling = mAdaptiveSampling_save;
                 return data;
             }
             void QCPGraphVect::draw(QCPPainter *painter)
             {
                 if (!mKeyAxis || !mValueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
                 int test = mKeyAxis.data()->range().size();
                 test = mData->count();
                 if (mKeyAxis.data()->range().size() <= 0 || mData->isEmpty()) return;
                 if (mLineStyle == lsNone && mScatterStyle.isNone()) return;
                 // allocate line and (if necessary) point vectors:
                 QVector<QPointF> *lineData = new QVector<QPointF>;
                 QVector<QCPData> *scatterData = 0;
                 if (!mScatterStyle.isNone())
                     scatterData = new QVector<QCPData>;
                 // fill vectors with data appropriate to plot style:
                 getPlotData(lineData, scatterData);
                 // check data validity if flag set:
             #ifdef QCUSTOMPLOT_CHECK_DATA
                 QCPDataMap::const_iterator it;
                 for (it = mData->constBegin(); it != mData->constEnd(); ++it)
                 {
                     if (QCP::isInvalidData(it.value().key, it.value().value) ||
                             QCP::isInvalidData(it.value().keyErrorPlus, it.value().keyErrorMinus) ||
                             QCP::isInvalidData(it.value().valueErrorPlus, it.value().valueErrorPlus))
                         qDebug() << Q_FUNC_INFO << "Data point at" << it.key() << "invalid." << "Plottable name:" << name();
                 }
             #endif
                 // draw fill of graph:
                 drawFill(painter, lineData);
                 // draw line:
                 if (mLineStyle == lsImpulse)
                     drawImpulsePlot(painter, lineData);
                 else if (mLineStyle != lsNone)
                     drawLinePlot(painter, lineData); // also step plots can be drawn as a line plot
                 // draw scatters:
                 if (scatterData)
                     drawScatterPlot(painter, scatterData);
                 // free allocated line and point vectors:
                 delete lineData;
                 if (scatterData)
                     delete scatterData;
             }
             void QCPGraphVect::getPlotData(QVector<QPointF> *lineData, QVector<QCPData> *scatterData) const
             {
                 switch(mLineStyle)
                 {
                 case lsNone: getScatterPlotData(scatterData); break;
                 case lsLine: getLinePlotData(lineData, scatterData); break;
                 case lsStepLeft: getStepLeftPlotData(lineData, scatterData); break;
                 case lsStepRight: getStepRightPlotData(lineData, scatterData); break;
                 case lsStepCenter: getStepCenterPlotData(lineData, scatterData); break;
                 case lsImpulse: getImpulsePlotData(lineData, scatterData); break;
                 }
             }
             void QCPGraphVect::getLinePlotData(QVector<QPointF> *linePixelData, QVector<QCPData> *scatterData) const
             {
                 QCPAxis *keyAxis = mKeyAxis.data();
                 QCPAxis *valueAxis = mValueAxis.data();
                 if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
                 if (!linePixelData) { qDebug() << Q_FUNC_INFO << "null pointer passed as linePixelData"; return; }
                 QVector<QCPData> lineData;
                 getPreparedData(&lineData, scatterData);
                 linePixelData->reserve(lineData.size()+2); // added 2 to reserve memory for lower/upper fill base points that might be needed for fill
                 linePixelData->resize(lineData.size());
                 // transform lineData points to pixels:
                 if (keyAxis->orientation() == Qt::Vertical)
                 {
                     for (int i=0; i<lineData.size(); ++i)
                     {
                         (*linePixelData)[i].setX(valueAxis->coordToPixel(lineData.at(i).value));
                         (*linePixelData)[i].setY(keyAxis->coordToPixel(lineData.at(i).key));
                     }
                 } else // key axis is horizontal
                 {
                     for (int i=0; i<lineData.size(); ++i)
                     {
                         (*linePixelData)[i].setX(keyAxis->coordToPixel(lineData.at(i).key));
                         (*linePixelData)[i].setY(valueAxis->coordToPixel(lineData.at(i).value));
                     }
                 }
             }
             QCPRange QCPGraphVect::getKeyRange(bool &foundRange, QCPAbstractPlottable::SignDomain inSignDomain, bool includeErrors) const
             {
                 QCPRange range;
                 bool haveLower = false;
                 bool haveUpper = false;
                 double current, currentErrorMinus, currentErrorPlus;
                 if (inSignDomain == sdBoth) // range may be anywhere
                   {
                     QVector<QCPData>::const_iterator it = mData->constBegin();
                     while (it != mData->constEnd())
                       {
                         current = (*it).key;
                         currentErrorMinus = (includeErrors ? (*it).keyErrorMinus : 0);
                         currentErrorPlus = (includeErrors ? (*it).keyErrorPlus : 0);
                         if (current-currentErrorMinus < range.lower || !haveLower)
                           {
                             range.lower = current-currentErrorMinus;
                             haveLower = true;
                           }
                         if (current+currentErrorPlus > range.upper || !haveUpper)
                           {
                             range.upper = current+currentErrorPlus;
                             haveUpper = true;
                           }
                         ++it;
                       }
                   } else if (inSignDomain == sdNegative) // range may only be in the negative sign domain
                   {
                     QVector<QCPData>::const_iterator it = mData->constBegin();
                     while (it != mData->constEnd())
                       {
                         current = (*it).key;
                         currentErrorMinus = (includeErrors ? (*it).keyErrorMinus : 0);
                         currentErrorPlus = (includeErrors ? (*it).keyErrorPlus : 0);
                         if ((current-currentErrorMinus < range.lower || !haveLower) && current-currentErrorMinus < 0)
                           {
                             range.lower = current-currentErrorMinus;
                             haveLower = true;
                           }
                         if ((current+currentErrorPlus > range.upper || !haveUpper) && current+currentErrorPlus < 0)
                           {
                             range.upper = current+currentErrorPlus;
                             haveUpper = true;
                           }
                         if (includeErrors) // in case point is in valid sign domain but errobars stretch beyond it, we still want to geht that point.
                           {
                             if ((current < range.lower || !haveLower) && current < 0)
                               {
                                 range.lower = current;
                                 haveLower = true;
                               }
                             if ((current > range.upper || !haveUpper) && current < 0)
                               {
                                 range.upper = current;
                                 haveUpper = true;
                               }
                           }
                         ++it;
                       }
                   } else if (inSignDomain == sdPositive) // range may only be in the positive sign domain
                   {
                     QVector<QCPData>::const_iterator it = mData->constBegin();
                     while (it != mData->constEnd())
                       {
                         current = (*it).key;
                         currentErrorMinus = (includeErrors ? (*it).keyErrorMinus : 0);
                         currentErrorPlus = (includeErrors ? (*it).keyErrorPlus : 0);
                         if ((current-currentErrorMinus < range.lower || !haveLower) && current-currentErrorMinus > 0)
                           {
                             range.lower = current-currentErrorMinus;
                             haveLower = true;
                           }
                         if ((current+currentErrorPlus > range.upper || !haveUpper) && current+currentErrorPlus > 0)
                           {
                             range.upper = current+currentErrorPlus;
                             haveUpper = true;
                           }
                         if (includeErrors) // in case point is in valid sign domain but errobars stretch beyond it, we still want to get that point.
                           {
                             if ((current < range.lower || !haveLower) && current > 0)
                               {
                                 range.lower = current;
                                 haveLower = true;
                               }
                             if ((current > range.upper || !haveUpper) && current > 0)
                               {
                                 range.upper = current;
                                 haveUpper = true;
                               }
                           }
                         ++it;
                       }
                   }
                 foundRange = haveLower && haveUpper;
                 return range;
             }
             QCPRange QCPGraphVect::getValueRange(bool &foundRange, QCPAbstractPlottable::SignDomain inSignDomain, bool includeErrors) const
             {
                 QCPRange range;
                 bool haveLower = false;
                 bool haveUpper = false;
                 double current, currentErrorMinus, currentErrorPlus;
                 if (inSignDomain == sdBoth) // range may be anywhere
                   {
                     QVector<QCPData>::const_iterator it = mData->constBegin();
                     while (it != mData->constEnd())
                       {
                         current = (*it).value;
                         currentErrorMinus = (includeErrors ? (*it).valueErrorMinus : 0);
                         currentErrorPlus = (includeErrors ? (*it).valueErrorPlus : 0);
                         if (current-currentErrorMinus < range.lower || !haveLower)
                           {
                             range.lower = current-currentErrorMinus;
                             haveLower = true;
                           }
                         if (current+currentErrorPlus > range.upper || !haveUpper)
                           {
                             range.upper = current+currentErrorPlus;
                             haveUpper = true;
                           }
                         ++it;
                       }
                   } else if (inSignDomain == sdNegative) // range may only be in the negative sign domain
                   {
                     QVector<QCPData>::const_iterator it = mData->constBegin();
                     while (it != mData->constEnd())
                       {
                         current = (*it).value;
                         currentErrorMinus = (includeErrors ? (*it).valueErrorMinus : 0);
                         currentErrorPlus = (includeErrors ? (*it).valueErrorPlus : 0);
                         if ((current-currentErrorMinus < range.lower || !haveLower) && current-currentErrorMinus < 0)
                           {
                             range.lower = current-currentErrorMinus;
                             haveLower = true;
                           }
                         if ((current+currentErrorPlus > range.upper || !haveUpper) && current+currentErrorPlus < 0)
                           {
                             range.upper = current+currentErrorPlus;
                             haveUpper = true;
                           }
                         if (includeErrors) // in case point is in valid sign domain but errobars stretch beyond it, we still want to get that point.
                           {
                             if ((current < range.lower || !haveLower) && current < 0)
                               {
                                 range.lower = current;
                                 haveLower = true;
                               }
                             if ((current > range.upper || !haveUpper) && current < 0)
                               {
                                 range.upper = current;
                                 haveUpper = true;
                               }
                           }
                         ++it;
                       }
                   } else if (inSignDomain == sdPositive) // range may only be in the positive sign domain
                   {
                     QVector<QCPData>::const_iterator it = mData->constBegin();
                     while (it != mData->constEnd())
                       {
                         current = (*it).value;
                         currentErrorMinus = (includeErrors ? (*it).valueErrorMinus : 0);
                         currentErrorPlus = (includeErrors ? (*it).valueErrorPlus : 0);
                         if ((current-currentErrorMinus < range.lower || !haveLower) && current-currentErrorMinus > 0)
                           {
                             range.lower = current-currentErrorMinus;
                             haveLower = true;
                           }
                         if ((current+currentErrorPlus > range.upper || !haveUpper) && current+currentErrorPlus > 0)
                           {
                             range.upper = current+currentErrorPlus;
                             haveUpper = true;
                           }
                         if (includeErrors) // in case point is in valid sign domain but errobars stretch beyond it, we still want to geht that point.
                           {
                             if ((current < range.lower || !haveLower) && current > 0)
                               {
                                 range.lower = current;
                                 haveLower = true;
                               }
                             if ((current > range.upper || !haveUpper) && current > 0)
                               {
                                 range.upper = current;
                                 haveUpper = true;
                               }
                           }
                         ++it;
                       }
                   }
                 foundRange = haveLower && haveUpper;
                 return range;
             }
             void QCPGraphVect::getPreparedData(QVector<QCPData> *lineData, QVector<QCPData> *scatterData) const
             {
                 QCPAxis *keyAxis = mKeyAxis.data();
                 QCPAxis *valueAxis = mValueAxis.data();
                 if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
                 // get visible data range:
                 QVector<QCPData>::const_iterator lower, upper; // note that upper is the actual upper point, and not 1 step after the upper point
                 getVisibleDataBounds(lower, upper);
                 if (lower == mData->constEnd() || upper == mData->constEnd())
                   return;
                 // count points in visible range, taking into account that we only need to count to the limit maxCount if using adaptive sampling:
                 int maxCount = std::numeric_limits<int>::max();
                 if (mAdaptiveSampling)
                   {
                     int keyPixelSpan = qAbs(keyAxis->coordToPixel((*lower).key)-keyAxis->coordToPixel((*upper).key));
                     maxCount = 2*keyPixelSpan+2;
                   }
                 int dataCount = countDataInBounds(lower, upper, maxCount);
                 if (mAdaptiveSampling && dataCount >= maxCount) // use adaptive sampling only if there are at least two points per pixel on average
                   {
                     if (lineData)
                       {
                         QVector<QCPData>::const_iterator it = lower;
                         QVector<QCPData>::const_iterator upperEnd = upper+1;
                         double minValue = (*it).value;
                         double maxValue = (*it).value;
                         QVector<QCPData>::const_iterator currentIntervalFirstPoint = it;
                         int reversedFactor = keyAxis->rangeReversed() != (keyAxis->orientation()==Qt::Vertical) ? -1 : 1; // is used to calculate keyEpsilon pixel into the correct direction
                         int reversedRound = keyAxis->rangeReversed() != (keyAxis->orientation()==Qt::Vertical) ? 1 : 0; // is used to switch between floor (normal) and ceil (reversed) rounding of currentIntervalStartKey
                         double currentIntervalStartKey = keyAxis->pixelToCoord((int)(keyAxis->coordToPixel((*lower).key)+reversedRound));
                         double lastIntervalEndKey = currentIntervalStartKey;
                         double keyEpsilon = qAbs(currentIntervalStartKey-keyAxis->pixelToCoord(keyAxis->coordToPixel(currentIntervalStartKey)+1.0*reversedFactor)); // interval of one pixel on screen when mapped to plot key coordinates
                         bool keyEpsilonVariable = keyAxis->scaleType() == QCPAxis::stLogarithmic; // indicates whether keyEpsilon needs to be updated after every interval (for log axes)
                         int intervalDataCount = 1;
                         ++it; // advance iterator to second data point because adaptive sampling works in 1 point retrospect
                         while (it != upperEnd)
                           {
                             if ((*it).key < currentIntervalStartKey+keyEpsilon) // data point is still within same pixel, so skip it and expand value span of this cluster if necessary
                               {
                                 if ((*it).value < minValue)
                                   minValue = (*it).value;
                                 else if ((*it).value > maxValue)
                                   maxValue = (*it).value;
                                 ++intervalDataCount;
                               } else // new pixel interval started
                               {
                                 if (intervalDataCount >= 2) // last pixel had multiple data points, consolidate them to a cluster
                                   {
                                     if (lastIntervalEndKey < currentIntervalStartKey-keyEpsilon) // last point is further away, so first point of this cluster must be at a real data point
                                       lineData->append(QCPData(currentIntervalStartKey+keyEpsilon*0.2, (*currentIntervalFirstPoint).value));
                                     lineData->append(QCPData(currentIntervalStartKey+keyEpsilon*0.25, minValue));
                                     lineData->append(QCPData(currentIntervalStartKey+keyEpsilon*0.75, maxValue));
                                     if ((*it).key > currentIntervalStartKey+keyEpsilon*2) // new pixel started further away from previous cluster, so make sure the last point of the cluster is at a real data point
                                       lineData->append(QCPData(currentIntervalStartKey+keyEpsilon*0.8, (*(it-1)).value));
                                   } else
                                   lineData->append(QCPData((*currentIntervalFirstPoint).key, (*currentIntervalFirstPoint).value));
                                 lastIntervalEndKey = (*(it-1)).key;
                                 minValue = (*it).value;
                                 maxValue = (*it).value;
                                 currentIntervalFirstPoint = it;
                                 currentIntervalStartKey = keyAxis->pixelToCoord((int)(keyAxis->coordToPixel((*it).key)+reversedRound));
                                 if (keyEpsilonVariable)
                                   keyEpsilon = qAbs(currentIntervalStartKey-keyAxis->pixelToCoord(keyAxis->coordToPixel(currentIntervalStartKey)+1.0*reversedFactor));
                                 intervalDataCount = 1;
                               }
                             ++it;
                           }
                         // handle last interval:
                         if (intervalDataCount >= 2) // last pixel had multiple data points, consolidate them to a cluster
                           {
                             if (lastIntervalEndKey < currentIntervalStartKey-keyEpsilon) // last point wasn't a cluster, so first point of this cluster must be at a real data point
                               lineData->append(QCPData(currentIntervalStartKey+keyEpsilon*0.2, (*currentIntervalFirstPoint).value));
                             lineData->append(QCPData(currentIntervalStartKey+keyEpsilon*0.25, minValue));
                             lineData->append(QCPData(currentIntervalStartKey+keyEpsilon*0.75, maxValue));
                           } else
                           lineData->append(QCPData((*currentIntervalFirstPoint).key, (*currentIntervalFirstPoint).value));
                       }
                     if (scatterData)
                       {
                         double valueMaxRange = valueAxis->range().upper;
                         double valueMinRange = valueAxis->range().lower;
                         QVector<QCPData>::const_iterator it = lower;
                         QVector<QCPData>::const_iterator upperEnd = upper+1;
                         double minValue = (*it).value;
                         double maxValue = (*it).value;
                         QVector<QCPData>::const_iterator minValueIt = it;
                         QVector<QCPData>::const_iterator maxValueIt = it;
                         QVector<QCPData>::const_iterator currentIntervalStart = it;
                         int reversedFactor = keyAxis->rangeReversed() ? -1 : 1; // is used to calculate keyEpsilon pixel into the correct direction
                         int reversedRound = keyAxis->rangeReversed() ? 1 : 0; // is used to switch between floor (normal) and ceil (reversed) rounding of currentIntervalStartKey
                         double currentIntervalStartKey = keyAxis->pixelToCoord((int)(keyAxis->coordToPixel((*lower).key)+reversedRound));
                         double keyEpsilon = qAbs(currentIntervalStartKey-keyAxis->pixelToCoord(keyAxis->coordToPixel(currentIntervalStartKey)+1.0*reversedFactor)); // interval of one pixel on screen when mapped to plot key coordinates
                         bool keyEpsilonVariable = keyAxis->scaleType() == QCPAxis::stLogarithmic; // indicates whether keyEpsilon needs to be updated after every interval (for log axes)
                         int intervalDataCount = 1;
                         ++it; // advance iterator to second data point because adaptive sampling works in 1 point retrospect
                         while (it != upperEnd)
                           {
                             if ((*it).key < currentIntervalStartKey+keyEpsilon) // data point is still within same pixel, so skip it and expand value span of this pixel if necessary
                               {
                                 if ((*it).value < minValue && (*it).value > valueMinRange && (*it).value < valueMaxRange)
                                   {
                                     minValue = (*it).value;
                                     minValueIt = it;
                                   } else if ((*it).value > maxValue && (*it).value > valueMinRange && (*it).value < valueMaxRange)
                                   {
                                     maxValue = (*it).value;
                                     maxValueIt = it;
                                   }
                                 ++intervalDataCount;
                               } else // new pixel started
                               {
                                 if (intervalDataCount >= 2) // last pixel had multiple data points, consolidate them
                                   {
                                     // determine value pixel span and add as many points in interval to maintain certain vertical data density (this is specific to scatter plot):
                                     double valuePixelSpan = qAbs(valueAxis->coordToPixel(minValue)-valueAxis->coordToPixel(maxValue));
                                     int dataModulo = qMax(1, qRound(intervalDataCount/(valuePixelSpan/4.0))); // approximately every 4 value pixels one data point on average
                                     QVector<QCPData>::const_iterator intervalIt = currentIntervalStart;
                                     int c = 0;
                                     while (intervalIt != it)
                                       {
                                         if ((c % dataModulo == 0 || intervalIt == minValueIt || intervalIt == maxValueIt) && (*intervalIt).value > valueMinRange && (*intervalIt).value < valueMaxRange)
                                           scatterData->append((*intervalIt));
                                         ++c;
                                         ++intervalIt;
                                       }
                                   } else if ((*currentIntervalStart).value > valueMinRange && (*currentIntervalStart).value < valueMaxRange)
                                   scatterData->append((*currentIntervalStart));
                                 minValue = (*it).value;
                                 maxValue = (*it).value;
                                 currentIntervalStart = it;
                                 currentIntervalStartKey = keyAxis->pixelToCoord((int)(keyAxis->coordToPixel((*it).key)+reversedRound));
                                 if (keyEpsilonVariable)
                                   keyEpsilon = qAbs(currentIntervalStartKey-keyAxis->pixelToCoord(keyAxis->coordToPixel(currentIntervalStartKey)+1.0*reversedFactor));
                                 intervalDataCount = 1;
                               }
                             ++it;
                           }
                         // handle last interval:
                         if (intervalDataCount >= 2) // last pixel had multiple data points, consolidate them
                           {
                             // determine value pixel span and add as many points in interval to maintain certain vertical data density (this is specific to scatter plot):
                             double valuePixelSpan = qAbs(valueAxis->coordToPixel(minValue)-valueAxis->coordToPixel(maxValue));
                             int dataModulo = qMax(1, qRound(intervalDataCount/(valuePixelSpan/4.0))); // approximately every 4 value pixels one data point on average
                             QVector<QCPData>::const_iterator intervalIt = currentIntervalStart;
                             int c = 0;
                             while (intervalIt != it)
                               {
                                 if ((c % dataModulo == 0 || intervalIt == minValueIt || intervalIt == maxValueIt) && (*intervalIt).value > valueMinRange && (*intervalIt).value < valueMaxRange)
                                   scatterData->append((*intervalIt));
                                 ++c;
                                 ++intervalIt;
                               }
                           } else if ((*currentIntervalStart).value > valueMinRange && (*currentIntervalStart).value < valueMaxRange)
                           scatterData->append(*currentIntervalStart);
                       }
                   } else // don't use adaptive sampling algorithm, transfer points one-to-one from the map into the output parameters
                   {
                     QVector<QCPData> *dataVector = 0;
                     if (lineData)
                       {
                         dataVector = lineData;
                       }
                     else if (scatterData)
                       dataVector = scatterData;
                     if (dataVector)
                       {
                         QVector<QCPData>::const_iterator it = lower;
                         QVector<QCPData>::const_iterator upperEnd = upper+1;
                         dataVector->reserve(dataCount+2); // +2 for possible fill end points
                         while (it != upperEnd)
                           {
                             dataVector->append(*it);
                             ++it;
                           }
                       }
                     if (lineData && scatterData)
                       *scatterData = *dataVector;
                 }
             }
             QVector<QCPData>::const_iterator __lowerBoundDico_vect(QVector<QCPData>* vector,double key)
             {
               int DX=vector->size()/2;
               int pos=DX;
             //  double test=(*vector)[vector->length()-1].key;
               if(key>((*vector)[vector->length()-1].key))
                 return vector->constEnd();
               if(key<((*vector)[0].key))
                 return vector->constBegin();
               while (DX>1)
                 {
                   DX=DX/2;
                   if((*vector)[pos].key > key)
                     {
                       pos-=DX;
                     }
                   else
                     {
                       pos+=DX;
                     }
                 }
               if((*vector)[pos].key >= key)
                 return vector->constBegin()+pos;
               return vector->constBegin()+pos+1;
             }
             QVector<QCPData>::const_iterator __upperBoundDico_vect(QVector<QCPData>* vector,double key)
             {
               int DX=vector->size()/2;
               int pos=DX;
               if(key>((*vector)[vector->length()-1].key))
                 return vector->constEnd();
               if(key<((*vector)[0].key))
                 return vector->constBegin();
               while (DX>1)
                 {
                   DX=DX/2;
                   if((*vector)[pos].key > key)
                     {
                       pos-=DX;
                     }
                   else
                     {
                       pos+=DX;
                     }
                 }
               return vector->constBegin()+pos+1;
             }
             void QCPGraphVect::getVisibleDataBounds(QVector<QCPData>::const_iterator &lower, QVector<QCPData>::const_iterator &upper) const
             {
                 if (!mKeyAxis) { qDebug() << Q_FUNC_INFO << "invalid key axis"; return; }
                 if (mData->isEmpty())
                   {
                     lower = mData->constEnd();
                     upper = mData->constEnd();
                     return;
                   }
                 QVector<QCPData>::const_iterator lbound = __lowerBoundDico_vect(mData,mKeyAxis.data()->range().lower);
                 QVector<QCPData>::const_iterator ubound = __upperBoundDico_vect(mData,mKeyAxis.data()->range().upper);
                 bool lowoutlier = lbound != mData->constBegin(); // indicates whether there exist points below axis range
                 bool highoutlier = ubound != mData->constEnd(); // indicates whether there exist points above axis range
                 lower = (lowoutlier ? lbound-1 : lbound); // data point range that will be actually drawn
                 upper = (highoutlier ? ubound : ubound-1); // data point range that will be actually drawn
             }
             int QCPGraphVect::countDataInBounds(const QVector<QCPData>::const_iterator &lower, const QVector<QCPData>::const_iterator &upper, int maxCount) const
             {
                 if (upper == mData->constEnd() && lower == mData->constEnd())
                   return 0;
                 QVector<QCPData>::const_iterator  it = lower;
                 int count = 1;
                 while (it != upper && count < maxCount)
                   {
                     ++it;
                     ++count;
                   }
                 return count;
             }

src/Core/Widgets/qcustomplotvect.h +24 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
+            /*
+             * This code is mainly a copy of QCustomPlot's QCPGraph class
+            */
             #ifndef QCUSTOMPLOTVECT_H
             #define QCUSTOMPLOTVECT_H
             #include <QWidget>
             #include <qcustomplot.h>
             class QCPGraphVect : public QCPGraph
             {
                 Q_OBJECT
             public:
                 explicit QCPGraphVect(QCPAxis *keyAxis, QCPAxis *valueAxis);
                 ~QCPGraphVect();
                 QVector<QCPData> *data() const { return mData; }
                 void setData(QVector<QCPData> *data);
                 QVector<QCPData>* getVisibleData();
             protected:
                 QVector<QCPData>* mData;
                 virtual void draw(QCPPainter *painter);
                 virtual QCPRange getKeyRange(bool &foundRange, SignDomain inSignDomain, bool includeErrors) const; // overloads base class interface
                 virtual QCPRange getValueRange(bool &foundRange, SignDomain inSignDomain, bool includeErrors) const;
                 void getPreparedData(QVector<QCPData> *lineData, QVector<QCPData> *scatterData) const;
                 void getVisibleDataBounds(QVector<QCPData>::const_iterator &lower, QVector<QCPData>::const_iterator &upper) const;
                 int countDataInBounds(const QVector<QCPData>::const_iterator &lower, const QVector<QCPData>::const_iterator &upper, int maxCount) const;
                 void getPlotData(QVector<QPointF> *lineData, QVector<QCPData> *scatterData) const;
                 void getLinePlotData(QVector<QPointF> *linePixelData, QVector<QCPData> *scatterData) const;
             };
             class QCustomPlotVect : public QCustomPlot
             {
                 Q_OBJECT
             public:
                 QCustomPlotVect(QWidget *parent = 0);
                 ~QCustomPlotVect();
                 QCPGraphVect *addGraph(QCPAxis *keyAxis=0, QCPAxis *valueAxis=0);
             protected:
             };
             #endif // QCUSTOMPLOTVECT_H

src/Core/Widgets/qlopplots.cpp +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "qlopplots.h"
             #include  <QMainWindow>
             QLopPlots* QLopPlots::_self=NULL;
             SocExplorerPlot* QLopPlots::m_LastPlot=NULL;
             QDockWidget* QLopPlots::m_gui=NULL;
             QHash<int,SocExplorerPlot*>* QLopPlots::m_plots=NULL;
             toolBarContainer* QLopPlots::m_DocContainer=NULL;
             #define _INIT() if(Q_UNLIKELY(_self==NULL)){init();}
             QLopPlots::QLopPlots(bool noGUI,QObject *parent)
             {
                 m_noGui = noGUI;
                 m_serviceName = "QLopPlots";
                 m_plots = new QHash<int,SocExplorerPlot*>();
             }
             QLopPlots::~QLopPlots()
             {
             }
             int QLopPlots::getPlotID()
             {
                 _INIT();
                 for(int i=0;i<32768;i++)
                 {
                     if(!m_plots->contains(i))
                     {
                         return i;
                     }
                 }
                 return -1;
             }
             void QLopPlots::init(bool noGUI, QObject *parent)
             {
                 if(Q_UNLIKELY(_self==NULL))
                 {
                     _self=new QLopPlots(noGUI,parent);
                 }
             }
             QLopPlots *QLopPlots::self()
             {
                 _INIT();
                 return _self;
             }
             SocExplorerPlot *QLopPlots::getPlot(int plotID)
             {
                 _INIT();
                 if(!_self->m_noGui && (m_gui==NULL))
                 {
                     m_gui=new QDockWidget("Plots");
                     m_DocContainer = new toolBarContainer();
             //        m_SocExplorerPlot = new SocExplorerPlot();
                     m_gui->setWidget(m_DocContainer);
                     m_gui->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable);
                 }
                 if(m_plots->contains(plotID))
                 {
                     return m_plots->value(plotID);
                 }
                 if(plotID==-1)
                 {
                     return m_LastPlot;
                 }
                 return NULL;
             }
             int QLopPlots::addPlot()
             {
                 _INIT();
                 int pid=getPlotID();
                 if(pid!=-1)
                 {
                     SocExplorerPlot* plot=new SocExplorerPlot();
                     plot->setPID(pid);
                     m_plots->insert(pid,plot);
                     QDockWidget* dock = new QDockWidget();
                     dock->setWidget(plot);
                     dock->setAllowedAreas(Qt::AllDockWidgetAreas);
                     m_DocContainer->addDockWidget(Qt::TopDockWidgetArea,dock);
                     m_LastPlot=plot;
                     QObject::connect(plot,SIGNAL(titleChanged(QString)),dock,SLOT(setWindowTitle(QString)));
                     plot->setTitle(QString("Plot %1").arg(pid));
                 }
                 return pid;
             }
             bool QLopPlots::removePlot(int plotID)
             {
                 _INIT();
                 if(m_plots->contains(plotID))
                 {
                     SocExplorerPlot* plot=m_plots->value(plotID);
                     m_plots->remove(plotID);
                     QDockWidget* dock=(QDockWidget*)plot->parentWidget();
                     m_DocContainer->removeDockWidget(dock);
                     if(plot==m_LastPlot)
                     {
                         //TODO may cause troubles...
                         m_LastPlot = NULL;
                     }
                     if(dock!=NULL)
                     {
                         delete dock;
                     }
                     if(plot!=NULL)
                     {
                         delete plot;
                     }
                 }
                 return false;
             }
             QDockWidget *QLopPlots::getGUI()
             {
                 if(!m_noGui && (m_gui==NULL))
                 {
                     m_gui=new QDockWidget("Plots");
                     m_DocContainer = new toolBarContainer();
             //        m_SocExplorerPlot = new SocExplorerPlot();
                     m_gui->setWidget(m_DocContainer);
                     m_gui->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable);
                 }
                 return m_gui;
             }
             const QString &QLopPlots::serviceName()
             {
                 return m_serviceName;
             }
             SocExplorerPlot *QLopPlots::get_plot(int plotID)
             {
                 return getPlot(plotID);
             }
             int QLopPlots::add_plot()
             {
                 return addPlot();
             }
             bool QLopPlots::remove_plot(int plotID)
             {
                 return removePlot(plotID);
             }

src/Core/Widgets/qlopplots.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef QLOPPLOTS_H
             #define QLOPPLOTS_H
             #include <QObject>
             #include <QWidget>
             #include <qlopservice.h>
             #include <SocExplorerPlot.h>
             #include <QList>
             #include <QHash>
             #include <toolbarcontainer.h>
             class QLopPlots: public QLopService
             {
                 Q_OBJECT
             private:
                 static QLopPlots* _self;
                 static SocExplorerPlot* m_LastPlot;
                 static QHash<int,SocExplorerPlot*>* m_plots;
                 static QDockWidget* m_gui;
                 static toolBarContainer* m_DocContainer;
                 QLopPlots(bool noGUI=false,QObject *parent = 0);
                 ~QLopPlots();
                 static int getPlotID();
             public:
                 static void init(bool noGUI=false,QObject *parent = 0);
                 static QLopPlots *self();
                 static SocExplorerPlot* getPlot(int plotID=-1);
                 static int addPlot();
                 static bool removePlot(int plotID);
                 // QLopService methodes
                 QDockWidget* getGUI();
                 const QString& serviceName();
             public slots:
                 SocExplorerPlot* get_plot(int plotID);
                 int add_plot();
                 bool remove_plot(int plotID);
             public:
             };
             #endif // QLOPPLOTS_H

src/Core/abstractfileloader.cpp +22 0

@@ -1,12 +1,34
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the QLop Software
		3	-- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 2 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------*/
		19	/*-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@member.fsf.org
		21	----------------------------------------------------------------------------*/
		22
1	#include "abstractfileloader.h"	23	#include "abstractfileloader.h"
2		24
3	AbstractFileLoader::AbstractFileLoader(QObject *parent) : QThread(parent)	25	AbstractFileLoader::AbstractFileLoader(QObject *parent) : QThread(parent)
4	{	26	{
5		27
6	}	28	}
7		29
8	AbstractFileLoader::~AbstractFileLoader()	30	AbstractFileLoader::~AbstractFileLoader()
9	{	31	{
10		32
11	}	33	}
12		34

src/Core/abstractfileloader.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef ABSTRACTFILELOADER_H
             #define ABSTRACTFILELOADER_H
             #include <QObject>
             #include <QThread>
             #include "qcustomplot.h"
             #include <qlopdata.h>
             //typedef struct dataVector
             //{
             //  QString name;
             //  QString unit;
             //  QVector<QCPData>* data;
             //}dataVector;
             //typedef QList<dataVector> QListOfDataVector;
             class AbstractFileLoader : public QThread
             {
               Q_OBJECT
             public:
               explicit AbstractFileLoader(QObject *parent = 0);
               ~AbstractFileLoader();
               virtual void parseFile(const QString &fileName)=0;
             signals:
               void dataReady(QLopDataList data);
               void updateProgress(int threadId,int percentProgress);
             public slots:
             };
             #endif // ABSTRACTFILELOADER_H

src/Core/filedownloader.cpp +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "filedownloader.h"
             #include <QFile>
             FileDownloader* FileDownloader::_self=NULL;
             QNetworkAccessManager* FileDownloader::m_WebCtrl=NULL;
             QList<FileDownloaderTask*>* FileDownloader::m_pendingTasks=NULL;
             QDockWidget* FileDownloader::m_gui=NULL;
             DownLoadHistory* FileDownloader::m_DownLoadHistory=NULL;
             #define _INIT \
                 if(Q_UNLIKELY(_self==NULL))\
                 {\
                     init();\
                 }\
             int FileDownloader::downloadFile(QUrl fileUrl, const QString &name)
             {
                 _INIT
                 if(QFile::exists(name)|| QFile::exists(name+".part"))
                 {
                     return -1;
                 }
                 FileDownloaderTask* task=NULL;
                 int ID=_self->getTaskId();
                 if(ID!=-1)
                 {
                     QNetworkRequest request(fileUrl);
                     QNetworkReply* reply = m_WebCtrl->get(request);
                     if(reply && (reply->error()==QNetworkReply::NoError))
                     {
                         task=new FileDownloaderTask(reply,ID,name,_self);
                         m_pendingTasks->append(task);
                         if(!_self->m_noGui)
                         {
                             m_DownLoadHistory->addElement(new DownloadHistoryElement(task));
                         }
                     }
                     else
                     {
                         return -1;
                     }
                 }
                 return ID;
             }
             int FileDownloader::downloadFile(QString fileUrl, const QString &name)
             {
                 return downloadFile(QUrl(fileUrl),name);
             }
             QDockWidget *FileDownloader::getGUI()
             {
                 if(!_self->m_noGui && (m_gui==NULL))
                 {
                     m_DownLoadHistory=new DownLoadHistory();
                     m_gui=new QDockWidget("Download History");
                     m_gui->setWidget(m_DownLoadHistory);
                     m_gui->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable);
                 }
                 return (QDockWidget*) m_gui;
             }
             const QString &FileDownloader::serviceName()
             {
                 return m_serviceName;
             }
             int FileDownloader::download_file(QUrl fileUrl, const QString &name)
             {
                 return downloadFile(fileUrl,name);
             }
             int FileDownloader::download_file(QString fileUrl, const QString &name)
             {
                 return downloadFile(fileUrl,name);
             }
             FileDownloaderTask* FileDownloader::getDownloadTask(int ID)
             {
                 _INIT
                 for(int i=0;i<m_pendingTasks->count();i++)
                 {
                     if(m_pendingTasks->at(i)->ID()==ID)
                         return m_pendingTasks->at(i);
                 }
                 return NULL;
             }
             bool FileDownloader::taskIsCompleted(int ID)
             {
                 return getDownloadTask(ID)->downloadComplete();
             }
             FileDownloader *FileDownloader::self()
             {
                 _INIT
                 return _self;
             }
             int FileDownloader::getTaskId()
             {
                 for(unsigned int i=0;i<INT_MAX;i++)
                 {
                     bool idValid=true;
                     for(int j=0;j<m_pendingTasks->count();j++)
                     {
                         if(m_pendingTasks->at(j)->ID()==(int)i)
                             idValid=false;
                     }
                     if(idValid)
                         return (int)i;
                 }
                 return -1;
             }
             void FileDownloader::init(bool noGUI, QObject *parent)
             {
                 if(Q_UNLIKELY(_self==NULL))
                 {
                     _self=new FileDownloader(noGUI,parent);
                 }
             }
             FileDownloader::FileDownloader(bool noGUI,QObject *parent) : QLopService(parent)
             {
                 QNetworkProxyQuery q(QUrl("http://www.google.com"));
                 q.setQueryType(QNetworkProxyQuery::UrlRequest);
                 q.setProtocolTag("http");
                 QList<QNetworkProxy> proxies = QNetworkProxyFactory::systemProxyForQuery(q);
                 if( proxies.size() > 0 && proxies[0].type() != QNetworkProxy::NoProxy )
                   QNetworkProxy::setApplicationProxy(proxies[0]);
                 else
                  qDebug("No proxy server selected");
                 m_WebCtrl = new QNetworkAccessManager(this);
                 m_pendingTasks = new QList<FileDownloaderTask*>();
                 m_noGui=noGUI;
                 m_serviceName="FileDownloader";
             }
             FileDownloader::~FileDownloader()
             {
                 if(!m_noGui)
                     delete m_gui;
                 while (m_pendingTasks->count())
                 {
                     FileDownloaderTask* task=m_pendingTasks->last();
                     m_pendingTasks->removeLast();
                     delete task;
                 }
                 delete m_WebCtrl;
             }

src/Core/filedownloader.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef FILEDOWNLOADER_H
             #define FILEDOWNLOADER_H
             #include <QObject>
             #include <QNetworkAccessManager>
             #include <QNetworkReply>
             #include <QNetworkProxy>
             #include <QList>
             #include <QHash>
             #include <filedownloadertask.h>
             #include <downloadhistory.h>
             #include <qlopservice.h>
             #include <QDockWidget>
             class FileDownloader : public QLopService
             {
                 Q_OBJECT
             private:
                 static FileDownloader* _self;
                 static QNetworkAccessManager* m_WebCtrl;
                 static QList<FileDownloaderTask*>* m_pendingTasks;
                 static DownLoadHistory* m_DownLoadHistory;
                 static QDockWidget* m_gui;
                 FileDownloader(bool noGUI=false,QObject *parent = 0);
                ~FileDownloader();
             public:
                 static void init(bool noGUI=false,QObject *parent = 0);
                 static int downloadFile(QUrl fileUrl,const QString& name);
                 static int downloadFile(QString fileUrl,const QString& name);
                 static FileDownloaderTask *getDownloadTask(int ID);
                 static bool taskIsCompleted(int ID);
                 static FileDownloader *self();
                 // QLopService methodes
                 QDockWidget* getGUI();
                 const QString& serviceName();
             signals:
             public slots:
                 int download_file(QUrl fileUrl,const QString& name);
                 int download_file(QString fileUrl,const QString& name);
             private:
                 int getTaskId();
             };
             #endif // FILEDOWNLOADER_H

src/Core/filedownloadertask.cpp +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "filedownloadertask.h"
             FileDownloaderTask::FileDownloaderTask(QNetworkReply *reply, int ID, const QString &fileName, QObject *parent) : QObject(parent)
             {
                 this->m_Reply = reply;
                 this->m_downloadComplete = false;
                 this->m_FileName = fileName;
                 this->m_taskId = ID;
                 this->m_file = new QFile(fileName+".part");
                 this->m_file->open(QIODevice::WriteOnly|QIODevice::Truncate);
                 this->m_startDateTime = QDateTime::currentDateTime();
                 this->m_URL = m_Reply->url().toString();
                 connect(this->m_Reply,SIGNAL(downloadProgress(qint64,qint64)),this,SLOT(downloadProgress(qint64,qint64)));
                 connect(this->m_Reply,SIGNAL(downloadProgress(qint64,qint64)),this,SIGNAL(updateProgress(qint64,qint64)));
                 connect(this->m_Reply,SIGNAL(readyRead()),this,SLOT(readReady()));
                 connect(this->m_Reply,SIGNAL(finished()),this,SLOT(downloadFinished()));
             }
             FileDownloaderTask::~FileDownloaderTask()
             {
                 delete m_file;
                 delete m_Reply;
             }
             int FileDownloaderTask::ID(){return m_taskId;}
             const QString &FileDownloaderTask::fileName(){return m_FileName;}
             const QString &FileDownloaderTask::url(){return m_URL;}
             const QDateTime &FileDownloaderTask::startDateTime(){return m_startDateTime;}
             bool FileDownloaderTask::downloadComplete(){return m_downloadComplete;}
             void FileDownloaderTask::downloadProgress(qint64 bytesSent, qint64 bytesTotal)
             {
                 if(bytesTotal!=0)
                     emit updateProgress((100*bytesSent)/bytesTotal);
             }
             void FileDownloaderTask::readReady()
             {
                 this->m_file->write(this->m_Reply->readAll());
             }
             void FileDownloaderTask::downloadFinished()
             {
                 this->m_downloadComplete = true;
                 this->m_file->write(this->m_Reply->readAll());
                 this->m_file->close();
                 this->m_file->rename(this->m_FileName);
             }

src/Core/filedownloadertask.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef FILEDOWNLOADERTASK_H
             #define FILEDOWNLOADERTASK_H
             #include <QObject>
             #include <QByteArray>
             #include <QNetworkAccessManager>
             #include <QNetworkRequest>
             #include <QNetworkReply>
             #include <QFile>
             #include <QDateTime>
             // TODO add download speed and remaining time.
             class FileDownloaderTask : public QObject
             {
                 Q_OBJECT
             public:
                 explicit FileDownloaderTask(QNetworkReply* reply,int ID,const QString& fileName,QObject *parent = 0);
                 ~FileDownloaderTask();
                 int ID();
                 const QString& fileName();
                 const QString& url();
                 const QDateTime& startDateTime();
                 bool downloadComplete();
             signals:
                 void updateProgress(int percent);
                 void updateProgress(qint64 bytesSent, qint64 bytesTotal);
             public slots:
             private slots:
                 void downloadProgress(qint64 bytesSent, qint64 bytesTotal);
                 void readReady();
                 void downloadFinished();
             private:
                 int m_taskId;
                 QNetworkReply* m_Reply;
                 QByteArray m_DownloadedData;
                 bool m_downloadComplete;
                 QFile* m_file;
                 QString m_FileName;
                 QString m_URL;
                 QDateTime m_startDateTime;
             };
             #endif // FILEDOWNLOADERTASK_H

src/Core/qlop.h +22 0

@@ -1,15 +1,37
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the QLop Software
		3	-- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 2 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------*/
		19	/*-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@member.fsf.org
		21	----------------------------------------------------------------------------*/
		22
1	#ifndef QLOP	23	#ifndef QLOP
2	#define QLOP	24	#define QLOP
3	#ifdef WIN32	25	#ifdef WIN32
4	#define QLOP_PLUGINS_INSTALL_PATH qApp->applicationDirPath()+"/plugins"	26	#define QLOP_PLUGINS_INSTALL_PATH qApp->applicationDirPath()+"/plugins"
5	#define QLOP_CONFIG_PATH qApp->applicationDirPath()+"/config"	27	#define QLOP_CONFIG_PATH qApp->applicationDirPath()+"/config"
6	#define PYMODULES qApp->applicationDirPath()+"/python"	28	#define PYMODULES qApp->applicationDirPath()+"/python"
7	#else	29	#else
8	#ifdef UNIX	30	#ifdef UNIX
9	#define QLOP_PLUGINS_INSTALL_PATH QDir::homePath()+"/.QLop/plugins"	31	#define QLOP_PLUGINS_INSTALL_PATH QDir::homePath()+"/.QLop/plugins"
10	#define QLOP_CONFIG_PATH QDir::homePath()+"/.QLop/config"	32	#define QLOP_CONFIG_PATH QDir::homePath()+"/.QLop/config"
11	#define PYMODULES "/etc/QLop/python"	33	#define PYMODULES "/etc/QLop/python"
12	#endif	34	#endif
13	#endif	35	#endif
14	#endif // QLOP	36	#endif // QLOP
15		37

src/Core/qlopdata.cpp +22 0

@@ -1,12 +1,34
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the QLop Software
		3	-- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 2 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------*/
		19	/*-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@member.fsf.org
		21	----------------------------------------------------------------------------*/
		22
1	#include "qlopdata.h"	23	#include "qlopdata.h"
2		24
3	QLopData::QLopData(QObject *parent) : QObject(parent)	25	QLopData::QLopData(QObject *parent) : QObject(parent)
4	{	26	{
5		27
6	}	28	}
7		29
8	QLopData::~QLopData()	30	QLopData::~QLopData()
9	{	31	{
10	delete data;	32	delete data;
11	}	33	}
12		34

src/Core/qlopdata.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef QLOPDATA_H
             #define QLOPDATA_H
             #include <QObject>
             #include <qcustomplot.h>
             typedef struct dataVector
             {
               QString name;
               QString unit;
               QVector<QCPData>* data;
             }dataVector;
             typedef QList<dataVector> QListOfDataVector;
             class QLopData : public QObject
             {
                 Q_OBJECT
             public:
                 explicit QLopData(QObject *parent = 0);
                 ~QLopData();
                 QString name;
                 QString unit;
                 QVector<QCPData>* data;
             signals:
                 void dataChanged();
             public slots:
             private:
             };
             typedef QList<QLopData*> QLopDataList;
             #endif // QLOPDATA_H

src/Core/qlopservice.cpp +22 0

@@ -1,12 +1,34
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the QLop Software
		3	-- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 2 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------*/
		19	/*-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@member.fsf.org
		21	----------------------------------------------------------------------------*/
		22
1	#include "qlopservice.h"	23	#include "qlopservice.h"
2		24
3	QLopService::QLopService(QObject *parent) : QObject(parent)	25	QLopService::QLopService(QObject *parent) : QObject(parent)
4	{	26	{
5		27
6	}	28	}
7		29
8	QLopService::~QLopService()	30	QLopService::~QLopService()
9	{	31	{
10		32
11	}	33	}
12		34

src/Core/qlopservice.h +22 0

+            /*------------------------------------------------------------------------------
+            -- This file is a part of the QLop Software
+            -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
+            --
+            -- This program is free software; you can redistribute it and/or modify
+            -- it under the terms of the GNU General Public License as published by
+            -- the Free Software Foundation; either version 2 of the License, or
+            -- (at your option) any later version.
+            --
+            -- This program is distributed in the hope that it will be useful,
+            -- but WITHOUT ANY WARRANTY; without even the implied warranty of
+            -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+            -- GNU General Public License for more details.
+            --
+            -- You should have received a copy of the GNU General Public License
+            -- along with this program; if not, write to the Free Software
+            -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+            -------------------------------------------------------------------------------*/
+            /*-- Author : Alexis Jeandet
+            -- Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef QLOPSERVICE_H
             #define QLOPSERVICE_H
             #include <QObject>
             #include <QWidget>
             #include <QDockWidget>
             class QLopService : public QObject
             {
                 Q_OBJECT
             public:
                 explicit QLopService(QObject *parent = 0);
                 ~QLopService();
                 virtual QDockWidget* getGUI()=0;
                 virtual const QString& serviceName(){return m_serviceName;}
             signals:
             public slots:
             protected:
                 bool m_noGui;
                 QString m_serviceName;
             };
             #endif // QLOPSERVICE_H

src/SocExplorerPlot.cpp +306 -260

             /*------------------------------------------------------------------------------
             -- This file is a part of the QLop Software
             -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program is distributed in the hope that it will be useful,
             -- but WITHOUT ANY WARRANTY; without even the implied warranty of
             -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
             -- GNU General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "SocExplorerPlot.h"
             #include <QSvgGenerator>
             #include <qcpdocumentobject.h>
             #include <QPdfWriter>
             #include <QPrinter>
             SocExplorerPlot::SocExplorerPlot(QWidget *parent) :
-              QWidget(parent), mRubberBand(new QRubberBand(QRubberBand::Rectangle, this))
+                QWidget(parent), mRubberBand(new QRubberBand(QRubberBand::Rectangle, this))
             {
-              this->m_plot = new QCustomPlotVect(this);
+                this->m_plot = new QCustomPlotVect(this);
-              this->m_plot->setInteractions(QCP::iRangeDrag  | QCP::iSelectAxes |
+                this->m_plot->setInteractions(QCP::iRangeDrag  | QCP::iSelectAxes |
-                                            QCP::iSelectLegend | QCP::iSelectPlottables);
+                                              QCP::iSelectLegend | QCP::iSelectPlottables);
-              this->m_plot->axisRect()->setRangeDrag(Qt::Horizontal|Qt::Vertical);
+                this->m_plot->axisRect()->setRangeDrag(Qt::Horizontal|Qt::Vertical);
-              this->m_plot->axisRect()->setRangeZoom(Qt::Horizontal|Qt::Vertical);
+                this->m_plot->axisRect()->setRangeZoom(Qt::Horizontal|Qt::Vertical);
-              this->m_mainlayout = new QGridLayout(this);
+                this->m_mainlayout = new QGridLayout(this);
-              this->setLayout(this->m_mainlayout);
+                this->setLayout(this->m_mainlayout);
-              this->m_mainlayout->addWidget(this->m_plot);
+                this->m_mainlayout->addWidget(this->m_plot);
-              this->setMinimumSize(400,300);
+                this->setMinimumSize(400,300);
-              this->setFocusPolicy(Qt::WheelFocus);
+                this->setFocusPolicy(Qt::WheelFocus);
-              this->m_plot->setAttribute(Qt::WA_TransparentForMouseEvents);
+                this->m_plot->setAttribute(Qt::WA_TransparentForMouseEvents);
-              this->ctrl_hold = false;
+                this->ctrl_hold = false;
-              this->shift_hold = false;
+                this->shift_hold = false;
-              this->mouse_hold = false;
+                this->mouse_hold = false;
-              this->m_plot->setNoAntialiasingOnDrag(true);
+                this->m_plot->setNoAntialiasingOnDrag(true);
-              this->show();
+                this->show();
-              this->m_plot->legend->setVisible(true);
+                this->m_plot->legend->setVisible(true);
             }
             SocExplorerPlot::~SocExplorerPlot()
             {
-              delete mRubberBand;
+                delete mRubberBand;
             }
             void SocExplorerPlot::show()
             {
-              QWidget::show();
+                QWidget::show();
             }
             void SocExplorerPlot::replot()
             {
                 this->m_plot->replot();
             }
             void SocExplorerPlot::exportToSVG(const QString &fileName)
             {
                 QSvgGenerator printer;
                 printer.setFileName(fileName);
                 QCPPainter qcpPainter;
                 qcpPainter.begin(&printer);
                 m_plot->toPainter(&qcpPainter, m_plot->width(), m_plot->height());
                 qcpPainter.end();
             }
             void SocExplorerPlot::exportToPDF(const QString &fileName)
             {
                 QPrinter printer(QPrinter::HighResolution);
                 printer.setOutputFormat(QPrinter::PdfFormat);
                 printer.setOrientation(QPrinter::Landscape);
                 printer.setOutputFileName(fileName);
                 printer.setFullPage(true);
                 QCPPainter qcpPainter;
                 qcpPainter.begin(&printer);
                 m_plot->toPainter(&qcpPainter, printer.width(), printer.height());
                 qcpPainter.end();
             }
             void SocExplorerPlot::addAction(SocExplorerPlotActions *action)
             {
                 this->m_actions.append(action);
                 QWidget::addAction((QAction*)action);
             }
             QVector<QCPData> *SocExplorerPlot::getVisibleData(int graphIndex)
             {
                 QVector<QCPData> *visibleData=((QCPGraphVect*)m_plot->graph(graphIndex))->getVisibleData();
                 return visibleData;
             }
             void SocExplorerPlot::setTitle(QString title)
             {
-              Q_UNUSED(title)
+                Q_UNUSED(title)
-              //this->m_plot->setTitle(title);
+                //this->m_plot->setTitle(title);
-              /*!
+                /*!
               @todo Function borcken fixe this!
             */
                 this->m_Title = title;
                 emit titleChanged(title);
                 this->repaint();
             }
             const QString &SocExplorerPlot::title()
             {
                 return m_Title;
             }
             void SocExplorerPlot::setXaxisLabel(QString label)
             {
-              this->m_plot->xAxis->setLabel(label);
+                this->m_plot->xAxis->setLabel(label);
                 this->repaint();
             }
             void SocExplorerPlot::setXaxisLog()
             {
                 this->m_plot->xAxis->setScaleType(QCPAxis::stLogarithmic);
             }
             void SocExplorerPlot::setYaxisLabel(QString label)
             {
-              this->m_plot->yAxis->setLabel(label);
+                this->m_plot->yAxis->setLabel(label);
                 this->repaint();
             }
             void SocExplorerPlot::setYaxisLog()
             {
                 this->m_plot->yAxis->setScaleType(QCPAxis::stLogarithmic);
             }
             void SocExplorerPlot::setXaxisRange(double lower, double upper)
             {
-              this->m_plot->xAxis->setRange(lower,upper);
+                this->m_plot->xAxis->setRange(lower,upper);
             }
             void SocExplorerPlot::setYaxisRange(double lower, double upper)
             {
-              this->m_plot->yAxis->setRange(lower,upper);
+                this->m_plot->yAxis->setRange(lower,upper);
             }
             void SocExplorerPlot::rescaleAxis()
             {
-              this->m_plot->rescaleAxes();
+                this->m_plot->rescaleAxes();
-              this->m_plot->replot();
+                this->m_plot->replot();
             }
             void SocExplorerPlot::setLegendFont(QFont font)
             {
-              this->m_plot->legend->setFont(font);
+                this->m_plot->legend->setFont(font);
-              this->repaint();
+                this->repaint();
             }
             void SocExplorerPlot::setLegendSelectedFont(QFont font)
             {
-              this->m_plot->legend->setSelectedFont(font);
+                this->m_plot->legend->setSelectedFont(font);
-              this->repaint();
+                this->repaint();
             }
             void SocExplorerPlot::setAdaptativeSampling(int graphIndex, bool enable)
             {
-              this->m_plot->graph(graphIndex)->setAdaptiveSampling(enable);
+                this->m_plot->graph(graphIndex)->setAdaptiveSampling(enable);
             }
             void SocExplorerPlot::setUseFastVector(int graphIndex, bool enable)
             {
                 // TODO deprecated
-            //  this->m_plot->graph(graphIndex)->setUseFastVectors(enable);
+                //  this->m_plot->graph(graphIndex)->setUseFastVectors(enable);
             }
             int SocExplorerPlot::addGraph()
             {
-              this->m_plot->addGraph();
+                this->m_plot->addGraph();
-              return this->m_plot->graphCount() -1;
+                return this->m_plot->graphCount() -1;
             }
             bool SocExplorerPlot::removeGraph(int graphIndex)
             {
                 return this->m_plot->removeGraph(graphIndex);
             }
             int SocExplorerPlot::graphCount()
             {
                 return m_plot->graphCount();
             }
             void SocExplorerPlot::removeAllGraphs()
             {
-              int graphCount=this->m_plot->graphCount();
+                int graphCount=this->m_plot->graphCount();
-              for(int i=0;i<graphCount;i++)
+                for(int i=0;i<graphCount;i++)
                 {
-                  this->m_plot->removeGraph(0);
+                    this->m_plot->removeGraph(0);
                 }
             }
             void SocExplorerPlot::setGraphName(int graphIndex,QString name)
             {
-              if(graphIndex<this->m_plot->graphCount())
+                if(graphIndex<this->m_plot->graphCount())
                 {
-                  this->m_plot->graph(graphIndex)->setName(name);
+                    this->m_plot->graph(graphIndex)->setName(name);
+                }
             }
             const QString &SocExplorerPlot::graphName(int graphIndex)
             {
                 if(graphIndex<this->m_plot->graphCount())
                 {
                     return this->m_plot->graph(graphIndex)->name();
                 }
                 return "";
             }
             void SocExplorerPlot::setGraphData(int graphIndex, QList<QVariant> x, QList<QVariant> y)
             {
-              if((graphIndex<this->m_plot->graphCount()) && (x.count()==y.count()) && (x.at(0).type()==QVariant::Double))
+                if((graphIndex<this->m_plot->graphCount()) && (x.count()==y.count()) && (x.at(0).type()==QVariant::Double))
                 {
-                  QVector<double> _x(x.count()), _y(y.count());
+                    QVector<double> _x(x.count()), _y(y.count());
-                  for(int i=0;i<x.count();i++)
+                    for(int i=0;i<x.count();i++)
                     {
-                      /*_x[i] = x.at(i).value<double>();
+                        /*_x[i] = x.at(i).value<double>();
                         _y[i] = y.at(i).value<double>();*/
-                      _x[i] = x.at(i).toDouble();
+                        _x[i] = x.at(i).toDouble();
-                      _y[i] = y.at(i).toDouble();
+                        _y[i] = y.at(i).toDouble();
                     }
-                  this->m_plot->graph(graphIndex)->setData(_x,_y);
+                    this->m_plot->graph(graphIndex)->setData(_x,_y);
                 }
-              else
+                else
                 {
-                  if((graphIndex<this->m_plot->graphCount()) && (x.count()==y.count()) && (x.at(0).type()==QVariant::DateTime))
+                    if((graphIndex<this->m_plot->graphCount()) && (x.count()==y.count()) && (x.at(0).type()==QVariant::DateTime))
                     {
-                      QVector<double> _x(x.count()), _y(y.count());
+                        QVector<double> _x(x.count()), _y(y.count());
-                      for(int i=0;i<x.count();i++)
+                        for(int i=0;i<x.count();i++)
                         {
-                          /*_x[i] = x.at(i).value<double>();
+                            /*_x[i] = x.at(i).value<double>();
                             _y[i] = y.at(i).value<double>();*/
-                          _x[i] = x.at(i).toDateTime().toMSecsSinceEpoch();
+                            _x[i] = x.at(i).toDateTime().toMSecsSinceEpoch();
-                          _y[i] = y.at(i).toDouble();
+                            _y[i] = y.at(i).toDouble();
                         }
-                      this->m_plot->graph(graphIndex)->setData(_x,_y);
+                        this->m_plot->graph(graphIndex)->setData(_x,_y);
-                      this->m_plot->xAxis->setTickLabelType(QCPAxis::ltDateTime);
+                        this->m_plot->xAxis->setTickLabelType(QCPAxis::ltDateTime);
-                      this->m_plot->xAxis->setDateTimeFormat("hh:mm:ss.zzz");
+                        this->m_plot->xAxis->setDateTimeFormat("hh:mm:ss.zzz");
                     }
                 }
-              this->m_plot->replot();
+                this->m_plot->replot();
             }
             void SocExplorerPlot::setGraphData(int graphIndex, QCPDataMap *data, bool copy, bool replot)
             {
-              if((graphIndex<this->m_plot->graphCount()))// && (x.at(0).type()==QVariant::Double))
+                if((graphIndex<this->m_plot->graphCount()))// && (x.at(0).type()==QVariant::Double))
                 {
-                  this->m_plot->graph(graphIndex)->setData(data,copy);
+                    this->m_plot->graph(graphIndex)->setData(data,copy);
                 }
-              if(replot)
+                if(replot)
-                this->m_plot->replot();
+                    this->m_plot->replot();
             }
             void SocExplorerPlot::setGraphData(int graphIndex,QVector<QCPData> *data, bool replot)
             {
-              if((graphIndex<this->m_plot->graphCount()))// && (x.at(0).type()==QVariant::Double))
+                if((graphIndex<this->m_plot->graphCount()))// && (x.at(0).type()==QVariant::Double))
                 {
-                  ((QCPGraphVect*)this->m_plot->graph(graphIndex))->setData(data);
+                    ((QCPGraphVect*)this->m_plot->graph(graphIndex))->setData(data);
                 }
-              if(replot)
+                if(replot)
-                this->m_plot->replot();
+                    this->m_plot->replot();
             }
             void SocExplorerPlot::addGraphData(int graphIndex, QList<QVariant> x, QList<QVariant> y)
             {
-              if((graphIndex<this->m_plot->graphCount()) && (x.count()==y.count()))// && (x.at(0).type()==QVariant::Double))
+                if((graphIndex<this->m_plot->graphCount()) && (x.count()==y.count()))// && (x.at(0).type()==QVariant::Double))
                 {
-                  QVector<double> _x(x.count()), _y(y.count());
+                    QVector<double> _x(x.count()), _y(y.count());
-                  for(int i=0;i<x.count();i++)
+                    for(int i=0;i<x.count();i++)
                     {
-                      /*_x[i] = x.at(i).value<double>();
+                        /*_x[i] = x.at(i).value<double>();
                         _y[i] = y.at(i).value<double>();*/
-                      _x[i] = x.at(i).toDouble();
+                        _x[i] = x.at(i).toDouble();
-                      _y[i] = y.at(i).toDouble();
+                        _y[i] = y.at(i).toDouble();
                     }
-                  this->m_plot->graph(graphIndex)->addData(_x,_y);
+                    this->m_plot->graph(graphIndex)->addData(_x,_y);
                 }
-              this->m_plot->replot();
+                this->m_plot->replot();
             }
             void SocExplorerPlot::addGraphData(int graphIndex, QVariant x, QVariant y)
             {
-              if(graphIndex<this->m_plot->graphCount())// && (x.at(0).type()==QVariant::Double))
+                if(graphIndex<this->m_plot->graphCount())// && (x.at(0).type()==QVariant::Double))
                 {
-                  this->m_plot->graph(graphIndex)->addData(x.toDouble(),y.toDouble());
+                    this->m_plot->graph(graphIndex)->addData(x.toDouble(),y.toDouble());
                 }
-              this->m_plot->replot();
+                this->m_plot->replot();
             }
             void SocExplorerPlot::setGraphPen(int graphIndex,QPen pen)
             {
-              if(graphIndex<this->m_plot->graphCount())
+                if(graphIndex<this->m_plot->graphCount())
                 {
-                  this->m_plot->graph(graphIndex)->setPen(pen);
+                    this->m_plot->graph(graphIndex)->setPen(pen);
                 }
             }
             QPen SocExplorerPlot::getGraphPen(int graphIndex)
             {
-              if(graphIndex<this->m_plot->graphCount())
+                if(graphIndex<this->m_plot->graphCount())
                 {
-                  return this->m_plot->graph(graphIndex)->pen();
+                    return this->m_plot->graph(graphIndex)->pen();
                 }
-              return this->m_plot->graph()->pen();
+                return this->m_plot->graph()->pen();
             }
             void SocExplorerPlot::setGraphLineStyle(int graphIndex,QString lineStyle)
             {
-              if(graphIndex<this->m_plot->graphCount())
+                if(graphIndex<this->m_plot->graphCount())
                 {
-                  if(!lineStyle.compare("none"))
+                    if(!lineStyle.compare("none"))
                     {
-                      this->m_plot->graph(graphIndex)->setLineStyle(QCPGraph::lsNone);
+                        this->m_plot->graph(graphIndex)->setLineStyle(QCPGraph::lsNone);
-                      return;
+                        return;
                     }
-                  if(!lineStyle.compare("line"))
+                    if(!lineStyle.compare("line"))
                     {
-                      this->m_plot->graph(graphIndex)->setLineStyle(QCPGraph::lsLine);
+                        this->m_plot->graph(graphIndex)->setLineStyle(QCPGraph::lsLine);
-                      return;
+                        return;
                     }
-                  if(!lineStyle.compare("stepleft"))
+                    if(!lineStyle.compare("stepleft"))
                     {
-                      this->m_plot->graph(graphIndex)->setLineStyle(QCPGraph::lsStepLeft);
+                        this->m_plot->graph(graphIndex)->setLineStyle(QCPGraph::lsStepLeft);
-                      return;
+                        return;
                     }
-                  if(!lineStyle.compare("stepright"))
+                    if(!lineStyle.compare("stepright"))
                     {
-                      this->m_plot->graph(graphIndex)->setLineStyle(QCPGraph::lsStepRight);
+                        this->m_plot->graph(graphIndex)->setLineStyle(QCPGraph::lsStepRight);
-                      return;
+                        return;
                     }
-                  if(!lineStyle.compare("stepcenter"))
+                    if(!lineStyle.compare("stepcenter"))
                     {
-                      this->m_plot->graph(graphIndex)->setLineStyle(QCPGraph::lsStepCenter);
+                        this->m_plot->graph(graphIndex)->setLineStyle(QCPGraph::lsStepCenter);
-                      return;
+                        return;
                     }
-                  if(!lineStyle.compare("impulse"))
+                    if(!lineStyle.compare("impulse"))
                     {
-                      this->m_plot->graph(graphIndex)->setLineStyle(QCPGraph::lsImpulse);
+                        this->m_plot->graph(graphIndex)->setLineStyle(QCPGraph::lsImpulse);
-                      return;
+                        return;
                     }
                 }
             }
             void SocExplorerPlot::setGraphScatterStyle(int graphIndex,QString scatterStyle)
             {
-              if(graphIndex<this->m_plot->graphCount())
+                if(graphIndex<this->m_plot->graphCount())
                 {
-                  if(!scatterStyle.compare("none"))
+                    if(!scatterStyle.compare("none"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssNone);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssNone);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("dot"))
+                    if(!scatterStyle.compare("dot"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssDot);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssDot);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("cross"))
+                    if(!scatterStyle.compare("cross"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssCross);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssCross);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("plus"))
+                    if(!scatterStyle.compare("plus"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssPlus);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssPlus);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("circle"))
+                    if(!scatterStyle.compare("circle"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssCircle);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssCircle);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("disc"))
+                    if(!scatterStyle.compare("disc"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssDisc);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssDisc);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("square"))
+                    if(!scatterStyle.compare("square"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssSquare);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssSquare);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("diamond"))
+                    if(!scatterStyle.compare("diamond"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssDiamond);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssDiamond);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("star"))
+                    if(!scatterStyle.compare("star"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssStar);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssStar);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("triangle"))
+                    if(!scatterStyle.compare("triangle"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssTriangle);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssTriangle);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("invertedtriangle"))
+                    if(!scatterStyle.compare("invertedtriangle"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssTriangleInverted);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssTriangleInverted);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("crosssquare"))
+                    if(!scatterStyle.compare("crosssquare"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssCrossSquare);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssCrossSquare);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("plussquare"))
+                    if(!scatterStyle.compare("plussquare"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssPlusSquare);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssPlusSquare);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("crosscircle"))
+                    if(!scatterStyle.compare("crosscircle"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssCrossCircle);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssCrossCircle);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("pluscircle"))
+                    if(!scatterStyle.compare("pluscircle"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssPlusCircle);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssPlusCircle);
-                      return;
+                        return;
                     }
-                  if(!scatterStyle.compare("peace"))
+                    if(!scatterStyle.compare("peace"))
                     {
-                      this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssPeace);
+                        this->m_plot->graph(graphIndex)->setScatterStyle(QCPScatterStyle::ssPeace);
-                      return;
+                        return;
                     }
                 }
             }
             void SocExplorerPlot::setXaxisTickLabelType(QCPAxis::LabelType type)
             {
-              this->m_plot->xAxis->setTickLabelType(type);
+                this->m_plot->xAxis->setTickLabelType(type);
             }
             void SocExplorerPlot::setXaxisDateTimeFormat(const QString &format)
             {
-              this->m_plot->xAxis->setDateTimeFormat(format);
+                this->m_plot->xAxis->setDateTimeFormat(format);
             }
             void SocExplorerPlot::keyPressEvent(QKeyEvent * event)
             {
-              switch(event->key())
+                switch(event->key())
                 {
                 case Qt::Key_Control:
-                  this->ctrl_hold = true;
+                    this->ctrl_hold = true;
-                  setCursor(Qt::CrossCursor);
+                    setCursor(Qt::CrossCursor);
-                  break;
+                    break;
                 case Qt::Key_Shift:
-                  this->shift_hold = true;
+                    this->shift_hold = true;
-                  break;
+                    break;
                 case Qt::Key_M:
-                  this->rescaleAxis();
+                    this->rescaleAxis();
-                  break;
+                    break;
                 case Qt::Key_Left:
-                  if(!ctrl_hold)
+                    if(!ctrl_hold)
                     {
-                      move(-0.1,Qt::Horizontal);
+                        move(-0.1,Qt::Horizontal);
                     }
-                  else
+                    else
                     {
-                      zoom(2,this->width()/2,Qt::Horizontal);
+                        zoom(2,this->width()/2,Qt::Horizontal);
                     }
-                  break;
+                    break;
                 case Qt::Key_Right:
-                  if(!ctrl_hold)
+                    if(!ctrl_hold)
                     {
-                      move(0.1,Qt::Horizontal);
+                        move(0.1,Qt::Horizontal);
                     }
-                  else
+                    else
                     {
-                      zoom(0.5,this->width()/2,Qt::Horizontal);
+                        zoom(0.5,this->width()/2,Qt::Horizontal);
                     }
-                  break;
+                    break;
                 case Qt::Key_Up:
-                  if(!ctrl_hold)
+                    if(!ctrl_hold)
                     {
-                      move(0.1,Qt::Vertical);
+                        move(0.1,Qt::Vertical);
                     }
-                  else
+                    else
                     {
-                      zoom(0.5,this->height()/2,Qt::Vertical);
+                        zoom(0.5,this->height()/2,Qt::Vertical);
                     }
-                  break;
+                    break;
                 case Qt::Key_Down:
-                  if(!ctrl_hold)
+                    if(!ctrl_hold)
                     {
-                      move(-0.1,Qt::Vertical);
+                        move(-0.1,Qt::Vertical);
                     }
-                  else
+                    else
                     {
-                      zoom(2,this->height()/2,Qt::Vertical);
+                        zoom(2,this->height()/2,Qt::Vertical);
                     }
-                  break;
+                    break;
                 default:
-                  QWidget::keyPressEvent(event);
+                    QWidget::keyPressEvent(event);
-                  break;
+                    break;
                 }
             }
             void SocExplorerPlot::keyReleaseEvent(QKeyEvent * event)
             {
-              switch(event->key())
+                switch(event->key())
                 {
                 case Qt::Key_Control:
-                  event->accept();
+                    event->accept();
-                  this->ctrl_hold = false;
+                    this->ctrl_hold = false;
-                  break;
+                    break;
                 case Qt::Key_Shift:
-                  event->accept();
+                    event->accept();
-                  this->shift_hold = false;
+                    this->shift_hold = false;
-                  break;
+                    break;
                 default:
-                  QWidget::keyReleaseEvent(event);
+                    QWidget::keyReleaseEvent(event);
-                  break;
+                    break;
                 }
-              setCursor(Qt::ArrowCursor);
+                setCursor(Qt::ArrowCursor);
             }
             void SocExplorerPlot::wheelEvent(QWheelEvent * event)
             {
-              double factor;
+                double factor;
-              double wheelSteps = event->delta()/120.0; // a single step delta is +/-120 usually
+                double wheelSteps = event->delta()/120.0; // a single step delta is +/-120 usually
-              if(ctrl_hold)
+                if(ctrl_hold)
                 {
-                  if (event->orientation()==Qt::Vertical)//mRangeZoom.testFlag(Qt::Vertical))
+                    if (event->orientation()==Qt::Vertical)//mRangeZoom.testFlag(Qt::Vertical))
                     {
-                      setCursor(Qt::SizeVerCursor);
+                        setCursor(Qt::SizeVerCursor);
-                      factor = pow(this->m_plot->axisRect()->rangeZoomFactor(Qt::Vertical), wheelSteps);
+                        factor = pow(this->m_plot->axisRect()->rangeZoomFactor(Qt::Vertical), wheelSteps);
-                      zoom(factor,event->pos().y(),Qt::Vertical);
+                        zoom(factor,event->pos().y(),Qt::Vertical);
                     }
-                  QWidget::wheelEvent(event);
+                    QWidget::wheelEvent(event);
-                  return;
+                    return;
                 }
-              if(shift_hold)
+                if(shift_hold)
                 {
-                  if (event->orientation()==Qt::Vertical)//mRangeZoom.testFlag(Qt::Vertical))
+                    if (event->orientation()==Qt::Vertical)//mRangeZoom.testFlag(Qt::Vertical))
                     {
-                      setCursor(Qt::SizeHorCursor);
+                        setCursor(Qt::SizeHorCursor);
-                      factor = pow(this->m_plot->axisRect()->rangeZoomFactor(Qt::Horizontal), wheelSteps);
+                        factor = pow(this->m_plot->axisRect()->rangeZoomFactor(Qt::Horizontal), wheelSteps);
-                      zoom(factor,event->pos().x(),Qt::Horizontal);
+                        zoom(factor,event->pos().x(),Qt::Horizontal);
                     }
-                  QWidget::wheelEvent(event);
+                    QWidget::wheelEvent(event);
-                  return;
+                    return;
                 }
-              move(wheelSteps/10,Qt::Horizontal);
+                move(wheelSteps,Qt::Horizontal);
-              QWidget::wheelEvent(event);
+                QWidget::wheelEvent(event);
             }
             void SocExplorerPlot::mousePressEvent(QMouseEvent *event)
             {
-              if(event->button()==Qt::LeftButton)
+                if(event->button()==Qt::LeftButton)
                 {
-                  if(ctrl_hold)
+                    if(ctrl_hold)
                     {
-                      setCursor(Qt::CrossCursor);
+                        setCursor(Qt::CrossCursor);
-                      mOrigin = event->pos();
+                        mOrigin = event->pos();
-                      mRubberBand->setGeometry(QRect(mOrigin, QSize()));
+                        mRubberBand->setGeometry(QRect(mOrigin, QSize()));
-                      mRubberBand->show();
+                        mRubberBand->show();
                     }
-                  else
+                    else
                     {
-                      setCursor(Qt::ClosedHandCursor);
+                        setCursor(Qt::ClosedHandCursor);
-                      mDragStart = event->pos();
+                        mDragStart = event->pos();
-                      this->mouse_hold = true;
+                        this->mouse_hold = true;
-                      DragStartHorzRange = this->m_plot->axisRect()->rangeDragAxis(Qt::Horizontal)->range();
+                        DragStartHorzRange = this->m_plot->axisRect()->rangeDragAxis(Qt::Horizontal)->range();
-                      DragStartVertRange = this->m_plot->axisRect()->rangeDragAxis(Qt::Vertical)->range();
+                        DragStartVertRange = this->m_plot->axisRect()->rangeDragAxis(Qt::Vertical)->range();
                     }
                 }
-              QWidget::mousePressEvent(event);
+                QWidget::mousePressEvent(event);
             }
             void SocExplorerPlot::mouseReleaseEvent(QMouseEvent *event)
             {
-              if(event->button()==Qt::LeftButton)
+                if(event->button()==Qt::LeftButton)
                 {
-                  this->mouse_hold = false;
+                    this->mouse_hold = false;
                 }
-              if (mRubberBand->isVisible())
+                if (mRubberBand->isVisible())
                 {
-                  const QRect & zoomRect = mRubberBand->geometry();
+                    const QRect & zoomRect = mRubberBand->geometry();
-                  int xp1, yp1, xp2, yp2;
+                    int xp1, yp1, xp2, yp2;
-                  zoomRect.getCoords(&xp1, &yp1, &xp2, &yp2);
+                    zoomRect.getCoords(&xp1, &yp1, &xp2, &yp2);
-                  double x1 = this->m_plot->xAxis->pixelToCoord(xp1);
+                    double x1 = this->m_plot->xAxis->pixelToCoord(xp1);
-                  double x2 = this->m_plot->xAxis->pixelToCoord(xp2);
+                    double x2 = this->m_plot->xAxis->pixelToCoord(xp2);
-                  double y1 = this->m_plot->yAxis->pixelToCoord(yp1);
+                    double y1 = this->m_plot->yAxis->pixelToCoord(yp1);
-                  double y2 = this->m_plot->yAxis->pixelToCoord(yp2);
+                    double y2 = this->m_plot->yAxis->pixelToCoord(yp2);
-                  this->m_plot->xAxis->setRange(x1, x2);
+                    this->m_plot->xAxis->setRange(x1, x2);
-                  this->m_plot->yAxis->setRange(y1, y2);
+                    this->m_plot->yAxis->setRange(y1, y2);
-                  mRubberBand->hide();
+                    mRubberBand->hide();
-                  this->m_plot->replot();
+                    this->m_plot->replot();
                 }
-              setCursor(Qt::ArrowCursor);
+                setCursor(Qt::ArrowCursor);
-              QWidget::mouseReleaseEvent(event);
+                QWidget::mouseReleaseEvent(event);
             }
             void SocExplorerPlot::zoom(double factor, int center, Qt::Orientation orientation)
             {
-              QCPAxis* axis = this->m_plot->axisRect()->rangeZoomAxis(orientation);
+                QCPAxis* axis = this->m_plot->axisRect()->rangeZoomAxis(orientation);
-              axis->scaleRange(factor, axis->pixelToCoord(center));
+                axis->scaleRange(factor, axis->pixelToCoord(center));
-              this->m_plot->replot();
+                this->m_plot->replot();
             }
             void SocExplorerPlot::move(double factor, Qt::Orientation orientation)
             {
-              QCPAxis* axis = this->m_plot->axisRect()->rangeDragAxis(orientation);
+                QCPAxis* axis = this->m_plot->axisRect()->rangeDragAxis(orientation);
-              double rg = (axis->range().upper - axis->range().lower)*(factor);
+                //  double rg = (axis->range().upper - axis->range().lower)*(factor);
-              axis->setRange(axis->range().lower+(rg), axis->range().upper+(rg));
+                //  axis->setRange(axis->range().lower+(rg), axis->range().upper+(rg));
-              this->m_plot->replot();
+                double rg =0.0;
+                DragStartHorzRange = this->m_plot->axisRect()->rangeDragAxis(Qt::Horizontal)->range();
+                DragStartVertRange = this->m_plot->axisRect()->rangeDragAxis(Qt::Vertical)->range();
+                if(this->m_plot->xAxis->scaleType() == QCPAxis::stLinear)
+                {
+                    rg = (axis->range().upper - axis->range().lower)*(factor/10);
+                    axis->setRange(axis->range().lower+(rg), axis->range().upper+(rg));
+                }
+                else if(this->m_plot->xAxis->scaleType() == QCPAxis::stLogarithmic)
+                {
+                    //      rg = (axis->range().upper / axis->range().lower)*(factor/100);
+                    int start,stop;
+                    double diff;
+                    if(factor>0.0)
+                    {
+                        stop =this->width()*factor/10;
+                        start = 2*this->width()*factor/10;
+                    }
+                    if(factor<0.0)
+                    {
+                        factor*=-1.0;
+                        start =this->width()*factor/10;
+                        stop = 2*this->width()*factor/10;
+                    }
+                    diff = axis->pixelToCoord(start) / axis->pixelToCoord(stop);
+                    axis->setRange(this->m_plot->axisRect()->rangeDragAxis(orientation)->range().lower*diff, this->m_plot->axisRect()->rangeDragAxis(orientation)->range().upper*diff);
+                }
+                this->m_plot->replot();
             }
             void SocExplorerPlot::mouseMoveEvent(QMouseEvent *event)
             {
-              if(mouse_hold)
+                if(mouse_hold)
                 {
-                  QCPAxis* Haxis = this->m_plot->axisRect()->rangeDragAxis(Qt::Horizontal);
+                    QCPAxis* Haxis = this->m_plot->axisRect()->rangeDragAxis(Qt::Horizontal);
-                  QCPAxis* Vaxis = this->m_plot->axisRect()->rangeDragAxis(Qt::Vertical);
+                    QCPAxis* Vaxis = this->m_plot->axisRect()->rangeDragAxis(Qt::Vertical);
-                  double diff = Haxis->pixelToCoord(mDragStart.x()) - Haxis->pixelToCoord(event->pos().x());
+                    //      double diff = rangeDragHorzAxis->pixelToCoord(mDragStart.x()) / rangeDragHorzAxis->pixelToCoord(event->pos().x());
-                  Haxis->setRange(DragStartHorzRange.lower+diff, DragStartHorzRange.upper+diff);
+                    //      rangeDragHorzAxis->setRange(mDragStartHorzRange.lower*diff, mDragStartHorzRange.upper*diff);
-                  diff = Vaxis->pixelToCoord(mDragStart.y()) - Vaxis->pixelToCoord(event->pos().y());
+                    double diff=0;
-                  Vaxis->setRange(DragStartVertRange.lower+diff, DragStartVertRange.upper+diff);
+                    if(this->m_plot->xAxis->scaleType() == QCPAxis::stLinear)
-                  this->m_plot->replot();
+                        diff = Haxis->pixelToCoord(mDragStart.x()) - Haxis->pixelToCoord(event->pos().x());
+                        Haxis->setRange(DragStartHorzRange.lower+diff, DragStartHorzRange.upper+diff);
+                    }
+                    else if(this->m_plot->xAxis->scaleType() == QCPAxis::stLogarithmic)
+                    {
+                        diff = Haxis->pixelToCoord(mDragStart.x()) / Haxis->pixelToCoord(event->pos().x());
+                        Haxis->setRange(DragStartHorzRange.lower*diff, DragStartHorzRange.upper*diff);
+                    }
+                    if(this->m_plot->yAxis->scaleType() == QCPAxis::stLinear)
+                    {
+                        diff = Vaxis->pixelToCoord(mDragStart.y()) - Vaxis->pixelToCoord(event->pos().y());
+                        Vaxis->setRange(DragStartVertRange.lower+diff, DragStartVertRange.upper+diff);
+                    }
+                    else if(this->m_plot->yAxis->scaleType() == QCPAxis::stLogarithmic)
+                    {
+                        diff = Vaxis->pixelToCoord(mDragStart.y()) / Vaxis->pixelToCoord(event->pos().y());
+                        Vaxis->setRange(DragStartVertRange.lower*diff, DragStartVertRange.upper*diff);
+                    }
+                    this->m_plot->replot();
                 }
-              if (mRubberBand->isVisible())
+                if (mRubberBand->isVisible())
                 {
-                  mRubberBand->setGeometry(QRect(mOrigin, event->pos()).normalized());
+                    mRubberBand->setGeometry(QRect(mOrigin, event->pos()).normalized());
                 }
-              QWidget::mouseMoveEvent(event);
+                QWidget::mouseMoveEvent(event);
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages