HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/QLop Commit - r12:ae7af17c2621

QLop dataBase started, WIP.

jeandet -

r12:ae7af17c2621 default

parent child

Context file:

r12:ae7af17c2621

src/Core/qlopdatabase.cpp created 644 +83 0

@@ -0,0 +1,83
	1	#include "qlopdatabase.h"
	2
	3	QList<QLopData> QLopDataBase::m_dataBase=NULL;
	4	QLopDataBase* QLopDataBase::_self=NULL;
	5
	6	#define INIT() \
	7	if(Q_UNLIKELY(_self==NULL))\
	8	{\
	9	init();\
	10	}
	11
	12	QLopDataBase::QLopDataBase(QObject *parent) : QObject(parent)
	13	{
	14	this->m_dataBase = new QList<QLopData*>();
	15	}
	16
	17	QLopDataBase::~QLopDataBase()
	18	{
	19
	20	}
	21
	22	void QLopDataBase::init()
	23	{
	24	_self=new QLopDataBase();
	25	}
	26
	27	int QLopDataBase::addData(QLopData *data)
	28	{
	29	INIT();
	30	if(!m_dataBase->contains(data))
	31	{
	32	m_dataBase->append(data);
	33	return 1;
	34	}
	35	return 0;
	36	}
	37
	38	int QLopDataBase::addData(const QLopDataList& data)
	39	{
	40	INIT();
	41	int addedData=0;
	42	for (int i = 0; i < data.count(); i++)
	43	{
	44	addedData += addData(data.at(i));
	45	}
	46	return addedData;
	47	}
	48
	49	QLopDataBase *QLopDataBase::self()
	50	{
	51	INIT();
	52	return _self;
	53	}
	54
	55	int QLopDataBase::count()
	56	{
	57	return m_dataBase->count();
	58	}
	59
	60	QLopData *QLopDataBase::getData(const QString &name)
	61	{
	62	for (int i = 0; i < m_dataBase->count(); i++)
	63	{
	64	if(Q_UNLIKELY(m_dataBase->at(i)->name==name))
	65	{
	66	return m_dataBase->at(i);
	67	}
	68	}
	69	return NULL;
	70	}
	71
	72	QLopData *QLopDataBase::getData(int ID)
	73	{
	74	for (int i = 0; i < m_dataBase->count(); i++)
	75	{
	76	if(Q_UNLIKELY(m_dataBase->at(i)->ID==ID))
	77	{
	78	return m_dataBase->at(i);
	79	}
	80	}
	81	return NULL;
	82	}
	83

src/Core/qlopdatabase.h created 644 +29 0

@@ -0,0 +1,29
	1	#ifndef QLOPDATABASE_H
	2	#define QLOPDATABASE_H
	3
	4	#include <QObject>
	5	#include <qlopdata.h>
	6	#include <QList>
	7
	8	class QLopDataBase : public QObject
	9	{
	10	Q_OBJECT
	11	explicit QLopDataBase(QObject *parent = 0);
	12	~QLopDataBase();
	13	static QLopDataBase* _self;
	14	public:
	15	static void init();
	16	static int addData(QLopData* data);
	17	static int addData(const QLopDataList &data);
	18	static QLopDataBase* self();
	19	static int count();
	20	static QLopData* getData(const QString& name);
	21	static QLopData* getData(int ID);
	22	signals:
	23
	24	public slots:
	25	private:
	26	static QList<QLopData> m_dataBase;
	27	};
	28
	29	#endif // QLOPDATABASE_H

QLop.pro +4 -2

             #-------------------------------------------------
             #
             # 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_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
+                src/Core/Widgets/qcustomplotvect.cpp \
+                src/Core/qlopdatabase.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
+                src/Core/Widgets/qcustomplotvect.h \
+                src/Core/qlopdatabase.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/cassinidatafile.cpp +6 -6

             /*------------------------------------------------------------------------------
             -- 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();
+                    QLopDataVector* ch1V=new QLopDataVector();
-                    QLopData* ch2V=new QLopData();
+                    QLopDataVector* ch2V=new QLopDataVector();
-                    QLopData* ch3V=new QLopData();
+                    QLopDataVector* ch3V=new QLopDataVector();
                     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 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);
+                        QLopDataVector* ch1V=(QLopDataVector*)m_data.at(0);
-                        QLopData* ch2V=m_data.at(1);
+                        QLopDataVector* ch2V=(QLopDataVector*)m_data.at(1);
-                        QLopData* ch3V=m_data.at(2);
+                        QLopDataVector* ch3V=(QLopDataVector*)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/cassinitools.cpp +8 -8

             /*------------------------------------------------------------------------------
             -- 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();
+                            QLopDataVector* vect = new QLopDataVector();
                             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();
+                            QLopDataVector* vect = new QLopDataVector();
                             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();
+                        QLopDataVector* vect = new QLopDataVector();
                         vect->data = plot->getVisibleData(i);
                         vectors.append(vect);
                     }
                     if(vectors.count()==3)
                     {
-                        QLopData* ch1V=vectors.at(0);
+                        QLopDataVector* ch1V=(QLopDataVector*)vectors.at(0);
-                        QLopData* ch2V=vectors.at(1);
+                        QLopDataVector* ch2V=(QLopDataVector*)vectors.at(1);
-                        QLopData* ch3V=vectors.at(2);
+                        QLopDataVector* ch3V=(QLopDataVector*)vectors.at(2);
-                        QLopData* FFTout=new QLopData();
+                        QLopDataVector* FFTout=new QLopDataVector();
                         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->setGraphData(i,((QLopDataVector*)data.at(i))->data,false);
                     }
                     plot->rescaleAxis();
                     plot->replot();
                 }
             }

src/Cassini/cassinitoolsgui.ui +12 -1

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>CassiniToolsGUI</class>
              <widget class="QWidget" name="CassiniToolsGUI">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QGridLayout" name="gridLayout">
                <item row="0" column="0">
                 <widget class="QTabWidget" name="tabWidget">
                  <property name="currentIndex">
                   <number>2</number>
                  </property>
                  <widget class="QWidget" name="tab">
                   <attribute name="title">
                    <string>Data downloader</string>
                   </attribute>
                   <layout class="QGridLayout" name="gridLayout_2">
                    <item row="0" column="0">
                     <widget class="CassiniDataDownloader" name="widget" native="true"/>
                    </item>
                   </layout>
                  </widget>
                  <widget class="QWidget" name="tab_2">
                   <attribute name="title">
                    <string>Index file viewer</string>
                   </attribute>
                   <layout class="QGridLayout" name="gridLayout_3">
                    <item row="0" column="0">
                     <widget class="CassiniIndexFileViewer" name="widget_2" native="true"/>
                    </item>
                   </layout>
                  </widget>
                  <widget class="QWidget" name="tab_3">
                   <attribute name="title">
                    <string>Folder browser</string>
                   </attribute>
                   <layout class="QGridLayout" name="gridLayout_4">
                    <item row="0" column="1">
                     <widget class="QPushButton" name="addFolderViewQpb">
+                     <property name="font">
+                      <font>
+                       <pointsize>7</pointsize>
+                      </font>
+                     </property>
                      <property name="text">
                       <string/>
                      </property>
                      <property name="icon">
                       <iconset resource="../../resources/qlop.qrc">
                        <normaloff>:/img/Gnome-list-add.svg</normaloff>:/img/Gnome-list-add.svg</iconset>
                      </property>
+                     <property name="iconSize">
+                      <size>
+                       <width>16</width>
+                       <height>16</height>
+                      </size>
+                     </property>
                      <property name="flat">
                       <bool>false</bool>
                      </property>
                     </widget>
                    </item>
                    <item row="0" column="0">
                     <spacer name="horizontalSpacer">
                      <property name="orientation">
                       <enum>Qt::Horizontal</enum>
                      </property>
                      <property name="sizeHint" stdset="0">
                       <size>
                        <width>40</width>
-                       <height>20</height>
+                       <height>8</height>
                       </size>
                      </property>
                     </spacer>
                    </item>
                    <item row="1" column="0" colspan="2">
                     <widget class="toolBarContainer" name="folderViews" native="true"/>
                    </item>
                   </layout>
                  </widget>
                 </widget>
                </item>
               </layout>
              </widget>
              <customwidgets>
               <customwidget>
                <class>toolBarContainer</class>
                <extends>QWidget</extends>
                <header location="global">toolbarcontainer.h</header>
                <container>1</container>
               </customwidget>
               <customwidget>
                <class>CassiniDataDownloader</class>
                <extends>QWidget</extends>
                <header location="global">cassinidatadownloader.h</header>
                <container>1</container>
               </customwidget>
               <customwidget>
                <class>CassiniIndexFileViewer</class>
                <extends>QWidget</extends>
                <header location="global">cassiniindexfileviewer.h</header>
                <container>1</container>
               </customwidget>
              </customwidgets>
              <resources>
               <include location="../../resources/qlop.qrc"/>
              </resources>
              <connections/>
             </ui>

src/Core/Widgets/filebrowser.cpp +40 -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 "filebrowser.h"
             #include "ui_filebrowser.h"
             #include <QListView>
             #include <QTreeView>
             FileBrowser::FileBrowser(QWidget *parent) :
                 QDockWidget(parent),
                 ui(new Ui::FileBrowser)
             {
+                this->doubleClickEater = new DoubleClickEater();
                 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->view,SIGNAL(activated(QModelIndex)),this,SLOT(activated(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);
+                this->setFocusPolicy(Qt::StrongFocus);
+                this->ui->pathLineEdit->installEventFilter(this->doubleClickEater);
+                connect(this->doubleClickEater,SIGNAL(doubleClicked()),this,SLOT(pathLineEditDblClicked()));
             }
             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::activated(const QModelIndex &index)
+            {
+                doubleClicked(index);
+            }
             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::pathLineEditDblClicked()
+            {
+                if(this->ui->pathLineEdit->isReadOnly())
+                    pathLineEditEnterEditMode(true);
+            }
             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(!this->view->hasFocus())
+                    {
                         if(QFile::exists(this->ui->pathLineEdit->text()))
                         {
                             this->cd(this->ui->pathLineEdit->text());
                             e->accept();
                         }
+                        pathLineEditEnterEditMode(false);
+                    }
+                    break;
+                case Qt::Key_Backspace:
+                    if(this->view->hasFocus())
+                    {
+                        parentDir();
+                    }
                     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();
             }
+            bool DoubleClickEater::eventFilter(QObject *obj, QEvent *event)
+            {
+                if (event->type() == QEvent::MouseButtonDblClick)
+                {
+                    emit doubleClicked();
+                    return true;
+                } else
+                {
+                    // standard event processing
+                    return QObject::eventFilter(obj, event);
+                }
+            }

src/Core/Widgets/filebrowser.h +18 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 DoubleClickEater : public QObject
+            {
+                Q_OBJECT
+            public:
+                DoubleClickEater(){}
+                ~DoubleClickEater(){}
+            signals:
+                void doubleClicked();
+            protected:
+                bool eventFilter(QObject *obj, QEvent *event);
+            };
             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 activated(const QModelIndex & index);
                 void parentDir();
                 void cd(const QString& newPath);
+                void pathLineEditDblClicked();
             protected:
                 void changeEvent(QEvent *e);
                 void keyPressEvent(QKeyEvent *e);
             private:
                 void pathLineEditEnterEditMode(bool enter=true);
                 Ui::FileBrowser *ui;
                 FileSystemModel* model;
                 QAbstractItemView* view;
                 QCompleter* pathCompleter;
+                DoubleClickEater* doubleClickEater;
             };
             #endif // FILEBROWSER_H

src/Core/qlopdata.cpp +15 -2

             /*------------------------------------------------------------------------------
             -- 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 "qlopdata.h"
             QLopData::QLopData(QObject *parent) : QObject(parent)
             {
+                this->unit = "";
+                this->source = "Not set";
+                this->type = QLopData::None;
             }
             QLopData::~QLopData()
             {
+            //    delete data;
+            }
+            QLopDataVector::QLopDataVector(QObject *parent)
+            {
+                this->type = QLopData::Vector;
+            }
+            QLopDataVector::~QLopDataVector()
+            {
                 delete data;
             }

src/Core/qlopdata.h +23 -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
             ----------------------------------------------------------------------------*/
             #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:
+                typedef enum QLopDataType
+                {
+                    Scalar=0,
+                    Vector=1,
+                    Matrix=2,
+                    None=-1,
+                }
+                QLopDataType;
                 explicit QLopData(QObject *parent = 0);
                 ~QLopData();
                 QString name;
+                QString source;
                 QString unit;
+                QLopDataType type;
+                int ID;
+            signals:
+                void dataChanged();
+            public slots:
+            private:
+            };
+            class QLopDataVector : public QLopData
+            {
+                Q_OBJECT
+            public:
+                explicit QLopDataVector(QObject *parent = 0);
+                ~QLopDataVector();
                 QVector<QCPData>* data;
             signals:
-                void dataChanged();
             public slots:
             private:
             };
             typedef QList<QLopData*> QLopDataList;
             #endif // QLOPDATA_H

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