HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r13:4680bac36b29

Updated lab name!

Jeandet Alexis -

r13:4680bac36b29 default

parent child

Context file:

r13:4680bac36b29

Expand all files

.hgignore +1 0

             # use glob syntax.
             syntax: glob
             moc_*
             Makefil*
             qrc_*
             *.qm
             *.tex
             *.html
             *log*
             *.dot
             *.css
             *.md5
             *.eps
             *.pdf
             *.toc
             *.map
             *.sty
             *.3
             *.js
             *.aux
             *.idx
             *.orig
             *.o
             *.dll
             *.a
             *.bin
             *~
             *.pro.user
             src/PythonQt/tests/PythonQtTest
             src/PythonQt/generator/pythonqt_generator
             src/plugins/common/.preprocessed.tmp
             *.exe
             src/common/.preprocessed.tmp
+            */.cccc/*
             syntax: regexp
             bin/*

.hgsubstate +1 -1

	@@ -1,1 +1,1
	1	e3a98a04d9ec8685bf222f8d687a614a71927549 src/SocExplorerEngine/PeripheralWidget		1	2c82d72694590cbc2aebb946667f11f60ea89afe src/SocExplorerEngine/PeripheralWidget

build_cfg/socexplorer.pri +1 -1

             QT += core gui xml svg network
             contains(QT_MAJOR_VERSION, 5) {
               QT += widgets
               QT += printsupport
             }
             CONFIG(debug, debug|release) {
               DEBUG_EXT = _d
             } else {
               DEBUG_EXT =
             }
             SOCEXPLORER_SDK_BUILD="SOCEXPLORER_SDK_BUILD"
             DEFINES += SOCEXPLORER_SDK_BUILD
             MOC_DIR      = moc
             RCC_DIR      = resources
             OBJECTS_DIR = obj
             win32:DESTDIR = $${SOCEXPLORER_ROOT}/bin/win32/
             unix:DESTDIR = $${SOCEXPLORER_ROOT}/bin/linux/
             metrics_cccc.target = metrics_cccc
-            metrics_cccc.commands = cccc $$SOURCES $$HEADERS
+            metrics_cccc.commands = cccc $(SOURCES) $(HEADERS)
             QMAKE_EXTRA_TARGETS += metrics_cccc

src/PyWdgt/pythonconsole.h +2 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PYTHONCONSOLE_H
             #define PYTHONCONSOLE_H
             #include <QWidget>
             #include <QDockWidget>
             #include <QHBoxLayout>
             #include <QtGui/QDragEnterEvent>
             #include <QtGui/QDragLeaveEvent>
             #include <QtGui/QDragMoveEvent>
             #include <QtGui/QDropEvent>
             #include <QtCore/QMimeData>
             #include <QtCore/QUrl>
             #include <QtCore/QList>
             #include "PythonQt.h"
             #include "PythonQt_QtAll.h"
             #include <gui/PythonQtScriptingConsole.h>
             #include "../plugins/socexplorerplugin.h"
             #include "pythonqtscriptingconsoledandd.h"
             #include <QMainWindow>
             #include "../proxy/socexplorerproxy.h"
-            class LPMONMainWindow;
+            class SocExplorerMainWindow;
             class PythonConsole : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit PythonConsole(socexplorerproxy* proxy,QWidget *parent = 0);
             signals:
                 void rootDriverDelete();
             public slots:
                 void setBussDriver(socexplorerplugin* driver);
                 void removeBussDriver();
                 void removeDriver(const QString& instanceName);
                 void pyConsoleRunFiles(const QStringList&);
                 void pyConsoleRunFile(const QString& fileName);
                 void registerObject(QObject* object,const QString& instanceName);
                 void changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName);
                 void addObject(const QString& name, QObject* object);
             protected:
                 QSize sizeHint();
             private:
                 QHBoxLayout* mainlayout;
                 socexplorerplugin* bussdriver;
                 PythonQtScriptingConsoleDandD* console;
                 PythonQtObjectPtr*  mainContext;
                 socexplorerproxy* proxy;
                 //LPMONMainWindow* mainwin;
             };
             #endif // PYTHONCONSOLE_H

src/PyWdgt/pythonqtscriptingconsoledandd.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PYTHONQTSCRIPTINGCONSOLEDANDD_H
             #define PYTHONQTSCRIPTINGCONSOLEDANDD_H
             #include "PythonQt.h"
             #include "PythonQt_QtAll.h"
             #include "gui/PythonQtScriptingConsole.h"
             #include "../plugins/socexplorerplugin.h"
             #include <QtGui/QDragEnterEvent>
             #include <QtGui/QDragLeaveEvent>
             #include <QtGui/QDragMoveEvent>
             #include <QtGui/QDropEvent>
             #include <QtCore/QMimeData>
             #include <QtCore/QUrl>
             #include <QtCore/QList>
             #include "NicePyConsole/NicePyConsole.h"
             class PythonQtScriptingConsoleDandD : public NicePyConsole
             {
                 Q_OBJECT
             public:
                 PythonQtScriptingConsoleDandD(QWidget* parent, const PythonQtObjectPtr& context, Qt::WindowFlags i = 0);
                 //void pyConsoleRunFiles(const QStringList&);
             signals:
                 void pyConsoleRunFiles(const QStringList&);
             protected:
                 void dropEvent(QDropEvent * event);
                 void dragMoveEvent(QDragMoveEvent *e);
                 void dragEnterEvent(QDragEnterEvent *e);
             private:
             };
             #endif // PYTHONQTSCRIPTINGCONSOLEDANDD_H

src/SocExplorerEngine/SOC/registerdata.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2013, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "registerdata.h"
             ucSystemOnChip::ucSystemOnChip(QObject *parent)
                 :QObject(parent),QList<ucPeripheral*>()
             {
             }
             ucPeripheral::ucPeripheral(QObject *parent)
                 :QObject(parent),QList<ucRegister*>()
             {
             }
             ucRegister::ucRegister(QObject *parent)
                 :QObject(parent)
             {
             }
             quint32 ucRegister::value()
             {
                 return this->p_value;
             }
             void ucRegister::setName(const QString &name)
             {
                 this->p_name = name;
                 emit nameChanged(this->p_name);
             }
             void ucRegister::setValue(quint32 value)
             {
                 this->p_value = value;
                 emit valueChanged(this->p_value);
             }
             void ucRegister::setOffset(qint64 offset)
             {
                 this->p_addressOffset = offset;
                 emit offsetChanged(this->p_addressOffset);
             }
             void ucSystemOnChip::setName(const QString &name)
             {
                 this->p_name = name;
                 emit nameChanged(this->p_name);
             }

src/SocExplorerEngine/SOC/registerdata.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2013, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef REGISTERDATA_H
             #define REGISTERDATA_H
             #include <QString>
             #include <QList>
             #include <QObject>
             //class ucBitfield: public QObject
             //{
             //    Q_OBJECT
             //public:
             //    explicit ucBitfield(QObject* parent =0);
             //    explicit ucBitfield(const QString& name,int offset,const QString& description,QObject* parent =0);
             //    QString name();
             //    int offset();
             //    QString description();
             //public slots:
             //    void setName(const QString& name);
             //    void setOffset(int offset);
             //    void setDescription(const QString& description);
             //signals:
             //    void nameChanged(const QString& name);
             //    void offsetChanged(int offset);
             //    void descriptionChanged(const QString& description);
             //private:
             //    QString p_name;
             //    int p_offset;
             //    QString p_description;
             //};
             class ucRegister :public QObject
             {
                 Q_OBJECT
             public:
                 ucRegister(QObject* parent=0);
                 quint32 value();
             public slots:
                 void setName(const QString& name);
                 void setValue(quint32 value);
                 void setOffset(qint64 offset);
             signals:
                 void nameChanged(const QString& name);
                 void offsetChanged(qint64 offset);
                 void valueChanged(quint32 value);
             private:
                 QString p_name;
                 qint64  p_addressOffset;
                 quint32 p_value;
             };
             class ucPeripheral: public QObject,public QList<ucRegister*>
             {
                 Q_OBJECT
             public:
                 ucPeripheral(QObject* parent=0);
             private:
                 QString p_name;
                 qint64  p_baseAddress;
             };
             class ucSystemOnChip : public QObject,public QList<ucPeripheral*>
             {
                 Q_OBJECT
             public:
                 ucSystemOnChip(QObject* parent=0);
             public slots:
                 void setName(const QString& name);
             signals:
                 void nameChanged(const QString& name);
             private:
                 QString p_name;
             };
             #endif // REGISTERDATA_H

src/SocExplorerEngine/SOC/socclk.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2014, 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 "socclk.h"
             SOCclk::SOCclk(const QString &name, qint64 value, qint64 divisor, qint64 multiplier)
             {
                 this->p_Name = name;
                 this->p_Value = value;
                 this->p_parentClk = NULL;
                 this->p_Multiplier= multiplier;
                 this->p_Divisor = divisor;
             }
             void SOCclk::appendChild(SOCclk *child)
             {
                 this->p_childrenClk.append(child);
                 child->setParentClk(this);
             }
             void SOCclk::setParentClk(SOCclk *parent)
             {
                 p_parentClk = parent;
             }
             SOCclk *SOCclk::getClk(const QString &name)
             {
                 SOCclk* clk=NULL;
                 if(this->p_Name==name)return this;
                 for(int i=0;i<=p_childrenClk.count();i++)
                 {
                     clk =p_childrenClk.at(i)->getClk(name);
                     if(clk!=NULL)break;
                 }
                 return clk;
             }
             qint64 SOCclk::Value()
             {
                 if(p_parentClk==NULL)
                     return p_Value;
                 return p_parentClk->Value()*p_Multiplier/p_Divisor;
             }
             void SOCclk::setValue(qint64 value)
             {
                 this->p_Value = value;
             }
             qint64 SOCclk::Divisor()
             {
                 return p_Divisor;
             }
             void SOCclk::setDivisor(qint64 divisor)
             {
                 p_Divisor = divisor;
             }
             qint64 SOCclk::Multiplier()
             {
                 return p_Multiplier;
             }
             void SOCclk::setMultiplier(qint64 multiplier)
             {
                 p_Multiplier = multiplier;
             }
             QString SOCclk::Name()
             {
                 return p_Name;
             }
             void SOCclk::setName(const QString &name)
             {
                 this->p_Name = name;
             }

src/SocExplorerEngine/SOC/socclk.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2014, 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 SOCCLK_H
             #define SOCCLK_H
             #include <QString>
             #include <QList>
             #include <socexplorer.h>
             class SOCEXPLORER_EXPORT SOCclk
             {
             public:
                 SOCclk(const QString& name, qint64 value, qint64 divisor, qint64 multiplier);
                 void appendChild(SOCclk* child);
                 void setParentClk(SOCclk* parent);
                 SOCclk* getClk(const QString& name);
                 qint64 Value();
                 void setValue(qint64 value);
                 qint64 Divisor();
                 void setDivisor(qint64 divisor);
                 qint64 Multiplier();
                 void setMultiplier(qint64 multiplier);
                 QString Name();
                 void setName(const QString& name);
             private:
                 qint64 p_Value;
                 QString p_Name;
                 qint64 p_Divisor;
                 qint64 p_Multiplier;
                 QList<SOCclk*> p_childrenClk;
                 SOCclk* p_parentClk;
             };
             #endif // SOCCLK_H

src/SocExplorerEngine/SOC/socexplorerenumdevice.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2012, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "socexplorerenumdevice.h"
             socExplorerEnumDevice::socExplorerEnumDevice(SOCModel* soc, int VID, int PID, qint32 baseAddress, const QString &name, QObject *parent)
                 :QObject(parent)
             {
                 _VID=VID;
                 _PID=PID;
                 _baseAddress=baseAddress;
                 _devName=new QString(name);
                 _visible=true;
                 _SOC = soc;
             }
             void socExplorerEnumDevice::writeReg(qint32 address, qint32 value)
             {
                 _SOC->writeReg(address,value);
             }
             qint32 socExplorerEnumDevice::readReg(qint32 address)
             {
                 return _SOC->readReg(address);
             }

src/SocExplorerEngine/SOC/socexplorerenumdevice.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2012, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef SOCEXPLORERENUMDEVICE_H
             #define SOCEXPLORERENUMDEVICE_H
             #include <QObject>
             #include <stdint.h>
             #include <socexplorerplugin.h>
             #include <socmodel.h>
             class SOCEXPLORER_EXPORT socExplorerEnumDevice : public QObject
             {
                 Q_OBJECT
             public:
                 explicit socExplorerEnumDevice(SOCModel* soc,int VID,int PID,qint32 baseAddress,const QString& name,QObject *parent = 0);
                 qint32 baseAddress(){return _baseAddress;}
                 int VID(){return _VID;}
                 int PID(){return _PID;}
                 QString name(){return *_devName;}
                 bool visible(){return _visible;}
                 void setVisible(bool visible){_visible=visible;}
             signals:
             public slots:
                 void writeReg(qint32 address,qint32 value);
                 qint32 readReg(qint32 address);
             private:
                 bool _visible;
                 qint32 _baseAddress;
                 int _VID;
                 int _PID;
                 QString* _devName;
                 SOCModel* _SOC;
             };
             #endif // SOCEXPLORERENUMDEVICE_H

src/SocExplorerEngine/SOC/socmodel.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2013, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "socmodel.h"
             #include <socexplorerenumdevice.h>
             SOCModel::SOCModel(socexplorerplugin *rootDev, QObject *parent):
                 QObject(parent)
             {
                     p_rootDev = rootDev;
             }
             qint32 SOCModel::getEnumDeviceBaseAddress(int VID, int PID, int count)
             {
                 for(int i=0;i<p_enumeratedDevices.count();i++)
                 {
                     if((p_enumeratedDevices.at(i)->VID()==VID) && (p_enumeratedDevices.at(i)->PID()==PID))
                     {
                         if(count==0)
                         {
                             return p_enumeratedDevices.at(i)->baseAddress();
                         }
                         count--;
                     }
                 }
                 return -1;
             }
             socExplorerEnumDevice *SOCModel::addEnumDevice( int VID, int PID, qint32 baseAddress, const QString &name)
             {
                 if(enumDeviceExists(baseAddress))
                     return getEnumDevice(baseAddress);
                 socExplorerEnumDevice* device= new socExplorerEnumDevice(this,VID,PID,baseAddress,name);
                 p_enumeratedDevices.append(device);
                 return device;
             }
             int SOCModel::addEnumDevice(socExplorerEnumDevice *device)
             {
                 if(enumDeviceExists(device->baseAddress()))
                     return 0;
                 p_enumeratedDevices.append(device);
                 return 1;
             }
             bool SOCModel::enumDeviceExists(qint32 baseAddress)
             {
                 for(int i=0;i<p_enumeratedDevices.count();i++)
                 {
                     if(p_enumeratedDevices.at(i)->baseAddress()==baseAddress)
                         return true;
                 }
                 return false;
             }
             socExplorerEnumDevice *SOCModel::getEnumDevice(qint32 baseAddress)
             {
                 for(int i=0;i<p_enumeratedDevices.count();i++)
                 {
                     if(p_enumeratedDevices.at(i)->baseAddress()==baseAddress)
                         return p_enumeratedDevices.at(i);
                 }
                 return NULL;
             }
             void SOCModel::writeReg(qint32 address, qint32 value)
             {
                 uint valueInt=value,addressInt=address;
                 p_rootDev->Write(&valueInt,1,addressInt);
             }
             qint32 SOCModel::readReg(qint32 address)
             {
                 uint valueInt=0,addressInt=address;
                 p_rootDev->Read(&valueInt,1,addressInt);
                 return (qint32)valueInt;
             }

src/SocExplorerEngine/SOC/socmodel.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2013, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef REGISTERSMODEL_H
             #define REGISTERSMODEL_H
             #include <QString>
             #include <QList>
             #include <QObject>
             #include <QDomDocument>
             #include <QDomElement>
             #include "registerdata.h"
             #include <socclk.h>
             #include <socexplorerplugin.h>
             //#include <socexplorerenumdevice.h>
             class socExplorerEnumDevice;
             class registerBitFieldModel
             {
             public:
                 registerBitFieldModel(const QString& name,const QString& description,
                                       int size, int offset, bool rw)
                 {
                     this->name = name;
                     this->description = description;
                     this->size = size;
                     this->offset = offset;
                     this->rw = rw;
                 }
                 QString name;
                 QString description;
                 int size;
                 int offset;
                 bool rw;
             };
             class registerModel
             {
             public:
                 registerModel(const QString& name,qint32 offset)
                 {
                     this->name = name;
                     this->offset = offset;
                 }
                 QString name;
                 qint32 offset;
                 QList<registerBitFieldModel> bitfields;
             };
             class peripheralModel
             {
             public:
                 peripheralModel(const QString& name)
                 {
                     this->name = name;
                 }
                 QString name;
                 QList<registerModel> registers;
             };
             class SOCEXPLORER_EXPORT SOCModel :public QObject
             {
                 Q_OBJECT
             public:
                 SOCModel(socexplorerplugin* rootDev,QObject* parent=0);
                // qint32 getRegValue(qint32 baseAddress);
                 bool isRootDev(socexplorerplugin* rootDev)
                 {
                     return rootDev==p_rootDev;
                 }
                 bool enumDeviceExists(qint32 baseAddress);
                 socExplorerEnumDevice *getEnumDevice(qint32 baseAddress);
             public slots:
                 //void setRegValue(qint32 baseAddress,qint32 value);
                 qint32 getEnumDeviceBaseAddress(int VID,int PID,int count=0);
                 socExplorerEnumDevice* addEnumDevice(int VID, int PID, qint32 baseAddress, const QString& name);
                 int addEnumDevice(socExplorerEnumDevice* device);
                 void writeReg(qint32 address,qint32 value);
                 qint32 readReg(qint32 address);
             private:
                 socexplorerplugin* p_rootDev;
                 QList<socExplorerEnumDevice*> p_enumeratedDevices;
                 QList<SOCclk*> clktree;
             };
             #endif // REGISTERSMODEL_H

src/SocExplorerEngine/XmlEngine/XMLdata.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2013, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "XMLdata.h"
             xmlDataBitfield::xmlDataBitfield(QObject *parent)
                 :QObject(parent)
             {
             }
             xmlDataBitfield::xmlDataBitfield(const QString& name,int offset,const QString& description,QObject* parent)
             {
                 Q_UNUSED(name)
                 Q_UNUSED(offset)
                 Q_UNUSED(offset)
                 Q_UNUSED(description)
                 Q_UNUSED(parent)
             }
             QString xmlDataBitfield::name()
             {
                 return this->p_name;
             }
             int xmlDataBitfield::offset()
             {
                 return this->p_offset;
             }
             QString xmlDataBitfield::description()
             {
                 return this->p_description;
             }
             void xmlDataBitfield::setName(const QString &name)
             {
                 this->p_name = name;
                 emit nameChanged(this->p_name);
             }
             void xmlDataBitfield::setOffset(int offset)
             {
                 this->p_offset = offset;
                 emit offsetChanged(this->p_offset);
             }
             void xmlDataBitfield::setDescription(const QString &description)
             {
                 this->p_description = description;
                 emit descriptionChanged(this->p_description);
             }
             xmlDataRegister::xmlDataRegister(QObject *parent)
                 :QObject(parent),QList<xmlDataBitfield*>()
             {
             }
             void xmlDataRegister::setName(const QString &name)
             {
                 this->p_name = name;
                 emit nameChanged(this->p_name);
             }
             void xmlDataRegister::setValue(quint32 value)
             {
                 this->p_value = value;
                 emit valueChanged(this->p_value);
             }
             void xmlDataRegister::setOffset(qint64 offset)
             {
                 this->p_addressOffset = offset;
                 emit offsetChanged(this->p_addressOffset);
             }
             xmlDataPeripheral::xmlDataPeripheral(QObject *parent)
                 :QObject(parent), QList<xmlDataRegister*>()
             {
             }
             xmlDataSystemOnChip::xmlDataSystemOnChip(QObject *parent)
                 :QObject(parent),QList<xmlDataRegister*>()
             {
             }
             void xmlDataSystemOnChip::setName(const QString &name)
             {
                 this->p_name = name;
                 emit nameChanged(this->p_name);
             }

src/SocExplorerEngine/XmlEngine/XMLdata.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2013, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef XMLDATA_H
             #define XMLDATA_H
             #include <QString>
             #include <QList>
             #include <QObject>
             class xmlDataBitfield: public QObject
             {
                 Q_OBJECT
             public:
                 explicit xmlDataBitfield(QObject* parent =0);
                 explicit xmlDataBitfield(const QString& name,int offset,const QString& description,QObject* parent =0);
                 QString name();
                 int offset();
                 QString description();
             public slots:
                 void setName(const QString& name);
                 void setOffset(int offset);
                 void setDescription(const QString& description);
             signals:
                 void nameChanged(const QString& name);
                 void offsetChanged(int offset);
                 void descriptionChanged(const QString& description);
             private:
                 QString p_name;
                 int p_offset;
                 QString p_description;
             };
             class xmlDataRegister : public QObject, public QList<xmlDataBitfield*>
             {
                 Q_OBJECT
             public:
                 xmlDataRegister(QObject* parent=0);
                 quint32 value();
             public slots:
                 void setName(const QString& name);
                 void setValue(quint32 value);
                 void setOffset(qint64 offset);
             signals:
                 void nameChanged(const QString& name);
                 void offsetChanged(qint64 offset);
                 void valueChanged(quint32 value);
             private:
                 QString p_name;
                 qint64  p_addressOffset;
                 quint32 p_value;
             };
             class xmlDataPeripheral:public QObject, public QList<xmlDataRegister*>
             {
                 Q_OBJECT
             public:
                 xmlDataPeripheral(QObject* parent=0);
             private:
                 QString p_name;
                 qint64  p_baseAddress;
             };
             class xmlDataSystemOnChip : public QObject, public QList<xmlDataRegister*>
             {
                 Q_OBJECT
             public:
                 xmlDataSystemOnChip(QObject* parent=0);
             public slots:
                 void setName(const QString& name);
             signals:
                 void nameChanged(const QString& name);
             private:
                 QString p_name;
             };
             #endif // XMLDATA_H

src/SocExplorerEngine/XmlEngine/XMLmodel.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2013, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "XMLmodel.h"
             #include <socexplorerengine.h>
             #include <QFile>
             #include <QDebug>
             socExplorerXmlModel::socExplorerXmlModel(QObject *parent)
                 :QObject(parent)
             {
                 p_driver = new XMLDriver;
                 p_driver->scanXmlFiles();
                 this->updateSOClist();
             }
             int socExplorerXmlModel::checkXmlFile(const QString &fileName)
             {
                 return p_driver->checkXmlFile(fileName);
             }
             int socExplorerXmlModel::createXmlFile(const QString &fileName)
             {
                 return p_driver->createXmlFile(fileName);
             }
             QList<xmlfile *> socExplorerXmlModel::getFileList(const QString &tagNameFilter)
             {
                 return p_driver->getFileList(tagNameFilter);
             }
             QList<QDomNodeList> socExplorerXmlModel::getAllNodes(const QString &tagName)
             {
                 return p_driver->getAllNodes(tagName);
             }
             QStringList socExplorerXmlModel::getPeripheralRegList(const QString &peripheralName)
             {
                 QStringList result;
                 QList<QDomNodeList> nodeList = p_driver->getAllNodes("peripheral");
                 for(int i=0;i<nodeList.count();i++)
                 {
                     for(int l=0;l<nodeList.at(i).count();l++)
                     {
                         if(peripheralName==nodeList.at(i).at(l).toElement().attribute("name","name"))
                         {
                             QDomNodeList registers=nodeList.at(i).at(l).toElement().elementsByTagName("register");
                             for(int m=0;m<registers.count();m++)
                             {
                                 result.append(registers.at(m).toElement().attribute("name","No name"));
                             }
                         }
                     }
                 }
                 return result;
             }
             peripheralModel socExplorerXmlModel::getPeripheral(const QString &peripheralName)
             {
                 peripheralModel result= peripheralModel(peripheralName);
                 QList<QDomNodeList> nodeList = p_driver->getAllNodes("peripheral");
                 QDomNodeList filteredPeriph;
                 for(int i=0;i<nodeList.count();i++)
                 {
                     for(int l=0;l<nodeList.at(i).count();l++)
                     {
                         if(peripheralName==nodeList.at(i).at(l).toElement().attribute("name","name"))
                         {
                             filteredPeriph = nodeList.at(i).at(l).toElement().elementsByTagName("register");
                             p_getRegs(&result,&filteredPeriph);
                         }
                     }
                 }
                 return result;
             }
             void socExplorerXmlModel::updateSOClist()
             {
                 QString socName;
                 this->clearSocList();
                 QList<QDomNodeList> nodeList = p_driver->getAllNodes("soc");
                 for(int i=0;i<nodeList.count();i++)
                 {
                     for(int l=0;l<nodeList.at(i).count();l++)
                     {
                         socName = nodeList.at(i).at(l).toElement().attribute("name","name");
                         qDebug()<<"Found SOC " + socName;
                     }
                 }
             }
             void socExplorerXmlModel::registerXmlFile(const QString &fileName)
             {
                 p_driver->registerXmlFile(fileName);
             }
             void socExplorerXmlModel::scanXmlFiles()
             {
                 p_driver->scanXmlFiles();
             }
             void socExplorerXmlModel::p_getRegs(peripheralModel *periph, QDomNodeList *nodes)
             {
                 QString name;
                 QString description;
                 int size=0;
                 int offset=0;
                 bool rw;
                 for(int i=0;i<nodes->count();i++)
                 {
                     periph->registers.append(registerModel(nodes->at(i).toElement().attribute("name","No name"),nodes->at(i).toElement().attribute("addOffset",QString::number(i*4)).toInt()));
                     QDomNodeList bitfields=nodes->at(i).toElement().elementsByTagName("bitField");
                     for(int l=0;l<bitfields.count();l++)
                     {
                         name = bitfields.at(l).toElement().attribute("name","No name");
                         description = bitfields.at(l).toElement().attribute("desc","");
                         offset = bitfields.at(l).toElement().attribute("offset",QString("%1").arg(offset+size)).toInt();
                         size = bitfields.at(l).toElement().attribute("size","1").toInt();
                         rw = bitfields.at(l).toElement().attribute("mode","1").toInt()==3;
                         periph->registers.last().bitfields.append(registerBitFieldModel(name,description,size,offset,rw));
                     }
                     size = 0;
                     offset = 0;
                 }
             }
             void socExplorerXmlModel::clearSocList()
             {
                 xmlDataSystemOnChip* tmp;
                 for(int i=0;i<this->p_SocList.length();i++)
                 {
                     tmp = this->p_SocList.last();
                     this->p_SocList.removeLast();
                     delete tmp;
                 }
             }

src/SocExplorerEngine/XmlEngine/XMLmodel.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2013, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef XMLMODEL_H
             #define XMLMODEL_H
             #include <QString>
             #include <QList>
             #include <QObject>
             #include "XMLdata.h"
             #include "socexplorerxmlfile.h"
             #include "xmldriver.h"
             #include <socmodel.h>
             #if defined(SOCEXPLORER_SDK_BUILD)
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
             #else
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
             #endif
             class SOCEXPLORER_SDK_EXPORT socExplorerXmlModel: public QObject
             {
                 Q_OBJECT
             public:
                 socExplorerXmlModel(QObject* parent=0);
                 //! Check that the given file is a readable Xml file.
                 int checkXmlFile(const QString& fileName);
                 int createXmlFile(const QString& fileName);
                 //! Return the list of all xml nodes with the given tag name in cached Xml files.
                 QList<xmlfile*> getFileList(const QString& tagNameFilter);
                 QList<QDomNodeList> getAllNodes(const QString& tagName);
                 QStringList getPeripheralRegList(const QString& peripheralName);
                 peripheralModel getPeripheral(const QString& peripheralName);
             public slots:
                 void updateSOClist();
                 void registerXmlFile(const QString &fileName);
                 //! Reload all xmlFiles.
                 void scanXmlFiles();
             signals:
             private:
                 void p_getRegs(peripheralModel *periph, QDomNodeList *nodes);
                 QList<xmlDataSystemOnChip*> p_SocList;
                 void clearSocList();
                 XMLDriver* p_driver;
             };
             #endif // XMLMODEL_H

src/SocExplorerEngine/engine/socexplorerengine.cpp +8 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2012, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "socexplorerengine.h"
             #include <proxy/socexplorerproxy.h>
             SocExplorerEngine* SocExplorerEngine::_self = NULL;
             socExplorerXmlModel* SocExplorerEngine::p_xmlmodel=NULL;
             QMainWindow* SocExplorerEngine::mainWindow=NULL;
             QList<SOCModel*>* SocExplorerEngine::SOCs=NULL;
             int SocExplorerEngine::loglvl=1;
             SocExplorerEngine::SocExplorerEngine(QObject *parent) :
                 QObject(parent)
             {
                 if(SOCs==NULL)
                 {
                     SOCs = new QList<SOCModel*>;
                 }
             }
             void SocExplorerEngine::init()
             {
                 QDir dir;
                 if(!_self)
                 {
                     _self= new SocExplorerEngine;
                 }
                 if(!dir.exists(configFolder()))
                     dir.mkdir(configFolder());
                 p_xmlmodel = new socExplorerXmlModel(_self);
                 p_xmlmodel->updateSOClist();
             }
             QString SocExplorerEngine::configFolder()
             {
                 return QString(SOCEXPLORER_CONFIG_PATH);
             }
             SOCModel *SocExplorerEngine::plugin2Soc(socexplorerplugin *plugin)
             {
                 if(!_self)
                     init();
                 if(plugin)
                 {
                     while (plugin->parent!=NULL) {
                         plugin = plugin->parent;
                     }
                     for(int i=0;i<SOCs->count();i++)
                     {
                         if(SOCs->at(i)->isRootDev(plugin))
                             return SOCs->at(i);
                     }
                     //no soc found so create a new one
                     SOCModel* soc=new SOCModel(plugin);
                     SOCs->append(soc);
                     return soc;
                 }
                 return NULL;
             }
             int SocExplorerEngine::addEnumDevice(socexplorerplugin* rootPlugin,int VID, int PID, qint32 baseAddress, const QString &name)
             {
                 if(!_self)
                     init();
                 SOCModel* soc = plugin2Soc(rootPlugin);
                 if(soc && !soc->enumDeviceExists(baseAddress))
                 {
                     emit _self->enumDeviceAdded(soc->addEnumDevice(VID,PID,baseAddress,name));
                     return 1;
                 }
                 return 0;
             }
             QList<SOCModel *> *SocExplorerEngine::getSOCs()
             {
                 if(!_self)
                     init();
                 return SOCs;
             }
             qint32 SocExplorerEngine::getEnumDeviceBaseAddress(const QString& rootPlugin,int VID, int PID, int count)
             {
                 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
                 if(plugin==NULL)return -1;
                 SOCModel* soc = plugin2Soc(plugin);
                 if(soc==NULL)
                     return -1;
                 return soc->getEnumDeviceBaseAddress(VID,PID,count);
             }
             qint32 SocExplorerEngine::getEnumDeviceBaseAddress(socexplorerplugin *plugin, int VID, int PID, int count)
             {
                 if(plugin==NULL)return -1;
                 SOCModel* soc = plugin2Soc(plugin);
                 if(soc==NULL)
                     return -1;
                 return soc->getEnumDeviceBaseAddress(VID,PID,count);
             }
             int SocExplorerEngine::addEnumDevice(const QString &rootPlugin, int VID, int PID, qint32 baseAddress, const QString &name)
             {
                 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
                 if(plugin==NULL)return -1;
                 SOCModel* soc = plugin2Soc(plugin);
                 if(soc==NULL)
                     return -1;
                 soc->addEnumDevice(VID,PID,baseAddress,name);
                 return  1;
             }
             QString SocExplorerEngine::getDevName(int VID, int PID)
             {
                 QList<QDomNodeList> list=p_xmlmodel->getAllNodes("peripheral");
                 for(int i=0;i<list.count();i++)
                 {
                     QDomNodeList nodes=list.at(i);
                     for(int l=0;l<nodes.count();l++)
                     {
                         QDomElement node=nodes.at(l).toElement();
                         int nodeVID=node.attribute("vid","0").toInt();
                         int nodePID=node.attribute("pid","0").toInt();
                         if((nodeVID==VID)&&(nodePID==PID))
                         {
                             return node.attribute("name","Unknow device");
                         }
                     }
                 }
                 return QString("Unknow device");
             }
             QString SocExplorerEngine::SocExplorerVersion(){return QString(SOCEXPLORER_VERSION);}
             QString SocExplorerEngine::SocExplorerChangeset(){return QString(SOCEXPLORER_CHAGESET).split(" ").at(0);}
             QString SocExplorerEngine::SocExplorerBranch(){return QString(SOCEXPLORER_BRANCH);}
             socExplorerXmlModel *SocExplorerEngine::xmlModel()
             {
                 if(!_self)
                     init();
                 return p_xmlmodel;
             }
             void SocExplorerEngine::setMainWindow(QMainWindow *Mainwindow)
             {
                 if(!_self)
                     init();
                 mainWindow=Mainwindow;
             }
             QProgressBar *SocExplorerEngine::getProgressBar(const QString& format, int max)
             {
                 if(!_self)
                     init();
                 QProgressBar* progressBar;
                 if(mainWindow!=NULL)
                 {
                     progressBar = new QProgressBar(mainWindow);
                     mainWindow->statusBar()->addWidget(progressBar);
                 }
                 else
                 {
                     progressBar = new QProgressBar();
                 }
                 progressBar->setMaximum(max);
                 progressBar->setFormat(format);
                 return progressBar;
             }
             void SocExplorerEngine::deleteProgressBar(QProgressBar *progressBar)
             {
                 if(mainWindow!=NULL)
                 {
                     mainWindow->statusBar()->removeWidget(progressBar);
                 }
                 delete progressBar;
             }
             void SocExplorerEngine::addSOC(socexplorerplugin *rootPlugin)
             {
                 plugin2Soc(rootPlugin);
             }
             void SocExplorerEngine::removeSOC(socexplorerplugin *rootPlugin)
             {
                 SOCModel* soc=plugin2Soc(rootPlugin);
                 SOCs->removeAll(soc);
                 delete soc;
             }
             void SocExplorerEngine::message(socexplorerplugin *sender, const QString &message, int debugLevel)
             {
                 // TODO add multi output message manager IE also log in files
                 if(!_self)
                     init();
                 if(loglvl>=debugLevel)
                     qDebug()<< QTime::currentTime().toString()+" " + sender->instanceName()+":"+message;
             }
+            void SocExplorerEngine::setLogLevel(int level)
+            {
+                if(!_self)
+                    init();
+                loglvl = level;
+            }

src/SocExplorerEngine/engine/socexplorerengine.h +2 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2012, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef SOCEXPLORERENGINE_H
             #define SOCEXPLORERENGINE_H
             #include <stdint.h>
             #include <QObject>
             #include <QtWidgets>
             #include <QStringList>
             #include <QDomDocument>
             #include <QDomElement>
             #include <QDomNodeList>
             #include <QFile>
             #include <QTextStream>
             #include <QDir>
             #include <QApplication>
             #include <QtCore/qglobal.h>
             #include <QFileDialog>
             #include <socexplorerxmlfile.h>
             #include <socexplorerenumdevice.h>
             #include <XMLmodel.h>
             #include <peripheralwidget.h>
             #include <registerwidget.h>
             #include <socmodel.h>
             #if defined(SOCEXPLORER_SDK_BUILD)
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
             #else
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
             #endif
             //! SocExplorerEngine is a pure static class which aims to provide services for both SocExplorer software and plugins.
             class SOCEXPLORER_SDK_EXPORT SocExplorerEngine : public QObject
             {
                 Q_OBJECT
             private:
                 static SocExplorerEngine* _self;
                 SocExplorerEngine(QObject *parent = 0);
                 static void init();
             public:
                 static SocExplorerEngine* self(){ if(!_self){_self= new SocExplorerEngine;}return _self;}
                 //! Return the configuration folder path, OS dependant.
                 SOCEXPLORER_SDK_EXPORT static QString configFolder();
                 //! Return the default plugin folder path, OS dependant.
                  static QString pluginFolder(){return QString(SOCEXPLORER_PLUGINS_INSTALL_PATH);}
                  static int addEnumDevice(socexplorerplugin* rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
                  static QList<SOCModel*>* getSOCs();
                  static QString getDevName(int VID, int PID);
                  static QString SocExplorerVersion();
                  static QString SocExplorerChangeset();
                  static QString SocExplorerBranch();
                  static socExplorerXmlModel* xmlModel();
                  static void setMainWindow(QMainWindow* Mainwindow);
                  static QProgressBar* getProgressBar(const QString &format, int max);
                  static void deleteProgressBar(QProgressBar* progressBar);
                  static void addSOC(socexplorerplugin* rootPlugin);
                  static void removeSOC(socexplorerplugin* rootPlugin);
                  static void message(socexplorerplugin* sender,const QString& message,int debugLevel=0);
+                 static void setLogLevel(int level);
             signals:
                  void enumDeviceAdded(socExplorerEnumDevice* device);
             public slots:
                  QString getSocExplorerVersion(){return SocExplorerEngine::SocExplorerVersion();}
                  QString getSocExplorerChangeset(){return SocExplorerEngine::SocExplorerChangeset();}
                  QString getSocExplorerBranch(){return SocExplorerEngine::SocExplorerBranch();}
                  qint32 getEnumDeviceBaseAddress(const QString& rootPlugin,int VID,int PID,int count=0);
                  qint32 getEnumDeviceBaseAddress(socexplorerplugin* plugin,int VID,int PID,int count=0);
                  int addEnumDevice(const QString& rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
             private:
                 static SOCModel* plugin2Soc(socexplorerplugin* plugin);
                 static socExplorerXmlModel* p_xmlmodel;
                 static QMainWindow* mainWindow;
                 static QList<SOCModel*>* SOCs;
                 static int loglvl;
             };
             #endif // SOCEXPLORERENGINE_H

src/SocExplorerEngine/engine/socexplorerxmlfile.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2012, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "socexplorerxmlfile.h"
             #include <QFile>
             #include <QTextStream>
             xmlfile::xmlfile(const QString& fileName)
             {
                 this->m_fileName = fileName;
                 this->m_document=new QDomDocument();
                 QFile file( fileName );
                 if( !file.open( QIODevice::ReadOnly ) )
                     return;
                 this->m_document->setContent(&file);
                 file.close();
                 this->m_rootElement = this->m_document->documentElement();
             }
             void xmlfile::save()
             {
                 QFile file( this->m_fileName );
                 if( !file.open( QIODevice::WriteOnly ) )
                     return;
                 QTextStream ts( &file );
                 ts << this->m_document->toString();
                 file.close();
                 this->reload();
             }
             void xmlfile::reload()
             {
                 QFile file( this->m_fileName );
                 if( !file.open( QIODevice::ReadOnly ) )
                     return;
                 this->m_document->setContent(&file);
                 file.close();
                 this->m_rootElement = this->m_document->documentElement();
             }
             void xmlfile::addElement(QDomElement* parentElement, const QString& tagName)
             {
                 if(m_document)
                 {
                     QDomElement element=this->m_document->createElement(tagName);
                     parentElement->appendChild(element);
                     //emit this->elementAdded(element);
                 }
             }
             void xmlfile::removeElement(QDomElement *parentElement, QDomElement *element)
             {
                 Q_UNUSED(parentElement)
                 Q_UNUSED(element)
                 if(m_document)
                 {
                 }
             }

src/SocExplorerEngine/engine/socexplorerxmlfile.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2012, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef XMLFILE_H
             #define XMLFILE_H
             #include <QObject>
             #include <QDomDocument>
             #include <QDomElement>
             #include <QString>
             /////////////////////////////////////////////////////////////////////////////////
             /////////////////////////////////////////////////////////////////////////////////
             //! Stores a cached Xml file and expose synchronization functions (Slots).
             class xmlfile : public QObject
             {
                 Q_OBJECT
             public:
                 xmlfile(const QString& fileName);
                 //! Return the root xml element of the current file.
                 QDomElement* getRootElement(){return &m_rootElement;}
                 //! Return the current file name.
                 QString fileName(){return this->m_fileName;}
                 //! Return the root xml element tag name of the current file.
                 QString rootTagName()
                 {
                     if(!this->m_rootElement.isNull())
                         return this->m_rootElement.tagName();
                     else
                         return QString("");
                 }
             public slots:
                 void save();
                 void reload();
                 void addElement(QDomElement* parentElement, const QString& tagName);
                 void removeElement(QDomElement* parentElement, QDomElement* element);
             private:
                 QString m_fileName;
                 QDomDocument* m_document;
                 QDomElement m_rootElement;
             };
             /////////////////////////////////////////////////////////////////////////////////
             /////////////////////////////////////////////////////////////////////////////////
             #endif // XMLFILE_H

src/SocExplorerEngine/pluginManagerWdgt/plugininfoswdgt.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "plugininfoswdgt.h"
             #include "pluginloader.h"
             #include <QDir>
             #include <QTextDocument>
             #include <QTextCursor>
             #include <QTextFragment>
             #include <QTextDocumentFragment>
             #include <QTextBlock>
             #include <QTextCharFormat>
             #include <QTextTable>
             #include <QApplication>
             pluginInfosWdgt::pluginInfosWdgt(QWidget *parent) :
                 QWidget(parent)
             {
                 this->mailLayout = new QVBoxLayout;
                 this->textInfos = new QTextBrowser;
                 this->textInfos->setReadOnly(true);
                 this->mailLayout->addWidget(this->textInfos);
                 this->setLayout(this->mailLayout);
                 this->textInfos->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
             }
             void pluginInfosWdgt::updateInfos(const QStringList &items)
             {
                 this->textInfos->clear();
                 QTextCursor cursor(this->textInfos->document());
                 //QTextTable* table;
                 int i=0;
                 cursor.atStart();
                 cursor.insertText("Plugins:\n");
                 for(i=0;i<items.count();i++)
                 {
                     cursor.insertText(pluginloader::getlibDir(items.at(i))+"\n");
                 }
                 cursor.insertText("\n\n");
                 //table = cursor.insertTable(7,items.count()+1);
                 cursor.insertTable(7,items.count()+1);
                 cursor.insertText(tr("Plugin name"));
                 for(i=0;i<items.count();i++)
                 {
                     cursor.movePosition(cursor.NextCell);
                     cursor.insertText(pluginloader::getlibName(items.at(i)));
                 }
                 cursor.movePosition(cursor.NextRow);
                 cursor.insertText(tr("Root"));
                 for(i=0;i<items.count();i++)
                 {
                     cursor.movePosition(cursor.NextCell);
                     if(pluginloader::libcanberoot(items.at(i)))
                     {
                         cursor.insertText("Yes");
                     }
                     else
                     {
                         cursor.insertText("No");
                     }
                 }
                 cursor.movePosition(cursor.NextRow);
                 cursor.insertText(tr("Child"));
                 for(i=0;i<items.count();i++)
                 {
                     cursor.movePosition(cursor.NextCell);
                     if(pluginloader::libcanbechild(items.at(i)))
                     {
                         cursor.insertText("Yes");
                     }
                     else
                     {
                         cursor.insertText("No");
                     }
                 }
                 cursor.movePosition(cursor.NextRow);
                 cursor.insertText(tr("VID"));
                 for(i=0;i<items.count();i++)
                 {
                     cursor.movePosition(cursor.NextCell);
                     cursor.insertText(pluginloader::getlibVIDstr(items.at(i)));
                 }
                 cursor.movePosition(cursor.NextRow);
                 cursor.insertText(tr("PID"));
                 for(i=0;i<items.count();i++)
                 {
                     cursor.movePosition(cursor.NextCell);
                     cursor.insertText(pluginloader::getlibPIDstr(items.at(i)));
                 }
                 cursor.movePosition(cursor.NextRow);
                 cursor.insertText(tr("Version"));
                 for(i=0;i<items.count();i++)
                 {
                     cursor.movePosition(cursor.NextCell);
                     cursor.insertText(pluginloader::getlibVersion(items.at(i)));
                 }
                 cursor.movePosition(cursor.NextRow);
                 cursor.insertText(tr("author"));
                 for(i=0;i<items.count();i++)
                 {
                     cursor.movePosition(cursor.NextCell);
                     cursor.insertText(pluginloader::getlibAuthor(items.at(i)));
                 }
                 cursor.movePosition(cursor.NextBlock);
                 for(i=0;i<items.count();i++)
                 {
                     cursor.insertText("\n\n");
                     cursor.insertText(pluginloader::getlibName(items.at(i))+" Description:\n");
                     cursor.insertText(pluginloader::getlibDescription(items.at(i)));
                 }
             }
             void pluginInfosWdgt::updateInfos(const QString pluginPath)
             {
                 this->textInfos->clear();
                 QTextCursor cursor(this->textInfos->document());
                 QTextCharFormat formatHeader(cursor.charFormat());
                 QTextCharFormat formatContent(cursor.charFormat());
                 //QTextTable* table;
                 formatHeader.setFontWeight(QFont::Bold);
                 formatHeader.setForeground(QBrush(Qt::red));
                 formatContent.setForeground(Qt::black);
                 cursor.atStart();
                 if(pluginloader::checklibrary(pluginPath)==1)
                 {
                     cursor.setBlockCharFormat(formatHeader);
                     cursor.insertText(tr("plugin name:"));
                     //cursor.insertBlock();
                     cursor.setBlockCharFormat(formatContent);
                     //table = cursor.insertTable(1,1);
                     cursor.insertTable(1,1);
                     cursor.insertText(pluginloader::getlibName(pluginPath));
                     //table->cellAt( (pluginloader::getlibName(pluginPath));
                     //this->textInfos->append(pluginloader::getlibName(pluginPath));
                     //this->textInfos->append("================================");
                     if(pluginloader::libcanberoot(pluginPath))
                     {
                         this->textInfos->append(tr("This plugin can be used as root driver."));
                     }
                     else
                     {
                         this->textInfos->append(tr("This plugin can't' be used as root driver, so it need to be connected to an other plugin."));
                     }
                     this->textInfos->append("================================");
                     if(pluginloader::libcanbechild(pluginPath))
                     {
                         this->textInfos->append(tr("This plugin can be used as child driver."));
                     }
                     else
                     {
                         this->textInfos->append(tr("This plugin can't' be used as child driver."));
                     }
                     this->textInfos->append("================================");
                     this->textInfos->append(tr("plugin VID:"));
                     this->textInfos->append(pluginloader::getlibVIDstr(pluginPath));
                     this->textInfos->append("================================");
                     this->textInfos->append(tr("plugin PID:"));
                     this->textInfos->append(pluginloader::getlibPIDstr(pluginPath));
                     this->textInfos->append("================================");
                     this->textInfos->append(tr("plugin Version:"));
                     this->textInfos->append(pluginloader::getlibVersion(pluginPath));
                     this->textInfos->append("================================");
                     this->textInfos->append(tr("plugin Author:"));
                     this->textInfos->append(pluginloader::getlibAuthor(pluginPath));
                     this->textInfos->append("================================");
                     this->textInfos->append(tr("plugin Description:"));
                     this->textInfos->append(pluginloader::getlibDescription(pluginPath));
                 }
                 else
                 {
                     this->textInfos->setText(tr("This is not a valid plugin."));
                 }
             }

src/SocExplorerEngine/pluginManagerWdgt/plugininfoswdgt.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PLUGININFOSWDGT_H
             #define PLUGININFOSWDGT_H
             #include <QWidget>
             #include <QVBoxLayout>
             #include <QTextEdit>
             #include <QString>
             #include <QTextBrowser>
             class pluginInfosWdgt : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit pluginInfosWdgt(QWidget *parent = 0);
             public slots:
                 void updateInfos(const QString pluginPath);
                 void updateInfos(const QStringList& items);
             private:
                 QVBoxLayout* mailLayout;
                 QTextBrowser* textInfos;
             };
             #endif // PLUGININFOSWDGT_H

src/SocExplorerEngine/pluginManagerWdgt/pluginlist.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "pluginlist.h"
             #include "pluginloader.h"
             #include <QDir>
             #include <QFile>
             #include <QFileInfoList>
             #include <QString>
             #include <QStringList>
             #include <QApplication>
             #include <QLabel>
             #include <QPixmap>
             #include "qsvgicon.h"
             #include <QWidget>
             #include <QDrag>
             PluginList::PluginList(QWidget *parent):QListWidget(parent)
             {
                 this->setAcceptDrops(true);
                 this->setDragEnabled(true);
                 this->setSelectionMode(QAbstractItemView::ExtendedSelection);
                 connect(this,SIGNAL(itemSelectionChanged()),this,SLOT(updateSelection()));
                 this->showCacheAction = new QAction(tr("View cache content"),this);
                 this->addAction(this->showCacheAction);
                 connect(this->showCacheAction,SIGNAL(triggered()),this,SLOT(showCache()));
                 this->setContextMenuPolicy(Qt::ActionsContextMenu);
             }
             void PluginList::refreshPluginList()
             {
                 this->clear();
                 QList<PluginsCacheItem*> plugins = pluginloader::listAvailiables(true);
                 for (int i = 0; i < plugins.count(); ++i)
                 {
                     PluginListItem *newItem = new PluginListItem(QString(plugins.at(i)->getpluginName()),plugins.at(i)->getpath()+"/"+plugins.at(i)->getfileName());
                     newItem->setFlags(newItem->flags() &~ Qt::ItemIsEditable);
                     this->addItem((QListWidgetItem*)newItem);
                 }
             }
             void PluginList::dragEnterEvent(QDragEnterEvent *event)
             {
                 this->clearSelection();
                 this->itemAt(dragStartPosition)->setSelected(true);
                 event->acceptProposedAction();
             }
             void PluginList::dragMoveEvent(QDragMoveEvent *e)
             {
                 e->accept();
             }
             void PluginList::mousePressEvent(QMouseEvent *event)
             {
                 if (event->button() == Qt::LeftButton)
                 {
                     dragStartPosition = event->pos();
                 }
                 QListWidget::mousePressEvent(event);
             }
             void PluginList::mouseMoveEvent(QMouseEvent *event)
             {
                 if (!(event->buttons() & Qt::LeftButton))
                     return;
                 if ((event->pos() - dragStartPosition).manhattanLength()< QApplication::startDragDistance())
                     return;
                 if(this->selectedItems().count()==0)
                     return;
                 QDrag *drag = new QDrag(this);
                 QMimeData *mimeData = new QMimeData;
                 drag->setHotSpot(event->pos() - rect().topLeft());
                 mimeData->setData("socexplorer/pluginName",QByteArray(((PluginListItem*)this->selectedItems().first())->fullPath->toLatin1()));
                 mimeData->setText(((PluginListItem*)this->selectedItems().first())->fullPath->toLatin1());
                 drag->setMimeData(mimeData);
                 drag->exec(Qt::MoveAction);
             }
             void PluginList::dropEvent(QDropEvent *event)
             {
                 Q_UNUSED(event)
             }
             void PluginList::updateSelection()
             {
                 QStringList _items;
                 for(int i=0;i<this->selectedItems().count();i++)
                 {
                     _items << *((PluginListItem*)(this->selectedItems().at(i)))->fullPath;
                 }
                 emit this->itemSelectionChanged(_items);
             }

src/SocExplorerEngine/pluginManagerWdgt/pluginlist.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PLUGINLIST_H
             #define PLUGINLIST_H
             #include <QTableWidget>
             #include <QListWidget>
             #include <QtGui/QDragEnterEvent>
             #include <QtGui/QDragLeaveEvent>
             #include <QtGui/QDragMoveEvent>
             #include <QtGui/QDropEvent>
             #include <QtCore/QMimeData>
             #include <QtCore/QUrl>
             #include <QtCore/QList>
             #include <QPoint>
             #include <QStringList>
             #include <QMenu>
             #include <QAction>
             #include <pluginloader.h>
             class PluginListItem: public QListWidgetItem
             {
             public:
                 explicit PluginListItem( const QString & Name,const QString & FullPath, QListWidget * parent = 0, int type = Type )
                     :QListWidgetItem(Name,parent,type)
                 {
                     this->fullPath = new QString(FullPath);
                 }
                 QString* fullPath;
             };
             class PluginList: public QListWidget
             {
                 Q_OBJECT
             public:
                 explicit PluginList(QWidget * parent = 0);
             protected:
                 void dragEnterEvent(QDragEnterEvent *event);
                 void dragMoveEvent(QDragMoveEvent *e);
                 void dropEvent(QDropEvent *event);
                 void mousePressEvent(QMouseEvent *event);
                 void mouseMoveEvent(QMouseEvent *e);
             public slots:
                 void refreshPluginList();
             private slots:
                 void updateSelection();
                 void showCache(){pluginloader::showCache();}
             signals:
                 void itemSelectionChanged(const QStringList& items);
             private:
                 QAction* showCacheAction;
                 QPoint dragStartPosition;
             };
             #endif // PLUGINLIST_H

src/SocExplorerEngine/pluginManagerWdgt/pluginmanagerWDGT.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "pluginmanagerWDGT.h"
             #include "pluginloader.h"
             #include <QFileDialog>
             #include <unistd.h>
             #include <qsvgicon.h>
             #include <socexplorerengine.h>
             #define mkbutton(button,text,image)button = new QPushButton();\
             button->setIcon(QSvgIcon(image));\
             button->setIconSize(QSize(16,16));\
             button->setToolTip(text)
             pluginmanagerWDGT::pluginmanagerWDGT(QWidget *parent) :
                 QSplitter(parent)
             {
                 this->setWindowTitle("Plugin Manager");
                 this->setOrientation(Qt::Vertical);
                 this->pluginListWidgetContainer = new QWidget();
                 this->mainlayoutSpliter = new QSplitter;
                 this->pluginListLayout = new QVBoxLayout();
                 this->mainlayoutSpliter->setOrientation(Qt::Vertical);
                 this->treeview = new plugintree();
                 this->pluginTable = new PluginList;
                 this->ButtonsLayout = new QHBoxLayout();
                 this->ButtonsLayout->addStretch();
                 this->pluginListLayout->addLayout(this->ButtonsLayout);
                 this->addWidget(this->treeview);
                 this->pluginListWidgetContainer->setLayout(this->pluginListLayout);
                 this->addWidget(this->pluginListWidgetContainer);
                 this->pluginListLayout->addWidget(this->pluginTable);
                 this->pluginInfos = new pluginInfosWdgt;
                 mkbutton(this->addPluginBt,tr("add plugin"),":/images/open.svg");
                 mkbutton(this->removePluginBt,tr("remove plugin(s)"),":/images/trash.svg");
                 mkbutton(this->refreshPluginListBt,tr("Refresh Plugin(s) list"),":/images/refresh.svg");
                 this->ButtonsLayout->addWidget(this->addPluginBt);
                 this->ButtonsLayout->addWidget(this->refreshPluginListBt);
                 this->ButtonsLayout->addWidget(this->removePluginBt);
                 this->addWidget(this->pluginInfos);
                 connect(this->treeview,SIGNAL(geteplugintree()),this,SIGNAL(geteplugintree()));
                 connect(this,SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->treeview,SLOT(treeChanged(QList<socexplorerplugin*>)));
                 connect(this->pluginTable,SIGNAL(currentRowChanged(int)),this,SLOT(libselected(int)));
                 connect(this->pluginTable,SIGNAL(itemSelectionChanged(QStringList)),this->pluginInfos,SLOT(updateInfos(QStringList)));
                 connect(this->addPluginBt,SIGNAL(clicked()),this,SLOT(addPlugin()));
                 connect(this->removePluginBt,SIGNAL(clicked()),this,SLOT(removePlugin()));
                 connect(this->pluginTable,SIGNAL(itemDoubleClicked(QListWidgetItem*)),this,SLOT(loadplugin(QListWidgetItem*)));
                 connect(this->refreshPluginListBt,SIGNAL(clicked()),this->pluginTable,SLOT(refreshPluginList()));
                 connect(this->treeview,SIGNAL(loadSysDriver(QString)),this,SIGNAL(loadSysDrviver(QString)));
                 connect(this->treeview,SIGNAL(loadSysDriverToParent(QString,QString)),this,SIGNAL(loadSysDriverToParent(QString,QString)));
                 connect(this->treeview,SIGNAL(changeSysDriverInstName(QString,QString)),this,SIGNAL(changeSysDriverInstName(QString,QString)));
                 connect(this->treeview,SIGNAL(closeSysDriver(QString)),this,SIGNAL(closeSysDriver(QString)));
                 connect(this->treeview,SIGNAL(pluginselected(QString)),this,SIGNAL(pluginselected(QString)));
                 this->rootLoadable = false;
                 this->childLoadable = false;
                 this->pluginTable->refreshPluginList();
                 this->pluginTable->refreshPluginList();
             }
             void pluginmanagerWDGT::setRootLoadable(bool flag)
             {
                 this->rootLoadable = flag;
             }
             void pluginmanagerWDGT::setChildLoadable(bool flag)
             {
                 this->childLoadable = flag;
             }
             void pluginmanagerWDGT::addPlugin()
             {
                 QString fileName = QFileDialog::getOpenFileName(this,tr("Open Plugin"), QDir::homePath(), tr("Plugin Files Files (*.dll *.so *.so.*)"));
                 if(pluginloader::checklibrary(fileName))
                 {
                     QFile::copy(fileName,QString(SocExplorerEngine::pluginFolder())+"/"+ fileName.section('/',-1));
                 }
                 this->pluginTable->refreshPluginList();
             }
             void pluginmanagerWDGT::removePlugin()
             {
                 for(int i=0;i<this->pluginTable->selectedItems().count();i++)
                 {
                     QListWidgetItem* item = this->pluginTable->selectedItems().at(i);
                     if(item!=NULL)
                     {
                         QFile::remove(QString(SocExplorerEngine::pluginFolder())+"/"+item->text());
                     }
                 }
                 this->pluginTable->refreshPluginList();
             }
             void pluginmanagerWDGT::loadplugin()
             {
                 for(int i=0;i<this->pluginTable->selectedItems().count();i++)
                 {
                     QListWidgetItem* item = this->pluginTable->selectedItems().at(i);
                     if(item!=NULL)
                     {
                         QString plugin = QString(SocExplorerEngine::pluginFolder())+"/"+item->text();
                         emit this->loadSysDrviver(plugin);
                     }
                 }
                 this->pluginTable->refreshPluginList();
             }

src/SocExplorerEngine/pluginManagerWdgt/pluginmanagerWDGT.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PLUGINMANAGERWDGT_H
             #define PLUGINMANAGERWDGT_H
             #include <QApplication>
             #include <QWidget>
             #include <QDockWidget>
             #include <QVBoxLayout>
             #include <QHBoxLayout>
             #include <QTableWidget>
             #include <QDir>
             #include <QStringList>
             #include <QFileInfoList>
             #include <QFileInfo>
             #include <QTextEdit>
             #include <QPushButton>
             #include <QSplitter>
             #include "plugininfoswdgt.h"
             #include "pluginlist.h"
             #include <socexplorerplugin.h>
             #include <QList>
             #include "plugintree.h"
             #if defined(SOCEXPLORER_SDK_BUILD)
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
             #else
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
             #endif
             class pluginmanagerWDGT : public QSplitter
             {
                 Q_OBJECT
             public:
             SOCEXPLORER_SDK_EXPORT        explicit pluginmanagerWDGT(QWidget *parent = 0);
             SOCEXPLORER_SDK_EXPORT        void setRootLoadable(bool flag);
             SOCEXPLORER_SDK_EXPORT        void setChildLoadable(bool flag);
             signals:
                 void updatepluginInfo(const QString libname);
                 void loadSysDrviver(const QString name);
                 void loadSysDriverToParent(const QString name, const QString instanceName);
                 void geteplugintree(void);
                 void treeChanged(const QList<socexplorerplugin*>& drivers);
                 void changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName);
                 void closeSysDriver(const QString instanceName);
                 void pluginselected(const QString& instanceName);
             public slots:
                 //void libselected(int row);
                 void addPlugin();
                 void removePlugin();
                 void loadplugin();
                 //void loadplugin(QListWidgetItem*);
             private:
                 bool rootLoadable;
                 bool childLoadable;
                 QWidget* pluginListWidgetContainer;
                 QVBoxLayout* pluginListLayout;
                 QHBoxLayout* ButtonsLayout;
                 QSplitter* mainlayoutSpliter;
                 PluginList* pluginTable;
                 pluginInfosWdgt* pluginInfos;
                 plugintree* treeview;
                 QPushButton* addPluginBt;
                 QPushButton* removePluginBt;
                 QPushButton* loadPluginBt;
                 QPushButton* refreshPluginListBt;
             };
             #endif // PLUGINMANAGERWDGT_H

src/SocExplorerEngine/pluginManagerWdgt/plugintree.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PLUGINTREE_H
             #define PLUGINTREE_H
             #include <QWidget>
             #include <QTreeWidget>
             #include <socexplorerplugin.h>
             #include <QList>
             #include <QtGui/QDragEnterEvent>
             #include <QtGui/QDragLeaveEvent>
             #include <QtGui/QDragMoveEvent>
             #include <QtGui/QDropEvent>
             #include <QtCore/QMimeData>
             #include <QtCore/QUrl>
             #include <QtCore/QList>
             #include <QPoint>
             #include <QLabel>
             class plugintree : public QTreeWidget
             {
                 Q_OBJECT
             public:
                 explicit plugintree(QWidget *parent = 0);
             protected:
                 void dragEnterEvent(QDragEnterEvent *event);
                 void dragMoveEvent(QDragMoveEvent *event);
                 void dropEvent(QDropEvent *event);
                 void mousePressEvent(QMouseEvent *event);
                 void mouseDoubleClickEvent(QMouseEvent *event);
                 void keyPressEvent(QKeyEvent *event);
             signals:
                     void geteplugintree(void);
                     void pluginselected(const QString& Name);
                     void loadSysDriverToParent(const QString name, const QString instanceName);
                     void loadSysDriver(const QString name);
                     void closeSysDriver(const QString instanceName);
                     void changeSysDriverInstName(const QString instanceName);
                     void changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName);
             public slots:
                     void treeChanged(const QList<socexplorerplugin*>& drivers);
                     void pluginselectedslt( QTreeWidgetItem * item, int column);
                     void itemSelectionChangedslt();
             private:
                     void addplugin(socexplorerplugin* driver,QTreeWidgetItem* item);
                     QTreeWidgetItem* editeditem;
                     QString* editeditemprev;
                     bool editingItem;
             };
             #endif // PLUGINTREE_H

src/SocExplorerEngine/pluginloader/pluginloader.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PLUGINLOADER_H
             #define PLUGINLOADER_H
             #include <QString>
             #include <QLibrary>
             #include <QObject>
             #include <QStringList>
             #include <socexplorerplugininterface.h>
             #include <socexplorerplugin.h>
             #include <pluginscache.h>
             /*
               Debug
             */
             #include <stdio.h>
             #define loadlib(filename)   QLibrary* lib = new QLibrary((fileName));\
                                         lib->load();\
                                         if(!lib->isLoaded())\
                                         {\
                                             return 0;\
                                         }
             class pluginloader
             {
             private:
                 static pluginloader* _self;
                 static PluginsCache* _cache;
                 static QStringList* _folderList;
                 ~pluginloader();
                 pluginloader();
             public:
                 static void init();
                 static pluginloader* self();
                 static int checklibrary(const QString fileName);
                 static bool isvalid(QString Name);
                 static socexplorerplugin* newsocexplorerplugin(const QString Name);
                 static QString getlibTypeStr(QString Name);
                 static pluginT getlibType(QString Name);
                 static QString getlibVersion(const QString Name);
                 static QString getlibPIDstr(const QString Name);
                 static QString getlibVIDstr(const QString Name);
                 static int getlibPID(const QString Name);
                 static int getlibVID(const QString Name);
                 static int libcanbechild(const QString Name);
                 static int libcanberoot(const QString Name);
                 static QString getlibAuthor(const QString Name);
                 static QString getlibName(const QString Name);
                 static QString getlibDescription(const QString Name);
                 static QString getlibDir(const QString Name);
                 static QString findlib(QString name);
                 static QList<PluginsCacheItem *> listAvailiables(bool rescan=true);
                 static void scanFolders();
                 static void showCache(){_cache->show();}
             private:
                 int p_checklibraryQlib(const QString fileName);
                 int p_checklibraryCustom(const QString fileName);
                 socexplorerplugin* p_newsocexplorerpluginQlib(const QString Name);
                 socexplorerplugin* p_newsocexplorerpluginCustom(const QString Name);
                 static QStringList readFoldersList(const QStringList confFiles);
                 static QString* _cacheLookup(const QString Name);
                 static QString _getlibName(const QString fileName);
                 static int _getlibPID(const QString fileName);
                 static int _getlibVID(const QString fileName);
             };
             #endif

src/SocExplorerEngine/pluginloader/pluginscache.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2012, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PLUGINSCACHE_H
             #define PLUGINSCACHE_H
             #include <QObject>
             #include <QString>
             #include <QList>
             //#include <QtXml>
             #include <QTableWidget>
             class PluginsCacheItem
             {
             public:
                 PluginsCacheItem(const QString& fileName,const QString& path,const QString& pluginName,int VID,int PID);
                 ~PluginsCacheItem(){delete fileName;delete path;delete pluginName;}
                 bool compare(PluginsCacheItem* item);
                 bool comparePluginName(const QString& pluginName);
                 bool comparefileName(const QString& fileName);
                 bool comparefilePath(const QString& filePath);
                 bool compareIDs(int VID,int PID);
                 QString getpath(){return QString(*path);}
                 QString getfileName(){return QString(*fileName);}
                 QString getpluginName(){return QString(*pluginName);}
                 int getVID(){return this->VID;}
                 int getPID(){return this->PID;}
             private:
                 QString* fileName;
                 QString* path;
                 QString* pluginName;
                 int VID;
                 int PID;
             };
             class PluginsCache : public QObject
             {
                 Q_OBJECT
             public:
                 explicit PluginsCache(QObject *parent = 0);
                 void append(const QString& fileName,const QString& path,const QString& pluginName,int VID,int PID);
                 QString first(const QString& pluginName);
                 QString first(int VID,int PID);
                 QStringList findDriver(int VID,int PID);
                 QList<PluginsCacheItem*> listDrivers();
                 void flush();
             public slots:
                 void show();
             private:
                 QList<PluginsCacheItem*>* items;
                 QTableWidget* __view;
             };
             #endif // PLUGINSCACHE_H

src/SocExplorerEngine/plugins/genericPySysdriver.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef GENERICPYSYSDRIVER_H
             #define GENERICPYSYSDRIVER_H
             #include <QObject>
             #include <QVariant>
             #include <QVariantList>
             #include <malloc.h>
             #include <QFile>
             #include <stdint.h>
             #include <QTextStream>
             #if defined(SOCEXPLORER_SDK_BUILD)
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
             #else
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
             #endif
             class socexplorerplugin;
             class SOCEXPLORER_SDK_EXPORT genericPySysdriver : public QObject
             {
                 Q_OBJECT
             public:
                 explicit genericPySysdriver(socexplorerplugin* plugin,QObject* parent=0);
             signals:
             public slots:
                 QVariantList Read(unsigned int address,unsigned int count);
                 void Write(unsigned int address,QList<QVariant> dataList);
                 bool dumpMemory(unsigned int address,unsigned int count,QString file);
                 bool memSet(unsigned int address,int value, unsigned int count);
                 bool loadbin(unsigned int address,QString file);
                 QString instance();
             private:
                 socexplorerplugin* plugin;
             };
             #endif // GENERICPYSYSDRIVER_H

src/SocExplorerEngine/plugins/socexplorerplugin.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2014, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include <socexplorerplugin.h>
             int socexplorerplugin::isConnected(){return this->Connected;}
             QString socexplorerplugin::baseName(){return *_Name;}
             int socexplorerplugin::baseAddress(){return this->BaseAddress;}
             void socexplorerplugin::setBaseAddress(unsigned int baseAddress){this->BaseAddress = baseAddress;}
             QString socexplorerplugin::instanceName()
             {
                 return this->_instanceName;
             }
             int socexplorerplugin::registermenu(QMenu *menu)
             {
                 this->menu = menu->addMenu(this->_instanceName);
                 this->closeAction = this->menu->addAction(tr("Close plugin"));
                 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
                 this->ChildsMenu = this->menu->addMenu(QString("Childs"));
                 for(int i=0;i<this->childs.count();i++)
                 {
                     this->childs.at(i)->registermenu(this->ChildsMenu);
                 }
                 if(this->pyObject!=NULL)emit this->registerObject((QObject*)this->pyObject,this->instanceName());
                 return 0;
             }
             void socexplorerplugin::postInstantiationTrigger()
             {
                 return;
             }
             unsigned int socexplorerplugin::Write(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 if(parent!=NULL)
                 {
                     return parent->Write(Value,count,address);
                 }
                 return 0;
             }
             unsigned int socexplorerplugin::Read(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 if(parent!=NULL)
                 {
                     return parent->Read(Value,count,address);
                 }
                 return 0;
             }
             void socexplorerplugin::closeMe(){emit this->closePlugin(this);}
             void socexplorerplugin::activate(bool flag){this->setEnabled(flag);emit this->activateSig(flag);}
             void socexplorerplugin::setInstanceName(const QString &newName)
             {
                 this->_instanceName = newName;
                 if(this->menu)
                     this->menu->setTitle(this->_instanceName);
                 this->setWindowTitle(newName);
             }
             void socexplorerplugin::makeGenericPyWrapper()
             {
                 this->pyObject = new genericPySysdriver(this);
             }

src/SocExplorerEngine/plugins/socexplorerplugin.h +1 -1

             /*------------------------------------------------------------------------------
             ███████╗ ██████╗  ██████╗    ███████╗██╗  ██╗██████╗ ██╗      ██████╗ ██████╗ ███████╗██████╗
             ██╔════╝██╔═══██╗██╔════╝    ██╔════╝╚██╗██╔╝██╔══██╗██║     ██╔═══██╗██╔══██╗██╔════╝██╔══██╗
             ███████╗██║   ██║██║         █████╗   ╚███╔╝ ██████╔╝██║     ██║   ██║██████╔╝█████╗  ██████╔╝
             ╚════██║██║   ██║██║         ██╔══╝   ██╔██╗ ██╔═══╝ ██║     ██║   ██║██╔══██╗██╔══╝  ██╔══██╗
             ███████║╚██████╔╝╚██████╗    ███████╗██╔╝ ██╗██║     ███████╗╚██████╔╝██║  ██║███████╗██║  ██║
             ╚══════╝ ╚═════╝  ╚═════╝    ╚══════╝╚═╝  ╚═╝╚═╝     ╚══════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝
             --  This file is a part of the SOC Explorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef SOCEXPLORERPLUGIN_H
             #define SOCEXPLORERPLUGIN_H
             #include <QWidget>
             #include <QAction>
             #include <QDockWidget>
             #include <QMainWindow>
             #include <QList>
             #include <QMenu>
             #include <socexplorer.h>
             #include <QObject>
             #include <QVariant>
             #include <QVariantList>
             #include <malloc.h>
             #include <QFile>
             #include <stdint.h>
             #include <QTextStream>
             #include <genericPySysdriver.h>
             #ifndef driver_Name
             #define driver_Name "Plugin"
             #endif
             #ifndef driver_Author
             #define driver_Author "No Author"
             #endif
             #ifndef driver_Version
             #define driver_Version "0.0.0"
             #endif
             #ifndef driver_Description
             #define driver_Description "No description."
             #endif
             #ifndef driver_can_be_root
             #define driver_can_be_root 0
             #endif
             #ifndef driver_can_be_child
             #define driver_can_be_child 0
             #endif
             #ifndef driver_VID
             #define driver_VID 0
             #endif
             #ifndef driver_PID
             #define driver_PID 0
             #endif
             #if defined(SOCEXPLORER_SDK_BUILD)
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
             #else
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
             #endif
             class  genericPySysdriver;
             //! socexplorerplugin is the base class for any SocExplorer plugin, it gives a standard interface to communicate
             //! between each plugins and to interact with SocExplorer software.
             class SOCEXPLORER_SDK_EXPORT socexplorerplugin : public QDockWidget
             {
                 Q_OBJECT
             public:
                 //! Default plugin constructor, any plugin should call this constructor. This constructor creates a
                 //! default python wrapper instance. If you want to connect your own python wrapper, you have to clear
                 //! createPyObject option and instanciate your own genericPySysdriver derivated object.
                 socexplorerplugin(QWidget *parent = 0,bool createPyObject=true):QDockWidget(parent)
                 {
                     closeAction=NULL;
                     menu=NULL;
                     ChildsMenu=NULL;
                     this->Connected = false;
                     this->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable|QDockWidget::DockWidgetVerticalTitleBar);
                     _Name = new QString(driver_Name);
                     _Author = new QString(driver_Author);
                     _Version = new QString(driver_Version);
                     _Description = new QString(driver_Description);
                     _canBeChild = driver_can_be_child;
                     _canBeRoot = driver_can_be_root;
                     _VID = driver_VID;
                     _PID = driver_PID;
                     if(createPyObject)
                     {
                         this->makeGenericPyWrapper();
                     }
                 }
                 //! Tells if the plugin is connected, it is used to enable or disable all childrens interfaces.
                 virtual int isConnected();
                 //! Gives the associated Vendor IDentifier, usefull to automatically associate plugins with found
                 //! hardware while board enumeration.
                 virtual int VID(){return _PID;}
                 //! Gives the associated Product IDentifier, usefull to automatically associate plugins with found
                 //! hardware while board enumeration.
                 virtual int PID(){return _VID;}
                 //! Gives the plugin's base name, usefull to automatically generate instance name.
                 virtual QString baseName();
                 //! Gives the base address of the current instance, for example if your plugin is supposed to drive
                 //! an UART it will correspond to the address of it's first register. This address have at least to
                 //! be set by SocExplorer and it can be user accessible if you want.
                 virtual int baseAddress();
                 //! Sets the base address of the current instance, for example if your plugin is supposed to drive
                 //! an UART it will correspond to the address of it's first register. This address have at least to
                 //! be set by lppSocExplorer and it can be user accessible if you want.
                 virtual void setBaseAddress(unsigned int baseAddress);
                 genericPySysdriver* getPyObjectWrapper(){return this->pyObject;}
                 QList<socexplorerplugin*> childs;
                 socexplorerplugin* parent;
                 QAction* closeAction;
                 QString  instanceName();
                 QMenu* menu;
                 QMenu* ChildsMenu;
             signals:
                 //! Signal emited each time the plugin is about to be closed.
                 void closePlugin(socexplorerplugin* driver);
                 void activateSig(bool flag);
                 void registerObject(QObject* object,const QString& instanceName);
             public slots:
                 virtual int registermenu(QMenu* menu);
                 virtual void postInstantiationTrigger();
                 //! Write slot this is the way your children plugins ask you for writing data.
                 //! If your plugin is supposed to have childern drivers you should implement this methode.
                 //! By default this methode forward the write request to the parent plugin.
                 //! \param Value Pointer the data buffer.
                 //! \param count Number of 32 bits words you should to write.
                 //! \param address Address from where you should to start to write.
                 //! \return Quantity of 32 bits words writtens.
                 virtual unsigned int Write(unsigned int* Value, unsigned int count,unsigned int address);
                 //! Read slot this is the way your children plugins ask you for reading data.
                 //! If your plugin is supposed to have childern drivers you should implement this methode.
                 //! By default this methode forward the write request to the parent plugin.
                 //! \param Value Pointer the data buffer.
                 //! \param count Number of 32 bits words you should to read.
                 //! \param address Address from where you should to start to read.
                 //! \return Quantity of 32 bits words read.
                 virtual unsigned int Read(unsigned int* Value, unsigned int count,unsigned int address);
                 virtual void closeMe();
                 virtual void activate(bool flag);
                 virtual void setInstanceName(const QString& newName);
             protected:
                 void makeGenericPyWrapper();
                 int BaseAddress;
                 bool Connected;
                 genericPySysdriver* pyObject;
                 QString* _Name;
                 QString* _Author;
                 QString* _Version;
                 QString* _Description;
                 QString  _instanceName;
                 int _canBeChild;
                 int _canBeRoot;
                 int _VID;
                 int _PID;
             };
             #endif // SOCEXPLORERPLUGIN_H

src/SocExplorerEngine/pluginsInterface/socexplorerplugininterface.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "socexplorerplugininterface.h"
             #include <QString>
             #ifdef PLUGINHEADER
                 #include PLUGINHEADER
             #else
                 #include <plugindefs.h>
             #endif
             void* socexplorerpluginCreateObject()
             {
                 return (void*) new PLUGIN();
             }
             int socexplorerplugincanberoot()
             {
                 return driver_can_be_root;
             }
             int socexplorerplugincanbechild()
             {
                 return driver_can_be_child;
             }
             int socexplorerpluginpid()
             {
                 return driver_PID;
             }
             int socexplorerpluginvid()
             {
                 return driver_VID;
             }
             pluginT socexplorerpluginType()
             {
                 return PerifDriverT;
             }
             QString socexplorerpluginName()
             {
                 return QString(driver_Name);
             }
             QString socexplorerpluginVersion()
             {
                 return QString(driver_Version);
             }
             QString socexplorerpluginAuthor()
             {
                 return QString(driver_Author);
             }
             QString socexplorerpluginDescription()
             {
                 return QString(driver_Description);
             }

src/SocExplorerEngine/pluginsInterface/socexplorerplugininterface.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the socexplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef SOCEXPLORERPLUGININTERFACE_H
             #define SOCEXPLORERPLUGININTERFACE_H
             #include "socexplorerplugininterface_global.h"
             #include <QString>
             #include <QtGlobal>
             #define ComDriverT  1
             #define PerifDriverT 2
             typedef int pluginT;
             typedef void* (*socexplorerpluginCreateObjectT)();
             typedef pluginT (*socexplorerpluginTypeT)();
             typedef  int (*socexplorerpluginpidT)();
             typedef  int (*socexplorerpluginvidT)();
             typedef  int (*socexplorerplugincanberootT)();
             typedef  int (*socexplorerplugincanbechildT)();
             typedef QString (*socexplorerpluginNameT)();
             typedef QString (*socexplorerpluginVersionT)();
             typedef QString (*socexplorerpluginAuthorT)();
             typedef QString (*socexplorerpluginDescriptionT)();
             extern "C"
             {
             #ifndef QT_ENSURE_STACK_ALIGNED_FOR_SSE
                 #define QT_ENSURE_STACK_ALIGNED_FOR_SSE
             #endif
             //! \header This the C interface socexplorer uses to load dynamically any plugin, a C interface is the
             //! easyest way to manually resolve functions in a dynamic library.
             //! \fn socexplorerpluginCreateObject Plugin constructor.
                 LIBSOCEXPLORERPLUGIN_EXPORT  void* socexplorerpluginCreateObject()QT_ENSURE_STACK_ALIGNED_FOR_SSE;
             //! \fn socexplorerpluginpid Plugin's PID.
                 LIBSOCEXPLORERPLUGIN_EXPORT  int socexplorerpluginpid()QT_ENSURE_STACK_ALIGNED_FOR_SSE;
             //! \fn socexplorerpluginvid Plugin's VID.
                 LIBSOCEXPLORERPLUGIN_EXPORT  int socexplorerpluginvid()QT_ENSURE_STACK_ALIGNED_FOR_SSE;
             //! \fn socexplorerplugincanberoot Tells if the plugin can be a root plugin.
                 LIBSOCEXPLORERPLUGIN_EXPORT  int socexplorerplugincanberoot()QT_ENSURE_STACK_ALIGNED_FOR_SSE;
             //! \fn socexplorerplugincanberoot Tells if the plugin can be a child plugin.
                 LIBSOCEXPLORERPLUGIN_EXPORT  int socexplorerplugincanbechild()QT_ENSURE_STACK_ALIGNED_FOR_SSE;
             //! \fn socexplorerpluginType Gives the plugin's type, not used yet.
                 LIBSOCEXPLORERPLUGIN_EXPORT  pluginT socexplorerpluginType()QT_ENSURE_STACK_ALIGNED_FOR_SSE;
             //! \fn socexplorerpluginVersion Gives the plugin's version.
                 LIBSOCEXPLORERPLUGIN_EXPORT  QString socexplorerpluginVersion()QT_ENSURE_STACK_ALIGNED_FOR_SSE;
             //! \fn socexplorerpluginName Gives the plugin's name.
                 LIBSOCEXPLORERPLUGIN_EXPORT  QString socexplorerpluginName()QT_ENSURE_STACK_ALIGNED_FOR_SSE;
             //! \fn socexplorerpluginAuthor Gives the plugin's author.
                 LIBSOCEXPLORERPLUGIN_EXPORT  QString socexplorerpluginAuthor()QT_ENSURE_STACK_ALIGNED_FOR_SSE;
             //! \fn socexplorerpluginDescription Gives the plugin's description.
                 LIBSOCEXPLORERPLUGIN_EXPORT  QString socexplorerpluginDescription()QT_ENSURE_STACK_ALIGNED_FOR_SSE;
             }
             #endif // SOCEXPLORERPLUGININTERFACE_H

src/SocExplorerEngine/pluginsInterface/socexplorerplugininterface_global.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef SOCEXPLORERPLUGIN_GLOBAL_H
             #define SOCEXPLORERPLUGIN_GLOBAL_H
             #include <QtCore/qglobal.h>
             #if defined(SOCEXPLORERPLUGIN_LIBRARY)
             #  define LIBSOCEXPLORERPLUGIN_EXPORT Q_DECL_EXPORT
             #else
             #  define LIBSOCEXPLORERPLUGIN_EXPORT Q_DECL_IMPORT
             #endif
             #endif // SOCEXPLORERPLUGIN_GLOBAL_H

src/SocExplorerEngine/proxy/socexplorerproxy.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "socexplorerproxy.h"
             #include <pluginmanagerWDGT.h>
             #include <socexplorerengine.h>
             #include <pluginloader.h>
             #include <socexplorerplugin.h>
             socexplorerproxy* socexplorerproxy::_self=NULL;
             QMainWindow* socexplorerproxy::mainWindow=NULL;
             QList<socexplorerplugin*>* socexplorerproxy::drivers=NULL;
             QList<socexplorerplugin*>* socexplorerproxy::linearDriverList=NULL;
             socexplorerplugin* socexplorerproxy::root=NULL;
             socexplorerplugin* socexplorerproxy::parent=NULL;
             PluginsCache* socexplorerproxy::cache=NULL;
             socexplorerproxy::socexplorerproxy(QObject *parent) :
                 QObject(parent)
             {
                 cache = new PluginsCache;
                 drivers = new QList<socexplorerplugin*>;
                 linearDriverList=new QList<socexplorerplugin*>;
                 root = NULL;
             }
             socexplorerproxy::socexplorerproxy(QMainWindow *Mainwindow, QObject *parent):
                 QObject(parent)
             {
                 mainWindow = Mainwindow;
                 cache = new PluginsCache;
                 drivers = new QList<socexplorerplugin*>;
                 linearDriverList=new QList<socexplorerplugin*>;
                 root = NULL;
             }
             void socexplorerproxy::init()
             {
                 if(!_self)
                 {
                     _self = new socexplorerproxy();
                     mainWindow = NULL;
                 }
             }
             void socexplorerproxy::setMainWindow(QMainWindow *Mainwindow)
             {
                 if(!_self)init();
                 mainWindow=Mainwindow;
             }
             void socexplorerproxy::loadSysDriver(const QString name)
             {
                 if(!_self)init();
                 if(pluginloader::libcanberoot(name))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(name);
                     QString driverName = _self->getinstanceName(driver->baseName());
                     loadSysDriver(driver,driverName);
                 }
             }
             void socexplorerproxy::loadSysDriver(const QString name, const QString instanceName)
             {
                 if(!_self)init();
                 if(pluginloader::libcanberoot(name) && !_self->instanceExists(instanceName))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(name);
                     loadSysDriver(driver,instanceName);
                 }
             }
             void socexplorerproxy::loadSysDriver(socexplorerplugin *driver, const QString instanceName)
             {
                 if(!_self)init();
                 driver->setInstanceName(instanceName);
                 driver->parent = NULL;
                 drivers->append(driver);
                 linearDriverList->append(driver);
                 connectChildToProxy(driver);
                 emit _self->addPluginGUI(driver);
                 emit _self->clearMenu();
                 emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
                 SocExplorerEngine::addSOC(driver);
             }
             void socexplorerproxy::loadChildSysDriver(socexplorerplugin *parent, const QString child)
             {
                 if(!_self)init();
                 if(pluginloader::libcanbechild(child))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(child);
                     QString driverName = _self->getinstanceName(driver->baseName());
                     bool ok=true;
                     if(ok)
                     {
                         if(parent!=NULL)_self->loadSysDriverToParent(driver,parent,driverName);
                     }
                 }
             }
             void socexplorerproxy::loadSysDriverToParent(const QString name,const QString ParentInst)
             {
                 if(!_self)init();
                 if(pluginloader::libcanbechild(name))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(name);
                     QString driverName = _self->getinstanceName(driver->baseName());
                     bool ok=true;
                     if(ok)
                     {
                         socexplorerplugin* parent=_self->getSysDriver(ParentInst);
                         if(parent!=NULL)loadSysDriverToParent(driver,parent,driverName);
                     }
                 }
             }
             void socexplorerproxy::loadSysDriverToParent(const QString name,const QString instanceName,const QString ParentInst)
             {
                 if(!_self)init();
                 if(pluginloader::libcanbechild(name) && !_self->instanceExists(instanceName))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(name);
                     bool ok=true;
                     if(ok)
                     {
                         socexplorerplugin* parent=_self->getSysDriver(ParentInst);
                         if(parent!=NULL)loadSysDriverToParent(driver,parent,instanceName);
                     }
                 }
             }
             void socexplorerproxy::loadSysDriverToParent(socexplorerplugin *driver,socexplorerplugin *parent, const QString instanceName)
             {
                 if(!_self)init();
                 linearDriverList->append(driver);
                 driver->parent = parent;
                 driver->setInstanceName(instanceName);
                 parent->childs.append(driver);
                 connectChildToProxy(driver);
                 connectChildToParent(parent,driver);
                 emit _self->clearMenu();
                 emit _self->addPluginGUI(driver);
                 emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
                 driver->postInstantiationTrigger();
             }
             void socexplorerproxy::changeSysDriverInstName(const QString instanceName)
             {
                 Q_UNUSED(instanceName)
             }
             void socexplorerproxy::changeSysDriverInstName(const QString newinstanceName, const QString previnstanceName)
             {
                 if(!_self)init();
                 socexplorerplugin*temp=_self->getSysDriver(previnstanceName);
                 if(temp!=NULL)
                 {
                     if(NULL!=_self->getSysDriver(newinstanceName))
                     {
                         emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
                         return;
                     }
                     temp->setInstanceName(newinstanceName);
                 }
                 emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
             }
             //void socexplorerproxy::loadChild(socexplorerplugin *parent)
             //{
             //    if(!_self)init();
             //    parent = parent;
             //    pluginmanagerWDGT* pluginmanager0 = new pluginmanagerWDGT;
             //    pluginmanager0->setChildLoadable(true);
             //    pluginmanager0->connect(pluginmanager0,SIGNAL(loadSysDrviver(QString)),_self,SLOT(loadSysDriverToParent(QString)));
             //    pluginmanager0->show();
             //}
             void socexplorerproxy::connectChildToParent(socexplorerplugin *parent, socexplorerplugin *child)
             {
                 if(!_self)init();
                 connect(parent,SIGNAL(activateSig(bool)),child,SLOT(activate(bool)));
                 child->activate(parent->isConnected());
             }
             void socexplorerproxy::disconnectChildToParent(socexplorerplugin *child)
             {
                 if(!_self)init();
                 disconnect(child->parent,SIGNAL(activateSig(bool)),child,SLOT(activate(bool)));
             }
             void socexplorerproxy::connectChildToProxy(socexplorerplugin *child)
             {
                 if(!_self)init();
                 connect(child,SIGNAL(registerObject(QObject*,QString)),_self,SIGNAL(registerObject(QObject*,QString)));
                 connect(child,SIGNAL(closePlugin(socexplorerplugin*)),_self,SLOT(closeSysDriver(socexplorerplugin*)));
             }
             void socexplorerproxy::disconnectChildToProxy(socexplorerplugin *child)
             {
                 if(!_self)init();
                 disconnect(child,SIGNAL(registerObject(QObject*,QString)),_self,SIGNAL(registerObject(QObject*,QString)));
                 disconnect(child,SIGNAL(closePlugin(socexplorerplugin*)),_self,SLOT(closeSysDriverFromDriver(socexplorerplugin*)));
             }
             QString socexplorerproxy::getinstanceName(const QString& baseName)
             {
                 if(!_self)init();
                 int i=0;
                 QString name;
                 bool validName = false;
                 while(!validName)
                 {
                     name.clear();
                     name.append(baseName+QString::number(i));
                     validName = instanceNameIsValid(name);
                     i++;
                 }
                 return name;
             }
             void socexplorerproxy::changeSysDriverInstName(socexplorerplugin* driver)
             {
                 if(!_self)init();
                 QString prevName(driver->instanceName());
             }
             bool socexplorerproxy::instanceNameIsValid(const QString& instanceName)
             {
                 if(!_self)init();
                 for(int k=0;k<linearDriverList->count();k++)
                 {
                     if(!linearDriverList->at(k)->instanceName().compare(instanceName))
                         return false;
                 }
                 return true;
             }
             socexplorerplugin *socexplorerproxy::findPlugin(const QString &instanceName)
             {
                 if(!_self)init();
                 for(int k=0;k<linearDriverList->count();k++)
                 {
                     if(linearDriverList->at(k)->instanceName().compare(instanceName))
                         return linearDriverList->at(k);
                 }
                 return NULL;
             }
             bool socexplorerproxy::instanceExists(const QString &instanceName)
             {
                 return !socexplorerproxy::instanceNameIsValid(instanceName);
             }
             void socexplorerproxy::close()
             {
                 if(!_self)init();
                 socexplorerplugin* tmpPtr;
                 while(drivers->count()>0)
                 {
                     tmpPtr = drivers->last();
                     drivers->removeLast();
                     _self->closeSysDriver(tmpPtr);
                 }
                 if(root!=NULL)
                 {
                     _self->closeSysDriver(root);
                 }
             }
             socexplorerplugin* socexplorerproxy::getSysDriver(const QString instanceName)
             {
                 if(!_self)init();
                 for(int i=0;i<linearDriverList->count();i++)
                 {
                     if(!linearDriverList->at(i)->instanceName().compare(instanceName))
                         return linearDriverList->at(i);
                 }
                 return NULL;
             }
             void socexplorerproxy::closeSysDriver(const QString instanceName)
             {
                 if(!_self)init();
                 closeSysDriver(getSysDriver(instanceName),false);
             }
             void socexplorerproxy::closeSysDriver(socexplorerplugin *driver, bool recursive)
             {
                 if(!_self)init();
                 if(driver!=NULL)
                 {
                     emit _self->removePluginGUI(driver);
                     if(driver->parent==NULL)SocExplorerEngine::removeSOC(driver);
                     while(driver->childs.count()!=0)closeSysDriver(driver->childs.first());
                     linearDriverList->removeOne(driver);
                     if(driver->parent!= NULL)
                     {
                         driver->parent->childs.removeOne(driver);     //Have parent so it's a child
                         disconnectChildToParent(driver);
                         disconnectChildToProxy(driver);
                         delete driver;
                     }
                     else
                     {
                         drivers->removeOne(driver);
                         disconnectChildToProxy(driver);
                         delete driver;
                     }
                     if(!recursive)
                     {
                         emit _self->clearMenu();
                         emit _self->registermenu(mainWindow);
                         emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
                     }
                 }
             }
             void socexplorerproxy::geteplugintree()
             {
                 if(!_self)init();
                 emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
             }
             void socexplorerproxy::closeSysDriverFromDriver(socexplorerplugin *driver)
             {
                 if(!_self)init();
                 emit _self->closeSysDriverSig(driver);
             }
             void socexplorerproxy::updateText()
             {
                 if(!_self)init();
                 emit _self->clearMenu();
                 emit _self->registermenu(mainWindow);
             }
             void socexplorerproxy::makeMenu(QMenu* menu)
             {
                 if(!_self)init();
                 for(int i=0;i<drivers->count();i++)
                 {
                     drivers->at(i)->registermenu(menu);
                 }
             }

src/SocExplorerEngine/proxy/socexplorerproxy.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef SOCEXPLORERPROXY_H
             #define SOCEXPLORERPROXY_H
             #include <QObject>
             #include <QString>
             #include <QList>
             #include "pluginscache.h"
             #include <socexplorerplugin.h>
             #include <socexplorerplugininterface.h>
             #include <QInputDialog>
             #include <QtGlobal>
             #if defined(SOCEXPLORER_SDK_BUILD)
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
             #else
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
             #endif
             class SOCEXPLORER_SDK_EXPORT socexplorerproxy : public QObject
             {
                 Q_OBJECT
             private:
                 socexplorerproxy(QObject *parent = 0);
                 socexplorerproxy(QMainWindow* Mainwindow,QObject *parent = 0);
                 static socexplorerproxy* _self;
             public:
                 static socexplorerproxy* self(){if(!_self)init(); return _self;}
                 static void init();
                 static void setMainWindow(QMainWindow* Mainwindow);
                 static void connectChildToParent(socexplorerplugin* parent, socexplorerplugin* child);
                 static void connectChildToProxy(socexplorerplugin* child);
                 static void disconnectChildToParent(socexplorerplugin* child);
                 static void disconnectChildToProxy(socexplorerplugin* child);
                 static bool instanceNameIsValid(const QString& instanceName);
                 static socexplorerplugin* findPlugin(const QString &instanceName);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE static void loadChildSysDriver(socexplorerplugin* parent,const QString child);
             signals:
                 void addPluginGUI(QDockWidget* plugin);
                 void removePluginGUI(QDockWidget* plugin);
                 int registermenu(QMainWindow* menuHolder);
                 void clearMenu();
                 QStringList findDrivers(int VID,int PID);
                 void rootDriverAdded(socexplorerplugin* driver);
                 void rootDriverRemoved();
                 void closeSysDriverSig(socexplorerplugin* driver);
                 void registerObject(QObject* object,const QString& instanceName);
                 void treeChanged(const QList<socexplorerplugin*>& drivers);
             public slots:
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriver(const QString name);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriver(const QString name,const QString instanceName);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriver(socexplorerplugin* driver,const QString instanceName);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriverToParent(const QString name,const QString ParentInst);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriverToParent(const QString name,const QString instanceName,const QString ParentInst);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriverToParent(socexplorerplugin *driver,socexplorerplugin *parent, const QString instanceName);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void changeSysDriverInstName(const QString instanceName);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName);
              //   QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadChild(socexplorerplugin* parent);
                 void updateText();
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void closeSysDriverFromDriver(socexplorerplugin* driver);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void closeSysDriver(socexplorerplugin* driver,bool recursive=false);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void closeSysDriver(const QString instanceName);
                 void makeMenu(QMenu* menu);
                 void close();
                 QString getinstanceName(const QString& baseName);
                 void geteplugintree();
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE socexplorerplugin* getSysDriver(const QString instanceName);
                 bool instanceExists(const QString& instanceName);
             private:
                 static void changeSysDriverInstName(socexplorerplugin* driver);
                 static QMainWindow* mainWindow;
                 static QList<socexplorerplugin*>* drivers;
                 static QList<socexplorerplugin*>* linearDriverList;
                 static socexplorerplugin* root;
                 static socexplorerplugin* parent;
                 static PluginsCache* cache;
             };
             #endif // SOCEXPLORERPROXY_H

src/aboutsocexplorer.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2012, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "aboutsocexplorer.h"
             #include <socexplorerengine.h>
             aboutsocexplorer::aboutsocexplorer(QWidget *parent) :
                 QTextBrowser(parent)
             {
                 this->setReadOnly(true);
                 QString code;
                 QFile file;
                 code.clear();
                 file.setFileName(":/about/about.html");
                 this->setAcceptRichText(true);
                 file.open(QIODevice::ReadOnly);
                 QTextStream filestrm(&file);
                 while(!filestrm.atEnd())code.append(filestrm.readLine().replace("$VERSION$",SocExplorerEngine::SocExplorerVersion()).replace("$Branch$",SocExplorerEngine::SocExplorerBranch()).replace("$Changeset$",SocExplorerEngine::SocExplorerChangeset())+"\n");
                 this->setHtml(code);
                 file.close();
                 this->setMinimumSize(400,400);
                 connect(this,SIGNAL(anchorClicked(QUrl)),this,SLOT(anchorClicked_slt(QUrl)));
                 this->setOpenLinks(false);
             }
             void aboutsocexplorer::anchorClicked_slt(const QUrl & url)
             {
                 QDesktopServices::openUrl(url);
             }

src/aboutsocexplorer.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2012, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef ABOUTSOCEXPLORER_H
             #define ABOUTSOCEXPLORER_H
             #include <QWidget>
             #include <QTextBrowser>
             #include <QFile>
             #include <QTextStream>
             #include <QDesktopServices>
             #include <QUrl>
             class aboutsocexplorer : public QTextBrowser
             {
                 Q_OBJECT
             public:
                 explicit aboutsocexplorer(QWidget *parent = 0);
             signals:
             public slots:
                 void anchorClicked_slt(const QUrl &);
             private:
             };
             #endif // ABOUTSOCEXPLORER_H

src/common/abstractexecfile.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2014, 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 "abstractexecfile.h"
             abstractExecFile::abstractExecFile(QObject *parent) :
                 QObject(parent)
             {
             }
             abstractExecFile::abstractExecFile(const QString &File, QObject *parent)
             {
             }
             bool abstractExecFile::openFile(const QString &File)
             {
             }
             bool abstractExecFile::isopened()
             {
             }
             int abstractExecFile::setFilename(const QString &name)
             {
             }
             int abstractExecFile::closeFile()
             {
             }
             QList<codeFragment> abstractExecFile::getFragments()
             {
             }
             codeFragment::codeFragment()
             {
             }

src/common/abstractexecfile.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2014, 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 ABSTRACTEXECFILE_H
             #define ABSTRACTEXECFILE_H
             #include <QObject>
             class codeFragment
             {
             public:
                 codeFragment();
                 char* data;
                 quint32 size;
                 quint32 address;
             };
             class abstractExecFile : public QObject
             {
                 Q_OBJECT
             public:
                 abstractExecFile(QObject *parent = 0);
                 abstractExecFile(const QString& File,QObject *parent = 0);
                 virtual bool openFile(const QString& File);
                 virtual bool isopened();
                 virtual int setFilename(const QString& name);
                 virtual int closeFile();
                 virtual QList<codeFragment> getFragments();
             signals:
             public slots:
             };
             #endif // ABSTRACTEXECFILE_H

src/common/elf/elffile.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2014, 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 "elffile.h"
             ElfFile::ElfFile(QObject *parent) :
                 abstractExecFile(parent)
             {
             }
             ElfFile::ElfFile(const QString &File, QObject *parent)
             {
             }

src/common/elf/elffile.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2014, 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 <abstractexecfile.h>
             #ifndef ELFFILE_H
             #define ELFFILE_H
             class ElfFile : public abstractExecFile
             {
                 Q_OBJECT
             public:
                 ElfFile(QObject *parent = 0);
                 ElfFile(const QString& File,QObject *parent = 0);
             signals:
             public slots:
             };
             #endif // ELFFILE_H

src/common/elf/elfinfowdgt.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2013, 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 3 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "elfinfowdgt.h"
             elfInfoWdgt::elfInfoWdgt(QWidget *parent) :
                 QWidget(parent)
             {
                 this->mainLayout = new QVBoxLayout;
                 this->ElfArchitecture= new QLabel;
                 this->ElfType = new QLabel;
                 this->ElfVersion = new QLabel;
                 this->splitter = new QSplitter;
                 this->hexViewer  = new QHexEdit;
                 this->elfInfoWdgtLay = new QWidget;
                 this->elfInfoWdgtLayout = new QVBoxLayout;
                 this->segmentsListTableWdgt = new QTableWidget;
                 this->segmentsListTableWdgt->setColumnCount(7);
                 this->segmentsListTableWdgt->setHorizontalHeaderLabels(QStringList()<<"Type"<<"Offset"<<"Vaddr"<<"Paddr"<<"File Size"<<"Mem Size"<<"Flags");
                 this->sectionsListTableWdgt = new QTableWidget;
                 this->sectionsListTableWdgt->setColumnCount(2);
                 this->sectionsListTableWdgt->setHorizontalHeaderLabels(QStringList()<<"Name"<<"Type");
                 this->ElfArchitecture->setText(QString("Architecture: "));
                 this->ElfType->setText(QString("Type: "));
                 this->ElfVersion->setText(QString("Version: "));
                 this->elfInfoWdgtLayout->addWidget(this->ElfArchitecture);
                 this->elfInfoWdgtLayout->addWidget(this->ElfType);
                 this->elfInfoWdgtLayout->addWidget(this->ElfVersion);
                 this->elfInfoWdgtLayout->addWidget(this->segmentsListTableWdgt);
                 this->elfInfoWdgtLayout->addWidget(this->sectionsListTableWdgt);
                 this->splitter->addWidget(this->hexViewer);
                 this->splitter->addWidget(this->elfInfoWdgtLay);
                 this->elfInfoWdgtLay->setLayout(this->elfInfoWdgtLayout);
                 this->mainLayout->addWidget(this->splitter);
                 this->setLayout(this->mainLayout);
                 connect(this->segmentsListTableWdgt,SIGNAL(cellActivated(int,int)),this,SLOT(cellActivated(int,int)));
                 connect(this->sectionsListTableWdgt,SIGNAL(cellActivated(int,int)),this,SLOT(cellActivated(int,int)));
             }
             void elfInfoWdgt::updateInfo(elfparser *parser)
             {
                 if(parser!=NULL)
                 {
                     this->ElfArchitecture->setText(QString("Architecture: ")+parser->getArchitecture());
                     this->ElfType->setText(QString("Type: ")+parser->getType());
                     this->ElfVersion->setText(QString("Version: 0x")+QString::number(parser->getVersion(),16));
                     this->updateSectionsTable(parser);
                     this->updateSegmentsTable(parser);
                 }
             }
             void elfInfoWdgt::cellActivated(int row, int column)
             {
                 char* buff=NULL;
                 this->parser->getSectionData(row,&buff);
                 this->hexViewer->setData(QByteArray(buff,this->parser->getSectionDatasz(row)));
             }
             void elfInfoWdgt::updateSectionsTable(elfparser* parser)
             {
                 if(parser!=NULL)
                 {
                     this->parser = parser;
                     QTableWidgetItem *item;
                     for(int i=0 ;i<this->sectionsListTableWdgt->rowCount();i++)
                     {
                         for(int l=0;l<this->sectionsListTableWdgt->columnCount();l++)
                         {
                             item = this->sectionsListTableWdgt->item(i,l);
                             delete item;
                         }
                     }
                     this->sectionsListTableWdgt->setRowCount(parser->getSectioncount());
                     for(int i=0;i<parser->getSectioncount();i++)
                     {
                         item = new QTableWidgetItem(parser->getSectionName(i));
                         item->setFlags(item->flags() &~ Qt::ItemIsEditable);
                         this->sectionsListTableWdgt->setItem(i,0,item);
                         item = new QTableWidgetItem(parser->getSectionType(i));
                         item->setFlags(item->flags() &~ Qt::ItemIsEditable);
                         this->sectionsListTableWdgt->setItem(i,1,item);
                     }
                     this->sectionsListTableWdgt->resizeColumnsToContents();
                     this->sectionsListTableWdgt->resizeRowsToContents();
                 }
             }
             void elfInfoWdgt::updateSegmentsTable(elfparser* parser)
             {
                 if(parser!=NULL)
                 {
                     this->parser = parser;
                     QTableWidgetItem *item;
                     for(int i=0 ;i<this->segmentsListTableWdgt->rowCount();i++)
                     {
                         for(int l=0;l<this->segmentsListTableWdgt->columnCount();l++)
                         {
                             item = this->segmentsListTableWdgt->item(i,l);
                             delete item;
                         }
                     }
                     this->segmentsListTableWdgt->setRowCount(parser->getSegmentcount());
                     for(int i=0;i<parser->getSegmentcount();i++)
                     {
                         item = new QTableWidgetItem(parser->getSegmentType(i));
                         item->setFlags(item->flags() &~ Qt::ItemIsEditable);
                         this->segmentsListTableWdgt->setItem(i,0,item);
                         item = new QTableWidgetItem("0x"+QString::number(parser->getSegmentOffset(i),16));
                         item->setFlags(item->flags() &~ Qt::ItemIsEditable);
                         this->segmentsListTableWdgt->setItem(i,1,item);
                         item = new QTableWidgetItem("0x"+QString::number(parser->getSegmentVaddr(i),16));
                         item->setFlags(item->flags() &~ Qt::ItemIsEditable);
                         this->segmentsListTableWdgt->setItem(i,2,item);
                         item = new QTableWidgetItem("0x"+QString::number(parser->getSegmentPaddr(i),16));
                         item->setFlags(item->flags() &~ Qt::ItemIsEditable);
                         this->segmentsListTableWdgt->setItem(i,3,item);
                         item = new QTableWidgetItem("0x"+QString::number(parser->getSegmentFilesz(i),16));
                         item->setFlags(item->flags() &~ Qt::ItemIsEditable);
                         this->segmentsListTableWdgt->setItem(i,4,item);
                         item = new QTableWidgetItem("0x"+QString::number(parser->getSegmentMemsz(i),16));
                         item->setFlags(item->flags() &~ Qt::ItemIsEditable);
                         this->segmentsListTableWdgt->setItem(i,5,item);
                         item = new QTableWidgetItem(parser->getSegmentFlags(i));
                         item->setFlags(item->flags() &~ Qt::ItemIsEditable);
                         this->segmentsListTableWdgt->setItem(i,6,item);
                     }
                     this->segmentsListTableWdgt->resizeColumnsToContents();
                     this->segmentsListTableWdgt->resizeRowsToContents();
                 }
             }

src/common/elf/elfinfowdgt.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2013, 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 3 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef ELFINFOWDGT_H
             #define ELFINFOWDGT_H
             #include <QWidget>
             #include "elfparser.h"
             #include <QVBoxLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QTextEdit>
             #include <QTableWidget>
             #include <qhexedit.h>
             #include <QSplitter>
             class elfInfoWdgt : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit elfInfoWdgt(QWidget *parent = 0);
             signals:
             public slots:
                 void updateInfo(elfparser* parser);
                 void cellActivated ( int row, int column );
             private:
                 void updateSectionsTable(elfparser* parser);
                 void updateSegmentsTable(elfparser* parser);
                 QVBoxLayout* mainLayout;
                 QLabel* ElfArchitecture;
                 QLabel* ElfType;
                 QLabel* ElfVersion;
                 QTableWidget* segmentsListTableWdgt,*sectionsListTableWdgt;
                 QHexEdit* hexViewer;
                 QSplitter* splitter;
                 QWidget* elfInfoWdgtLay;
                 QVBoxLayout* elfInfoWdgtLayout;
                 elfparser* parser;
             };
             #endif // ELFINFOWDGT_H

src/common/elf/elfparser.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2013, 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 3 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "elfparser.h"
             #include <sys/types.h>
             #include <sys/stat.h>
             #include <fcntl.h>
             #include <unistd.h>
             void elfresolveMachine(Elf64_Half	e_machine,char* MachineName)
             {
                 //Update from with bash script don't write it by yourself!
                 switch(e_machine)
                 {
                 case EM_NONE   :
                     strcpy(MachineName,"No machine");
                     break;
                 case EM_M32   :
                     strcpy(MachineName,"AT&T WE 32100");
                     break;
                 case EM_SPARC   :
                     strcpy(MachineName,"SUN SPARC");
                     break;
                 case EM_386   :
                     strcpy(MachineName,"Intel 80386");
                     break;
                 case EM_68K   :
                     strcpy(MachineName,"Motorola m68k family");
                     break;
                 case EM_88K   :
                     strcpy(MachineName,"Motorola m88k family");
                     break;
                 case EM_860   :
                     strcpy(MachineName,"Intel 80860");
                     break;
                 case EM_MIPS   :
                     strcpy(MachineName,"MIPS R3000 big-endian");
                     break;
                 case EM_S370  :
                     strcpy(MachineName,"IBM System\/370");
                     break;
                 case EM_MIPS_RS3_LE   :
                     strcpy(MachineName,"MIPS R3000 little-endian");
                     break;
                 case EM_PARISC   :
                     strcpy(MachineName,"HPPA");
                     break;
                 case EM_VPP500   :
                     strcpy(MachineName,"Fujitsu VPP500");
                     break;
                 case EM_SPARC32PLUS   :
                     strcpy(MachineName,"Sun's \"v8plus\"");
                     break;
                 case EM_960   :
                     strcpy(MachineName,"Intel 80960");
                     break;
                 case EM_PPC   :
                     strcpy(MachineName,"PowerPC");
                     break;
                 case EM_PPC64   :
                     strcpy(MachineName,"PowerPC 64-bit");
                     break;
                 case EM_S390   :
                     strcpy(MachineName,"IBM S390");
                     break;
                 case EM_V800   :
                     strcpy(MachineName,"NEC V800 series");
                     break;
                 case EM_FR20   :
                     strcpy(MachineName,"Fujitsu FR20");
                     break;
                 case EM_RH32   :
                     strcpy(MachineName,"TRW RH-32");
                     break;
                 case EM_RCE   :
                     strcpy(MachineName,"Motorola RCE");
                     break;
                 case EM_ARM   :
                     strcpy(MachineName,"ARM");
                     break;
                 case EM_SH   :
                     strcpy(MachineName,"Hitachi SH");
                     break;
                 case EM_SPARCV9   :
                     strcpy(MachineName,"SPARC v9 64-bit");
                     break;
                 case EM_TRICORE   :
                     strcpy(MachineName,"Siemens Tricore");
                     break;
                 case EM_ARC   :
                     strcpy(MachineName,"Argonaut RISC Core");
                     break;
                 case EM_H8_300 :
                     strcpy(MachineName,"Hitachi H8\/300");
                     break;
                 case EM_H8_300H  :
                     strcpy(MachineName,"Hitachi H8\/300H");
                     break;
                 case EM_H8S   :
                     strcpy(MachineName,"Hitachi H8S");
                     break;
                 case EM_H8_500  :
                     strcpy(MachineName,"Hitachi H8\/500");
                     break;
                 case EM_IA_64   :
                     strcpy(MachineName,"Intel Merced");
                     break;
                 case EM_MIPS_X   :
                     strcpy(MachineName,"Stanford MIPS-X");
                     break;
                 case EM_COLDFIRE   :
                     strcpy(MachineName,"Motorola Coldfire");
                     break;
                 case EM_68HC12   :
                     strcpy(MachineName,"Motorola M68HC12");
                     break;
                 case EM_MMA   :
                     strcpy(MachineName,"Fujitsu MMA Multimedia Accelerator");
                     break;
                 case EM_PCP   :
                     strcpy(MachineName,"Siemens PCP");
                     break;
                 case EM_NCPU   :
                     strcpy(MachineName,"Sony nCPU embeeded RISC");
                     break;
                 case EM_NDR1   :
                     strcpy(MachineName,"Denso NDR1 microprocessor");
                     break;
                 case EM_STARCORE :
                     strcpy(MachineName,"Motorola Start*Core processor");
                     break;
                 case EM_ME16   :
                     strcpy(MachineName,"Toyota ME16 processor");
                     break;
                 case EM_ST100   :
                     strcpy(MachineName,"STMicroelectronic ST100 processor");
                     break;
                 case EM_TINYJ   :
                     strcpy(MachineName,"Advanced Logic Corp. Tinyj emb.fam");
                     break;
                 case EM_X86_64   :
                     strcpy(MachineName,"AMD x86-64 architecture");
                     break;
                 case EM_PDSP   :
                     strcpy(MachineName,"Sony DSP Processor");
                     break;
                 case EM_FX66 :
                     strcpy(MachineName,"Siemens FX66 microcontroller");
                     break;
                 case EM_ST9PLUS :
                     strcpy(MachineName,"STMicroelectronics ST9+ 8\/16 mc");
                     break;
                 case EM_ST7   :
                     strcpy(MachineName,"STmicroelectronics ST7 8 bit mc");
                     break;
                 case EM_68HC16   :
                     strcpy(MachineName,"Motorola MC68HC16 microcontroller");
                     break;
                 case EM_68HC11   :
                     strcpy(MachineName,"Motorola MC68HC11 microcontroller");
                     break;
                 case EM_68HC08   :
                     strcpy(MachineName,"Motorola MC68HC08 microcontroller");
                     break;
                 case EM_68HC05   :
                     strcpy(MachineName,"Motorola MC68HC05 microcontroller");
                     break;
                 case EM_SVX   :
                     strcpy(MachineName,"Silicon Graphics SVx");
                     break;
                 case EM_ST19   :
                     strcpy(MachineName,"STMicroelectronics ST19 8 bit mc");
                     break;
                 case EM_VAX   :
                     strcpy(MachineName,"Digital VAX");
                     break;
                 case EM_CRIS   :
                     strcpy(MachineName,"Axis Communications 32-bit embedded processor");
                     break;
                 case EM_JAVELIN   :
                     strcpy(MachineName,"Infineon Technologies 32-bit embedded processor");
                     break;
                 case EM_FIREPATH   :
                     strcpy(MachineName,"Element 14 64-bit DSP Processor");
                     break;
                 case EM_ZSP   :
                     strcpy(MachineName,"LSI Logic 16-bit DSP Processor");
                     break;
                 case EM_MMIX   :
                     strcpy(MachineName,"Donald Knuth's educational 64-bit processor");
                     break;
                 case EM_HUANY   :
                     strcpy(MachineName,"Harvard University machine-independent object files");
                     break;
                 case EM_PRISM   :
                     strcpy(MachineName,"SiTera Prism");
                     break;
                 case EM_AVR   :
                     strcpy(MachineName,"Atmel AVR 8-bit microcontroller");
                     break;
                 case EM_FR30   :
                     strcpy(MachineName,"Fujitsu FR30");
                     break;
                 case EM_D10V   :
                     strcpy(MachineName,"Mitsubishi D10V");
                     break;
                 case EM_D30V   :
                     strcpy(MachineName,"Mitsubishi D30V");
                     break;
                 case EM_V850   :
                     strcpy(MachineName,"NEC v850");
                     break;
                 case EM_M32R   :
                     strcpy(MachineName,"Mitsubishi M32R");
                     break;
                 case EM_MN10300   :
                     strcpy(MachineName,"Matsushita MN10300");
                     break;
                 case EM_MN10200   :
                     strcpy(MachineName,"Matsushita MN10200");
                     break;
                 case EM_PJ   :
                     strcpy(MachineName,"picoJava");
                     break;
                 case EM_OPENRISC   :
                     strcpy(MachineName,"OpenRISC 32-bit embedded processor");
                     break;
                 case EM_ARC_A5   :
                     strcpy(MachineName,"ARC Cores Tangent-A5");
                     break;
                 case EM_XTENSA   :
                     strcpy(MachineName,"Tensilica Xtensa Architecture");
                     break;
                 default:
                     strcpy(MachineName,"Unknow Machine");
                     break;
                 }
             }
             elfparser::elfparser()
             {
                 this->opened = false;
                 this->type_elf = false;
                 this->elfFile = NULL;
                 this->e = NULL;
             }
             int elfparser::setFilename(const QString &name)
             {
                 this->closeFile();
                 if(elf_version(EV_CURRENT)==EV_NONE)return 0;
             #ifdef _ELF_WINDOWS_
                 this->elfFile = open(name.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
             #else
                 this->elfFile = open(name.toStdString().c_str(),O_RDONLY ,0);
             #endif
                 if(this->elfFile==NULL)return 0;
                 this->e = elf_begin(this->elfFile,ELF_C_READ,NULL);
                 if(this->e==NULL)return 0;
                 this->ek = elf_kind(this->e);
                 gelf_getehdr (this->e, &this->ehdr );
                 elf_getshdrstrndx (this->e, &this->shstrndx);
                 this->updateSegments();
                 this->updateSections();
                 return 1;
             }
             int elfparser::closeFile()
             {
                 if(this->elfFile!=NULL)
                 {
                     if(this->e!=NULL)
                     {
                         elf_end(this->e);
                         this->e = NULL;
                     }
                     close(this->elfFile);
                     this->elfFile = NULL;
                 }
                 return 0;
             }
             bool elfparser::isopened()
             {
                 return this->opened;
             }
             bool elfparser::iself()
             {
                 return this->type_elf;
             }
             QString elfparser::getArchitecture()
             {
                 QString arch("");
                 char archName[256]="";
                 if(this->e!=NULL)
                 {
                     elfresolveMachine(this->ehdr.e_machine,archName);
                     arch = archName;
                 }
                 return arch;
             }
             QString elfparser::getType()
             {
                 QString kind("");
                 if(this->e!=NULL)
                 {
                     switch(this->ek)
                     {
                     case ELF_K_AR:
                         kind = "Archive";
                         break;
                     case ELF_K_ELF:
                         kind = "Elf";
                         break;
                     case ELF_K_COFF:
                         kind = "COFF";
                         break;
                     case ELF_K_NUM:
                         kind = "NUM";
                         break;
                     case ELF_K_NONE:
                         kind = "Data";
                         break;
                     default:
                         kind = "Unknow";
                         break;
                     }
                 }
                 return kind;
             }
             int32_t  elfparser::getVersion()
             {
                 if(this->e!=NULL)
                 {
                     return this->ehdr.e_version;
                 }
             }
             int elfparser::getSectioncount()
             {
                 return (int)this->SectionCount;
             }
             int elfparser::getSegmentcount()
             {
                 return (int)this->SegmentCount;
             }
             QString elfparser::getSegmentType(int index)
             {
                 QString type("");
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         switch(this->Segments.at(index)->p_type)
                         {
                         case PT_NULL:
                             type = "Program header table entry unused";
                             break;
                         case PT_LOAD:
                             type = "Loadable program segment";
                             break;
                         case PT_DYNAMIC	:
                             type = "Dynamic linking information";
                             break;
                         case PT_INTERP:
                             type ="Program interpreter";
                             break;
                         case PT_NOTE:
                             type = "Auxiliary information";
                             break;
                         case PT_SHLIB:
                             type = "Reserved";
                             break;
                         case PT_PHDR:
                             type =	"Entry for header table itself";
                             break;
                         case PT_TLS:
                             type = "Thread-local storage segment";
                             break;
                         case PT_NUM:
                             type = "Number of defined types";
                             break;
                         case PT_LOOS:
                             type =	"Start of OS-specific";
                             break;
                         case PT_SUNWSTACK:
                             type = "Stack segment";
                             break;
                         case PT_LOPROC:
                             type = "Start of processor-specific";
                             break;
                         case PT_HIPROC:
                             type = "End of processor-specific";
                             break;
                         default:
                             type = "Unknow Section Type";
                             break;
                         }
                     }
                 }
                 return type;
             }
             int64_t elfparser::getSegmentOffset(int index)
             {
                 int64_t Offset;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         Offset =  (int64_t)this->Segments.at(index)->p_offset;
                     }
                 }
                 return Offset;
             }
             int64_t elfparser::getSegmentVaddr(int index)
             {
                 int64_t Vaddr = 0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         Vaddr =  (int64_t)this->Segments.at(index)->p_vaddr;
                     }
                 }
                 return Vaddr;
             }
             int64_t elfparser::getSegmentPaddr(int index)
             {
                 int64_t Paddr=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         Paddr = (int64_t)this->Segments.at(index)->p_paddr;
                     }
                 }
                 return Paddr;
             }
             int64_t elfparser::getSectionPaddr(int index)
             {
                 int64_t Paddr=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         Paddr = (int64_t)this->sections.at(index)->section_header->sh_addr;
                     }
                 }
                 return Paddr;
             }
             int64_t elfparser::getSegmentFilesz(int index)
             {
                 int64_t FileSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         FileSz = (int64_t)this->Segments.at(index)->p_filesz;
                     }
                 }
                 return FileSz;
             }
             int64_t elfparser::getSectionDatasz(int index)
             {
                 int64_t DataSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         DataSz = (int64_t)this->sections.at(index)->data->d_size;
                     }
                 }
                 return DataSz;
             }
             bool elfparser::getSectionData(int index, char **buffer)
             {
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         *buffer = (char *)this->sections.at(index)->data->d_buf;
                         return true;
                     }
                 }
                 return false;
             }
             int64_t elfparser::getSegmentMemsz(int index)
             {
                 int64_t MemSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         MemSz = (int64_t)this->Segments.at(index)->p_memsz;
                     }
                 }
                 return MemSz;
             }
             int64_t elfparser::getSectionMemsz(int index)
             {
                 int64_t MemSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         MemSz = (int64_t)this->sections.at(index)->section_header->sh_size;
                     }
                 }
                 return MemSz;
             }
             QString elfparser::getSegmentFlags(int index)
             {
                 QString flags("");
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         if((this->Segments.at(index)->p_flags&PF_X) == PF_X)flags+="x";
                         if((this->Segments.at(index)->p_flags&PF_W) == PF_W)flags+="w";
                         if((this->Segments.at(index)->p_flags&PF_R) == PF_R)flags+="r";
                         if((this->Segments.at(index)->p_flags&PF_MASKOS) == PF_MASKOS)flags+=" OS-specific";
                         if((this->Segments.at(index)->p_flags&PF_MASKPROC) == PF_MASKPROC)flags+=" Processor-specific";
                     }
                 }
                 return flags;
             }
             QString elfparser::getSectionName(int index)
             {
                 char* nameChr = elf_strptr(this->e , this->shstrndx , this->sections.at(index)->section_header->sh_name);
                 return QString(nameChr);
             }
             void elfparser::updateSections()
             {
                 for(int i=0;i<this->sections.count();i++)
                 {
                     delete this->sections.at(i);
                 }
                 this->sections.clear();
                 this->scn = elf_nextscn (this->e , NULL );
                 this->SectionCount = 0;
                 while( this->scn != NULL )
                 {
                     GElf_Shdr* shdr = (GElf_Shdr*)malloc(sizeof(GElf_Shdr));
                     gelf_getshdr ( this->scn , shdr );
                     Elf_Data*  data = elf_getdata(this->scn, NULL);
                     this->sections.append(new Elf_Section(data,shdr));
                     this->SectionCount+=1;
                     this->scn = elf_nextscn(e , scn);
                 }
             }
             void elfparser::updateSegments()
             {
                 elf_getphdrnum (this->e , &this->SegmentCount);
                 for(int i=0;i<this->Segments.count();i++)
                 {
                     free(this->Segments.at(i));
                 }
                 this->Segments.clear();
                 for(int i=0;i<this->SegmentCount;i++)
                 {
                     GElf_Phdr* header=(GElf_Phdr*)malloc(sizeof(GElf_Phdr));
                     gelf_getphdr (this->e , i , header );
                     this->Segments.append(header);
                 }
             }
             QString elfparser::getSectionType(int index)
             {
                 QString type("");
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         switch(this->Segments.at(index)->p_type)
                         {
                         case SHT_NULL	 :	type = "Section header table entry unused"; break;
                         case SHT_PROGBITS	  :		type = "Program data"; break;
                         case SHT_SYMTAB	  :		type = "Symbol table"; break;
                         case SHT_STRTAB	  :		type = "String table"; break;
                         case SHT_RELA	  :		type = "Relocation entries with addends"; break;
                         case SHT_HASH	  :		type = "Symbol hash table"; break;
                         case SHT_DYNAMIC	 :		type = "Dynamic linking information"; break;
                         case SHT_NOTE	  :		type = "Notes"; break;
                         case SHT_NOBITS    :type = "Program space with no data (bss)"; break;
                         case SHT_REL    :type = "Relocation entries, no addends"; break;
                         case SHT_SHLIB	 :		type = "Reserved"; break;
                         case SHT_DYNSYM	  :		type = "Dynamic linker symbol table"; break;
                         case SHT_INIT_ARRAY	  :		type = "Array of constructors"; break;
                         case SHT_FINI_ARRAY	  :		type = "Array of destructors"; break;
                         case SHT_PREINIT_ARRAY :		type = "Array of pre-constructors"; break;
                         case SHT_GROUP	  :		type = "Section group"; break;
                         case SHT_SYMTAB_SHNDX  :		type = "Extended section indeces"; break;
                         case SHT_NUM		  :		type = "Number of defined types. "; break;
                         case SHT_LOOS	  :	type = "Start OS-specific. "; break;
                         case SHT_LOSUNW	  :	type = "Sun-specific low bound. "; break;
                         case SHT_SUNW_COMDAT  : type = " "; break;
                         case SHT_SUNW_syminfo  : type = " "; break;
                         case SHT_GNU_verdef	  :	type = "Version definition section. "; break;
                         case SHT_GNU_verneed	  :	type = "Version needs section. "; break;
                         case SHT_GNU_versym	  :	type = "Version symbol table. "; break;
                         case SHT_LOPROC	  :	type = "Start of processor-specific"; break;
                         case SHT_HIPROC	 :	type = "End of processor-specific"; break;
                         case SHT_HIUSER	 :	type = "End of application-specific"; break;
                         }
                     }
                 }
                 return type;
             }
             bool elfparser::isElf(const QString &File)
             {
                 int file =0;
             #ifdef _ELF_WINDOWS_
                 file = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
             #else
                 file = open(File.toStdString().c_str(),O_RDONLY ,0);
             #endif
                 char Magic[4];
                 if(file!=-1)
                 {
                     read(file,Magic,4);
                     close(file);
                     if(Magic[0]==0x7f && Magic[1]==0x45 && Magic[2]==0x4c && Magic[3]==0x46)
                     {
                         return true;
                     }
                 }
                 return false;
             }

src/common/elf/elfparser.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2013, 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 3 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef ELFPARSER_H
             #define ELFPARSER_H
             #include <libelf.h>
             #include <gelf.h>
             #include <QString>
             #include <stdio.h>
             #include <QList>
             #include <stdint.h>
             class Elf_Section
             {
             public:
                 Elf_Section(){}
                 Elf_Section(Elf_Data*  data,GElf_Shdr* section_header)
                 {
                     this->data = data;
                     this->section_header = section_header;
                 }
                 Elf_Data*  data;
                 GElf_Shdr* section_header;
             };
             class elfparser
             {
             public:
                 elfparser();
                 bool iself();
                 bool isopened();
                 int setFilename(const QString& name);
                 int closeFile();
                 QString getArchitecture();
                 QString getType();
                 int32_t getVersion();
                 int getSectioncount();
                 int getSegmentcount();
                 QString getSegmentType(int index);
                 int64_t getSegmentOffset(int index);
                 int64_t getSegmentVaddr(int index);
                 int64_t getSegmentPaddr(int index);
                 int64_t getSectionPaddr(int index);
                 int64_t getSegmentFilesz(int index);
                 int64_t getSectionDatasz(int index);
                 bool getSectionData(int index, char **buffer);
                 int64_t getSegmentMemsz(int index);
                 int64_t getSectionMemsz(int index);
                 QString getSegmentFlags(int index);
                 QString getSectionName(int index);
                 QString getSectionType(int index);
                 static bool isElf(const QString& File);
             private:
                 void updateSections();
                 void updateSegments();
                 int elfFile;
                 bool opened;
                 bool type_elf;
                 Elf* e;
                 Elf_Kind ek;
                 GElf_Ehdr ehdr;
                 Elf_Scn * scn;
                 Elf_Data * data;
                 size_t SectionCount,SegmentCount, shstrndx;
                 QList<GElf_Phdr*> Segments;
                 //QList<GElf_Shdr*> Sections;
                 QList<Elf_Section*> sections;
             };
             #endif // ELFPARSER_H

src/common/memsizewdgt.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef MEMSIZEWDGT_H
             #define MEMSIZEWDGT_H
             #include <QWidget>
             #include <QLineEdit>
             #include <QComboBox>
             #include <QHBoxLayout>
             class MemSizeWdgt : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MemSizeWdgt(QWidget *parent = 0);
                 MemSizeWdgt(int defaultSize,QWidget *parent = 0);
                 int getsize();
                 void setMaximum(unsigned int max);
                 void updateSizeValue();
                 void show();
             signals:
             public slots:
                 void setSizeValue(int size);
             private slots:
                 void setSizeValue();
                 void setSizeValue(QString size);
             private:
                 QHBoxLayout* mainLayout;
                 QLineEdit* sizeValue;
                 QComboBox* sizeUnit;
                 unsigned int maximum;
             };
             #endif // MEMSIZEWDGT_H

src/common/qhexspinbox.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef QHEXSPINBOX_H
             #define QHEXSPINBOX_H
             #include <QSpinBox>
             #include <QWidget>
             #include <QString>
             #include <QValidator>
             class QHexSpinBox : public QSpinBox
             {
             Q_OBJECT
             public:
                 explicit QHexSpinBox(QWidget *parent = 0);
                 QString textFromValue ( int value ) const;
                 int valueFromText ( const QString & text ) const ;
                 QValidator::State validate(QString &input, int &pos) const
                 {
                     Q_UNUSED(pos)
                     bool ok;
                     input.toUInt( &ok, 16 );
                     if(ok)
                         return QValidator::Acceptable;
                     else
                         return QValidator::Invalid;
                 }
                 void show();
             signals:
             public slots:
             };
             #endif // QHEXSPINBOX_H

src/common/qipdialogbox.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2014, 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 : Paul Leroy
             --                     Mail : paul.leroy@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "qipdialogbox.h"
             #include <QSpinBox>
             #include <QHBoxLayout>
             #include <QVBoxLayout>
             #include <QLabel>
             #include <QString>
             #include <QLocale>
             QIPDialogBox::QIPDialogBox(QWidget *parent) :
                 QWidget(parent)
             {
                 QHBoxLayout *addressLayout = new QHBoxLayout;
                 QVBoxLayout *mainLayout = new QVBoxLayout;
                 addressPart1 = new QSpinBox;
                 addressPart2 = new QSpinBox;
                 addressPart3 = new QSpinBox;
                 addressPart4 = new QSpinBox;
                 addressPart1->setRange(0, 255);
                 addressPart1->setValue(129);
                 addressPart1->setButtonSymbols(QAbstractSpinBox::NoButtons);
                 addressPart2->setRange(0, 255);
                 addressPart2->setValue(104);
                 addressPart2->setButtonSymbols(QAbstractSpinBox::NoButtons);
                 addressPart3->setRange(0, 255);
                 addressPart3->setValue(27);
                 addressPart3->setButtonSymbols(QAbstractSpinBox::NoButtons);
                 addressPart4->setRange(0, 255);
                 addressPart4->setValue(113);
                 addressPart4->setButtonSymbols(QAbstractSpinBox::NoButtons);
                 valueChanged();
                 connect(addressPart1, SIGNAL(valueChanged(int)), this, SLOT(valueChanged()));
                 connect(addressPart2, SIGNAL(valueChanged(int)), this, SLOT(valueChanged()));
                 connect(addressPart3, SIGNAL(valueChanged(int)), this, SLOT(valueChanged()));
                 connect(addressPart4, SIGNAL(valueChanged(int)), this, SLOT(valueChanged()));
                 addressLayout->addWidget(addressPart1);
                 addressLayout->addWidget(addressPart2);
                 addressLayout->addWidget(addressPart3);
                 addressLayout->addWidget(addressPart4);
                 mainLayout->addLayout(addressLayout);
                 //mainLayout->addWidget(labelGRESBIP);
                 setLayout(mainLayout);
             }
             void QIPDialogBox::valueChanged() // SLOT
             {
                 gresbIP = addressPart1->cleanText();
                 gresbIP.append(".");
                 gresbIP.append(addressPart2->cleanText());
                 gresbIP.append(".");
                 gresbIP.append(addressPart3->cleanText());
                 gresbIP.append(".");
                 gresbIP.append(addressPart4->cleanText());
             }
             QString QIPDialogBox::getIP()
             {
                 return(gresbIP);
             }
             void QIPDialogBox::setIP(unsigned char address1, unsigned char address2, unsigned char address3, unsigned char address4)
             {
                 addressPart1->setValue(address1);
                 addressPart2->setValue(address2);
                 addressPart3->setValue(address3);
                 addressPart4->setValue(address4);
                 addressPart1->repaint();
                 addressPart2->repaint();
                 addressPart3->repaint();
                 addressPart4->repaint();
             }
             unsigned char QIPDialogBox::get_addressPart1()
             {
                 return (unsigned char) addressPart1->value();
             }
             unsigned char QIPDialogBox::get_addressPart2()
             {
                 return (unsigned char) addressPart2->value();
             }
             unsigned char QIPDialogBox::get_addressPart3()
             {
                 return (unsigned char) addressPart3->value();
             }
             unsigned char QIPDialogBox::get_addressPart4()
             {
                 return (unsigned char) addressPart4->value();
             }

src/common/qipdialogbox.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2014, 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 : Paul Leroy
             --                     Mail : paul.leroy@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef WIDGETADDRESS_H
             #define WIDGETADDRESS_H
             #include <QWidget>
             #include <QSpinBox>
             #include <QString>
             #include <QLabel>
             class QIPDialogBox : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit QIPDialogBox(QWidget *parent = 0);
                 void setIP(unsigned char address1, unsigned char address2, unsigned char address3, unsigned char address4);
             signals:
             public slots:
                 void valueChanged();
                 QString getIP();
                 unsigned char get_addressPart1();
                 unsigned char get_addressPart2();
                 unsigned char get_addressPart3();
                 unsigned char get_addressPart4();
             private:
                 QSpinBox *addressPart1;
                 QSpinBox *addressPart2;
                 QSpinBox *addressPart3;
                 QSpinBox *addressPart4;
                 QString gresbIP;
             };
             #endif // WIDGETADDRESS_H

src/common/qsvgicon.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef QSVGICON_H
             #define QSVGICON_H
             #include <QIcon>
             #include <QSvgRenderer>
             #include <QImage>
             #include <QPainter>
             class QSvgIcon : public QIcon
             {
             public:
                 QSvgIcon();
                 QSvgIcon(const QString& fileName);
                 void addFile ( const QString & fileName, const QSize & size = QSize(), Mode mode = Normal, State state = Off );
             };
             #endif // QSVGICON_H

src/dockablepluginmanager.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef DOCKABLEPLUGINMANAGER_H
             #define DOCKABLEPLUGINMANAGER_H
             #include <QDockWidget>
             #include "pluginmanagerWDGT.h"
             class dockablePluginManager : public QDockWidget
             {
                 Q_OBJECT
             public:
                 explicit dockablePluginManager(QWidget *parent = 0);
                 void  setRootLoadable(bool flag);
             signals:
                 void loadSysDrviver(const QString name);
                 void loadSysDriverToParent(const QString name, const QString instanceName);
                 void geteplugintree(void);
                 void treeChanged(const QList<socexplorerplugin*>& drivers);
                 void changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName);
                 void closeSysDriver(const QString instanceName);
                 void pluginselected(const QString& instanceName);
             public slots:
             private:
                 pluginmanagerWDGT* managerGui;
             };
             #endif // DOCKABLEPLUGINMANAGER_H

src/main.cpp +11 -3

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include <QApplication>
             #include "mainwindow.h"
             #include <PythonQt.h>
             #include <PythonQt_QtAll.h>
             #include <gui/PythonQtScriptingConsole.h>
             #include <socexplorerplugin.h>
             #include <QStyle>
             #include <QStyleFactory>
             #include <QStringList>
             #include <QFile>
             int main(int argc, char *argv[])
             {
                // Q_INIT_RESOURCE(socexplorer);
             #ifdef Q_OS_LINUX
              //   QApplication::setGraphicsSystem("raster");
             #endif
                 QApplication a(argc, argv);
                 QString scriptToEval;
                 QStringList args= a.arguments();
                 for(int i=0;i<args.count()-1;i++)
                 {
-                    if((args.at(i).compare("&")==0) || (args.at(i).compare("--execute")==0))
+                    if((args.at(i).compare("-e")==0) || (args.at(i).compare("--execute")==0))
                     {
                         scriptToEval = args.at(i+1);
                         if(!QFile::exists(scriptToEval))
                         {
                             scriptToEval.clear();
                         }
                         else
                             qDebug() << "Will execute" << scriptToEval;
                         break;
                     }
+                    if((args.at(i).compare("-d")==0) || (args.at(i).compare("--debug-level")==0))
+                    {
+                        bool success;
+                        int lvl;
+                        lvl = args.at(i+1).toInt(&success,10);
+                        if(success)
+                            SocExplorerEngine::setLogLevel(lvl);
+                    }
                 }
-                LPMONMainWindow w(scriptToEval);
+                SocExplorerMainWindow w(scriptToEval);
                 w.show();
                 return a.exec();
             }

src/mainwindow.cpp +17 -17

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "mainwindow.h"
             #include <QDockWidget>
-            LPMONMainWindow::LPMONMainWindow(QString ScriptToEval, QWidget *parent)
+            SocExplorerMainWindow::SocExplorerMainWindow(QString ScriptToEval, QWidget *parent)
                 : QMainWindow(parent)
             {
                 QCoreApplication::setApplicationName("SocExplorer");
                 QCoreApplication::setOrganizationName("LPP");
                 QCoreApplication::setOrganizationDomain("lpp.fr");
                 this->makeObjects(ScriptToEval);
                 this->makeLayout();
                 this->makeMenu();
                 this->makeConnections();
                 this->setWindowIcon(QIcon(tr(":/images/logolppcutted.png")));
                 this->setAcceptDrops(true);
                 this->pluginManager->setRootLoadable(true);
                 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
             }
-            void LPMONMainWindow::makeObjects(QString ScriptToEval)
+            void SocExplorerMainWindow::makeObjects(QString ScriptToEval)
             {
                 Q_UNUSED(ScriptToEval)
                 this->p_pluginGUIlist = new QList<QDockWidget*>();
                 pluginsDockContainer = new QMainWindow;
                 pluginsDockContainer->setWindowFlags(Qt::Widget);
                 pluginsDockContainer->setDockNestingEnabled(true);
                 this->mainWidget = new QSplitter(Qt::Vertical);
                 this->appTranslator = new QTranslator;
                 this->Quit = new QAction(tr("&Quit"),this);
                 this->Quit->setShortcut(tr("CTRL+Q"));
                 this->ManagePlugins = new QAction(tr("&Manage Plugins"),this);
                 this->ManagePlugins->setShortcut(tr("CTRL+P"));
                 this->regsManager = new QAction(tr("&Manage registers"),this);
                 this->exploreRegs = new QAction(tr("&Explore registers"),this);
                 this->help = new QAction(tr("&Help"),this);
                 this->help->setShortcut(tr("CTRL+H"));
                 this->about = new QAction(tr("&About"),this);
                 socexplorerproxy::setMainWindow(this);
                 SocExplorerEngine::setMainWindow(this);
                 SocExplorerEngine::xmlModel()->scanXmlFiles();
                 this->regExplorer = new regsExplorer();
                 this->regExplorer->setAllowedAreas(Qt::AllDockWidgetAreas);
                 this->addPluginInterface(this->regExplorer);
                 this->PythonConsoleInst = new PythonConsole(socexplorerproxy::self());
                 this->PythonConsoleInst->addObject("SocExplorerEngine",SocExplorerEngine::self());
                 this->pluginManager = new dockablePluginManager();
                 this->toolpane = new toolBar;
                 this->p_about = new aboutsocexplorer();
             }
-            void LPMONMainWindow::makeLayout()
+            void SocExplorerMainWindow::makeLayout()
             {
                 this->mainWidget->addWidget(pluginsDockContainer);
                 this->mainWidget->addWidget(this->PythonConsoleInst);
                 this->toolpane->setAllowedAreas(Qt::RightDockWidgetArea|Qt::LeftDockWidgetArea);
                 this->addDockWidget(Qt::LeftDockWidgetArea,this->toolpane);
                 this->toolpane->addTool(this->pluginManager);
                 this->setCentralWidget(this->mainWidget);
             }
-            void LPMONMainWindow::makeConnections()
+            void SocExplorerMainWindow::makeConnections()
             {
                 connect(socexplorerproxy::self(),SIGNAL(clearMenu()),this,SLOT(clearMenu()));
                 connect(this,SIGNAL(translateSig()),socexplorerproxy::self(),SLOT(updateText()));
                 connect(socexplorerproxy::self(),SIGNAL(addPluginGUI(QDockWidget*)),this,SLOT(addPluginInterface(QDockWidget*)));
                 connect(socexplorerproxy::self(),SIGNAL(removePluginGUI(QDockWidget*)),this,SLOT(removePluginInterface(QDockWidget*)));
                 connect(this->ManagePlugins,SIGNAL(triggered()),this,SLOT(launchPluginManager()));
                 connect(this->Quit,SIGNAL(triggered()),qApp,SLOT(quit()));
                 connect(this,SIGNAL(registerObject(QObject*,QString)),this->PythonConsoleInst,SLOT(registerObject(QObject*,QString)));
                 connect(socexplorerproxy::self(),SIGNAL(registerObject(QObject*,QString)),this,SIGNAL(registerObject(QObject*,QString)));
                 connect(this->pluginManager,SIGNAL(geteplugintree()),socexplorerproxy::self(),SLOT(geteplugintree()));
                 connect(socexplorerproxy::self(),SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->pluginManager,SIGNAL(treeChanged(QList<socexplorerplugin*>)));
                 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),socexplorerproxy::self(),SLOT(changeSysDriverInstName(QString,QString)));
                 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),this->PythonConsoleInst,SLOT(changeSysDriverInstName(QString,QString)));
                 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),socexplorerproxy::self(),SLOT(closeSysDriver(QString)));
                 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),this->PythonConsoleInst,SLOT(removeDriver(QString)));
                 connect(this->pluginManager,SIGNAL(pluginselected(QString)),this,SLOT(pluginselected(QString)));
                 connect(this->about,SIGNAL(triggered()),this,SLOT(showAboutBox()));
                 connect(this->exploreRegs,SIGNAL(triggered()),this->regExplorer,SLOT(show()));
                 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDrviver(QString)),socexplorerproxy::self(),SLOT(loadSysDriver(QString)));
                 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDriverToParent(QString,QString)),socexplorerproxy::self(),SLOT(loadSysDriverToParent(QString,QString)));
             }
-            void LPMONMainWindow::launchPluginManager()
+            void SocExplorerMainWindow::launchPluginManager()
             {
                 if(this->pluginManager->isHidden())
                 {
                     this->pluginManager->setHidden(false);
                 }
             }
-            void LPMONMainWindow::addPluginInterface(QDockWidget *plugin)
+            void SocExplorerMainWindow::addPluginInterface(QDockWidget *plugin)
             {
                 plugin->setAllowedAreas(Qt::AllDockWidgetAreas);
                 this->pluginsDockContainer->addDockWidget(Qt::TopDockWidgetArea,plugin);
                 if(p_pluginGUIlist->count()!=0)
                     this->pluginsDockContainer->tabifyDockWidget(p_pluginGUIlist->last(),plugin);
                 p_pluginGUIlist->append(plugin);
             }
-            void LPMONMainWindow::removePluginInterface(QDockWidget *plugin)
+            void SocExplorerMainWindow::removePluginInterface(QDockWidget *plugin)
             {
                 p_pluginGUIlist->removeOne(plugin);
                 this->pluginsDockContainer->removeDockWidget(plugin);
             }
-            void LPMONMainWindow::clearMenu()
+            void SocExplorerMainWindow::clearMenu()
             {
                 this->menuBar()->clear();
                 this->makeMenu();
             }
-            void LPMONMainWindow::makeMenu()
+            void SocExplorerMainWindow::makeMenu()
             {
                 this->FileMenu = menuBar()->addMenu(tr("&File"));
                 this->PluginsMenu = menuBar()->addMenu(tr("&Plugins"));
                 this->ToolsMenu = menuBar()->addMenu(tr("&Tools"));
                 this->ToolsMenu->addAction(this->exploreRegs);
                 this->FileMenu->addAction(this->Quit);
                 socexplorerproxy::self()->makeMenu(this->PluginsMenu);
                 this->PluginsMenu->addAction(this->ManagePlugins);
                 this->helpMenu = menuBar()->addMenu(tr("Help"));
                 this->helpMenu->addAction(this->help);
                 this->helpMenu->addAction(this->about);
             }
-            LPMONMainWindow::~LPMONMainWindow()
+            SocExplorerMainWindow::~SocExplorerMainWindow()
             {
                 delete this->p_about;
                 delete this->p_pluginGUIlist;
             }
-            void LPMONMainWindow::setLangage(QAction *action)
+            void SocExplorerMainWindow::setLangage(QAction *action)
             {
                 QString local = action->data().toString();
                 QString qmPath = QDir(QString("translations")).absolutePath();
                 appTranslator->load(qmPath+"/socexplorer_"+local+".qm");
                 qApp->installTranslator(appTranslator);
                 emit this->translateSig();
             }
-            void LPMONMainWindow::createLangMenu()
+            void SocExplorerMainWindow::createLangMenu()
             {
                 this->langMenu = menuBar()->addMenu(tr("&Langue"));
                 this->langActionGrp = new QActionGroup(this);
                 connect(this->langActionGrp,SIGNAL(triggered(QAction*)),this,SLOT(setLangage(QAction*)));
                 QDir* qmDir = new QDir(QString("translations"));
                 QStringList LangFiles = qmDir->entryList(QStringList("socexplorer_*.qm"));
                 for(int i=0;i<LangFiles.size();++i)
                 {
                     QString Local = LangFiles[i];
                     Local.remove(0,Local.indexOf('_')+1);
                     Local.chop(3);
                     QTranslator translator;
                     translator.load(LangFiles[i],qmDir->absolutePath());
                     QString langage = translator.translate("MainWindow","English");
                     QAction *action = new QAction(tr("&%1 %2").arg(i+1).arg(langage),this);
                     action->setCheckable(true);
                     action->setData(Local);
                     langMenu->addAction(action);
                     langActionGrp->addAction(action);
                     if(langage==tr("English"))
                         action->setChecked(true);
                 }
             }
-            void LPMONMainWindow::updateText()
+            void SocExplorerMainWindow::updateText()
             {
                 emit this->translateSig();
             }
-            void LPMONMainWindow::showAboutBox()
+            void SocExplorerMainWindow::showAboutBox()
             {
                 p_about->show();
             }
-            void LPMONMainWindow::pluginselected(const QString &instanceName)
+            void SocExplorerMainWindow::pluginselected(const QString &instanceName)
             {
                 socexplorerplugin* drv=socexplorerproxy::self()->getSysDriver(instanceName);
                 if(drv)
                     drv->raise();
             }
-            void LPMONMainWindow::closeEvent(QCloseEvent *event)
+            void SocExplorerMainWindow::closeEvent(QCloseEvent *event)
             {
                 socexplorerproxy::self()->close();
                 qApp->closeAllWindows();
                 event->accept();
             }

src/mainwindow.h +4 -4

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef MAINWINDOW_H
             #define MAINWINDOW_H
             #include <QMainWindow>
             #include <QApplication>
             #include <QVBoxLayout>
             #include <QIcon>
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QDockWidget>
             #include <QTranslator>
             #include <QSplitter>
             #include "dockablepluginmanager.h"
             #include <socexplorerproxy.h>
             #include "PyWdgt/pythonconsole.h"
             #include "aboutsocexplorer.h"
             #include "toolbar.h"
             #include "regsExplorer/regsexplorer.h"
-            class LPMONMainWindow : public QMainWindow
+            class SocExplorerMainWindow : public QMainWindow
             {
                 Q_OBJECT
             public:
-                LPMONMainWindow(QString ScriptToEval,QWidget *parent = 0);
+                SocExplorerMainWindow(QString ScriptToEval,QWidget *parent = 0);
-                ~LPMONMainWindow();
+                ~SocExplorerMainWindow();
                 QAction* Quit,*LoadPlugin,*ManagePlugins,*help,*regsManager,*exploreRegs,*about,*translateAction;
                 QActionGroup*langActionGrp;
                 QMenu* FileMenu,*PluginsMenu,*ToolsMenu,*langMenu,*helpMenu;
                 QTranslator* appTranslator;
                 void createLangMenu();
                 void closeEvent(QCloseEvent *event);
                 toolBar* toolpane;
             public slots:
                 void launchPluginManager();
                 void addPluginInterface(QDockWidget* plugin);
                 void removePluginInterface(QDockWidget* plugin);
                 void clearMenu();
                 void updateText();
                 void setLangage(QAction* action);
                 void showAboutBox();
                 void pluginselected(const QString& instanceName);
             signals:
                 void translateSig();
                 void registerObject(QObject* object,const QString& instanceName);
             private:
                 void makeObjects(QString ScriptToEval);
                 void makeLayout();
                 void makeConnections();
                 void makeMenu();
                 QMainWindow* pluginsDockContainer;
                 QSplitter* mainWidget;
                 PythonConsole* PythonConsoleInst;
                 dockablePluginManager* pluginManager;
                 regsExplorer* regExplorer;
                 aboutsocexplorer* p_about;
                 QList<QDockWidget*>* p_pluginGUIlist;
             };
             #endif // MAINWINDOW_H

src/regsExplorer/regsexplorer.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef REGSEXPLORER_H
             #define REGSEXPLORER_H
             #include <QWidget>
             #include <QTabWidget>
             #include <QDockWidget>
             #include "regsexplorercfg.h"
             #include "regsviewer.h"
             #include <QGridLayout>
             #include <socexplorerengine.h>
             #include <peripheralwidget.h>
             #include <socregsviewer.h>
             class regsExplorer : public QDockWidget
             {
                 Q_OBJECT
             public:
                 explicit regsExplorer(QWidget *parent = 0);
             signals:
             public slots:
                 void addDev(socExplorerEnumDevice* device);
             private:
                 QTabWidget* mainWidget;
                 regsExplorerCfg* cfg;
                 socRegsViewer* socViewer;
             };
             #endif // REGSEXPLORER_H

src/regsExplorer/regsviewer.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef REGSVIEWER_H
             #define REGSVIEWER_H
             #include <QWidget>
             #include <QScrollArea>
             class regsViewer : public QScrollArea
             {
                 Q_OBJECT
             public:
                 explicit regsViewer(QWidget *parent = 0);
             signals:
             public slots:
             };
             #endif // REGSVIEWER_H

src/socexplorer.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2013, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef SOCEXPLORER_H
             #define SOCEXPLORER_H
             #ifdef WIN32
             #ifdef SOCEXPLORER_EXPORTS
             #define SOCEXPLORER_EXPORT __declspec(dllexport)
             #else
             #define SOCEXPLORER_EXPORT __declspec(dllimport)
             #endif
             #else
             #define SOCEXPLORER_EXPORT
             #endif
             #ifdef WIN32
             #include <stdlib.h>
             #define socexplorerBswap32(X) _byteswap_ulong(X)
             #else
             #ifdef UNIX
             #include <byteswap.h>
             #define socexplorerBswap32(X) bswap_32(X)
             #endif
             #endif
             #ifdef WIN32
                 #define SOCEXPLORER_PLUGINS_INSTALL_PATH qApp->applicationDirPath()+"/plugins"
                 #define SOCEXPLORER_CONFIG_PATH qApp->applicationDirPath()+"/config"
                 #define PYMODULES qApp->applicationDirPath()+"/python"
             #else
                 #ifdef UNIX
                     #define SOCEXPLORER_PLUGINS_INSTALL_PATH QDir::homePath()+"/.SocExplorer/plugins"
                     #define SOCEXPLORER_CONFIG_PATH QDir::homePath()+"/.SocExplorer/config"
                     #define PYMODULES "/etc/SocExplorer/python"
                 #endif
             #endif
             #endif // SOCEXPLORER_H

src/toolbar.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2012, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef TOOLBAR_H
             #define TOOLBAR_H
             #include <QDockWidget>
             #include "toolbarcontainer.h"
             class toolBar : public QDockWidget
             {
                 Q_OBJECT
             public:
                 explicit toolBar(QWidget *parent = 0);
             signals:
             public slots:
                 void addTool(QDockWidget* widget);
             private:
                 toolBarContainer* toolsContainer;
             };
             #endif // TOOLBAR_H

src/toolbarcontainer.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2012, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef TOOLBARCONTAINER_H
             #define TOOLBARCONTAINER_H
             #include <QMainWindow>
             class toolBarContainer : public QMainWindow
             {
                 Q_OBJECT
             public:
                 explicit toolBarContainer(QWidget *parent = 0);
             signals:
             public slots:
             };
             #endif // TOOLBARCONTAINER_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