HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r94:9652b437323f

Session manager almost complete.

Jeandet Alexis -

r94:9652b437323f default

parent child

Context file:

r94:9652b437323f

Collapse all files

src/SocExplorerEngine/engine/socexplorersettings.cpp +53 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  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 "socexplorersettings.h"
             SocExplorerSettings* SocExplorerSettings::_self=NULL;
             QSettings* SocExplorerSettings::m_settings=NULL;
             QSettings* SocExplorerSettings::m_sessionSettings=NULL;
             SocExplorerSettingsDialog* SocExplorerSettings::m_configDialog = NULL;
             #include <socexplorergui.h>
             #include <QFile>
             #include <QFileInfo>
             #include <QDir>
             #include <QDebug>
             #define INIT() \
                 if(Q_UNLIKELY(_self==NULL))\
             {\
                 init();\
                 }
             SocExplorerSettings::SocExplorerSettings(QObject *parent) : QObject(parent)
             {
                 m_settings = new QSettings();
                 m_configDialog = new SocExplorerSettingsDialog();
                 QAction* trigerGUI = new QAction(tr("Settings"),this);
                 connect(trigerGUI,SIGNAL(triggered()),this,SLOT(popConfigDialog()));
                 SocExplorerGUI::addSettingsAction(trigerGUI);
             }
             SocExplorerSettings::~SocExplorerSettings()
             {
                 if(m_settings)
                 {
                     m_settings->sync();
                     delete m_settings;
                 }
                 if(m_sessionSettings)
                 {
                     m_sessionSettings->sync();
                     delete m_sessionSettings;
                 }
             }
             void SocExplorerSettings::init()
             {
                 if(!_self)
                 {
                     _self= new SocExplorerSettings();
                 }
             }
             void SocExplorerSettings::setValue(QObject *object, const QString &key, const QVariant &value, SettingScope Sscope)
             {
                 INIT();
                 setValue(object->metaObject()->className(),key,value,Sscope);
             }
             QVariant SocExplorerSettings::value(QObject *object, const QString &key, const QVariant &defaultValue, SettingScope Sscope)
             {
                 INIT();
                 return value(object->metaObject()->className(),key,defaultValue,Sscope);
             }
             void SocExplorerSettings::setValue(const QString scope, const QString &key, const QVariant &value, SettingScope Sscope)
             {
                 INIT();
                 switch (Sscope)
                 {
                 case SystemWide:
                     if(m_settings)
                         m_settings->setValue(scope+"/"+key,value);
                     break;
                 case Session:
                     if(m_sessionSettings)
                         m_sessionSettings->setValue(scope+"/"+key,value);
                     break;
                 default:
                     break;
                 }
             }
             QVariant SocExplorerSettings::value(const QString scope, const QString &key, const QVariant &defaultValue, SettingScope Sscope)
             {
                 INIT();
                 switch (Sscope)
                 {
                 case SystemWide:
                     if(m_settings)
                         return m_settings->value(scope+"/"+key,defaultValue);
                     break;
                 case Session:
                     if(m_sessionSettings)
                         return m_sessionSettings->value(scope+"/"+key,defaultValue);
                     break;
                 default:
                     break;
                 }
                 return defaultValue;
             }
             QList<QList<QVariant> > SocExplorerSettings::arrays(const QString &prefix, QStringList keys, SocExplorerSettings::SettingScope Sscope)
             {
                 INIT();
                 QList<QList<QVariant> > defaultValue;
                 switch (Sscope)
                 {
                 case SystemWide:
                     if(m_settings)
                         return arrays(prefix,keys,m_settings);
                     break;
                 case Session:
                     if(m_sessionSettings)
                         return arrays(prefix,keys,m_sessionSettings);
                     break;
                 default:
                     break;
                 }
                 return defaultValue;
             }
             void SocExplorerSettings::setArrays(const QString &prefix, QStringList keys, QList<QList<QVariant> > values, SocExplorerSettings::SettingScope Sscope)
             {
                 INIT();
                 switch (Sscope)
                 {
                 case SystemWide:
                     if(m_settings)
                         return setArrays(prefix,keys,values,m_settings);
                     break;
                 case Session:
                     if(m_sessionSettings)
                         return setArrays(prefix,keys,values,m_sessionSettings);
                     break;
                 default:
                     break;
                 }
             }
             void SocExplorerSettings::sync()
             {
                 INIT();
                 if(m_settings)
                 {
                     m_settings->sync();
                 }
                 if(m_sessionSettings)
                 {
                     m_sessionSettings->sync();
                 }
             }
             bool SocExplorerSettings::registerConfigEntry(SocExplorerSettingsItem *configEntry, QIcon icon, QString text)
             {
                 INIT();
                 return m_configDialog->registerConfigEntry(configEntry,icon,text);
             }
             bool SocExplorerSettings::loadSession(const QString &session)
             {
                 INIT();
                 QFileInfo sessionInfo(m_settings->fileName());
                 QString fullpath=sessionInfo.absoluteDir().absolutePath() +"/"+session+".conf";
                 if(m_sessionSettings)
                 {
                     delete m_sessionSettings;
                     m_sessionSettings = NULL;
                 }
                 m_sessionSettings = new QSettings(fullpath,QSettings::NativeFormat,self());
                 qDebug()<< m_sessionSettings->fileName();
                 if(m_sessionSettings->status()==QSettings::NoError)
                 {
                     return true;
                 }
                 delete m_sessionSettings;
                 m_sessionSettings = NULL;
                 return false;
             }
+            bool SocExplorerSettings::deleteSession()
+            {
+                INIT();
+                if(m_sessionSettings)
+                {
+                    m_sessionSettings->clear();
+                    QString filename= m_sessionSettings->fileName();
+                    if(QFile::exists(filename))
+                    {
+                        delete m_sessionSettings;
+                        QFile::remove(filename);
+                    }
+                    else
+                        delete m_sessionSettings;
+                    m_sessionSettings = NULL;
+                    return true;
+                }
+                return false;
+            }
+            bool SocExplorerSettings::deleteSession(const QString &session)
+            {
+                QFileInfo sessionInfo(m_settings->fileName());
+                QString fullpath=sessionInfo.absoluteDir().absolutePath() +"/"+session+".conf";
+                if(m_sessionSettings)
+                {
+                    if(m_sessionSettings->fileName()==fullpath)
+                    {
+                        deleteSession();
+                        return true;
+                    }
+                }
+                QSettings* sessionSettings = new QSettings(fullpath,QSettings::NativeFormat,self());
+                if(sessionSettings)
+                {
+                    if(sessionSettings->status()==QSettings::NoError)
+                    {
+                            sessionSettings->clear();
+                            QString filename= m_sessionSettings->fileName();
+                            if(QFile::exists(filename))
+                            {
+                                delete sessionSettings;
+                                QFile::remove(filename);
+                            }
+                            else
+                                delete sessionSettings;
+                            return true;
+                    }
+                    delete sessionSettings;
+                }
+                return false;
+            }
             void SocExplorerSettings::popConfigDialog()
             {
                 m_configDialog->popConfigDialog(NULL);
             }
             QList<QList<QVariant> > SocExplorerSettings::arrays(const QString &prefix, QStringList keys, QSettings *settings)
             {
                 QList<QList<QVariant> > result;
                 if(settings)
                 {
                     int size = settings->beginReadArray(prefix);
                     for (int i = 0; i < size; ++i)
                     {
                         result.append(QList<QVariant>());
                         settings->setArrayIndex(i);
                         for(int l=0;l<keys.count();l++)
                         {
                             result[i].append(settings->value(keys.at(l)));
                         }
                     }
                     settings->endArray();
                 }
                 return result;
             }
             void SocExplorerSettings::setArrays(const QString &prefix, QStringList keys, QList<QList<QVariant> > values, QSettings *settings)
             {
                 if(settings)
                 {
                     QString key;
                     foreach (key, keys)
                     {
                         settings->remove(prefix+"/"+key);
                     }
                     settings->beginWriteArray(prefix);
                     for (int i = 0; i < values.size(); ++i)
                     {
                         settings->setArrayIndex(i);
                         for(int l=0;l<keys.count();l++)
                         {
                             settings->setValue(keys[l], values.at(i).at(l));
                         }
                     }
                     settings->endArray();
                 }
             }

src/SocExplorerEngine/engine/socexplorersettings.h +2 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  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 SOCEXPLORERSETTINGS_H
             #define SOCEXPLORERSETTINGS_H
             #include <QObject>
             #include <QWidget>
             #include <QSettings>
             #include <socexplorersettingsdialog.h>
             class SocExplorerSettings : public QObject
             {
                 Q_OBJECT
             private:
                 static SocExplorerSettings* _self;
                 static QSettings* m_settings;
                 static QSettings* m_sessionSettings;
                 static SocExplorerSettingsDialog* m_configDialog;
                 SocExplorerSettings(QObject *parent = 0);
                 ~SocExplorerSettings();
             public:
                 enum SettingScope {
                     SystemWide = 0,
                     Session
                 };
                 static void init();
                 static SocExplorerSettings* self(){ if(!_self){_self= new SocExplorerSettings;}return _self;}
                 static void	setValue(QObject* object,const QString & key, const QVariant & value,SettingScope Sscope =SystemWide);
                 static QVariant	value(QObject* object, const QString & key, const QVariant & defaultValue = QVariant(),SettingScope Sscope=SystemWide);
                 static void	setValue(const QString scope,const QString & key, const QVariant & value,SettingScope Sscope= SystemWide);
                 static QVariant	value(const QString scope, const QString & key, const QVariant & defaultValue = QVariant(),SettingScope Sscope =SystemWide);
                 static QList<QList<QVariant> > arrays(const QString & prefix, QStringList keys,SettingScope Sscope =SystemWide);
                 static void setArrays(const QString & prefix, QStringList keys,QList<QList<QVariant> > values,SettingScope Sscope =SystemWide);
                 static void sync();
                 static bool registerConfigEntry(SocExplorerSettingsItem* configEntry,QIcon icon, QString text);
                 //! Loads the given session, or sreate it if doesn't exists.
                 //! \param session Session name.
                 //! \return true if success or false if fails to create session config file.
                 static bool loadSession(const QString& session);
+                static bool deleteSession();
+                static bool deleteSession(const QString& session);
             signals:
             public slots:
                 void popConfigDialog();
             private:
                 static QList<QList<QVariant> > arrays(const QString & prefix, QStringList keys,QSettings* settings);
                 static void setArrays(const QString & prefix, QStringList keys,QList<QList<QVariant> > values,QSettings* settings);
             };
             #endif // SOCEXPLORERSETTINGS_H

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

             /*------------------------------------------------------------------------------
             ███████╗ ██████╗  ██████╗    ███████╗██╗  ██╗██████╗ ██╗      ██████╗ ██████╗ ███████╗██████╗
             ██╔════╝██╔═══██╗██╔════╝    ██╔════╝╚██╗██╔╝██╔══██╗██║     ██╔═══██╗██╔══██╗██╔════╝██╔══██╗
             ███████╗██║   ██║██║         █████╗   ╚███╔╝ ██████╔╝██║     ██║   ██║██████╔╝█████╗  ██████╔╝
             ╚════██║██║   ██║██║         ██╔══╝   ██╔██╗ ██╔═══╝ ██║     ██║   ██║██╔══██╗██╔══╝  ██╔══██╗
             ███████║╚██████╔╝╚██████╗    ███████╗██╔╝ ██╗██║     ███████╗╚██████╔╝██║  ██║███████╗██║  ██║
             ╚══════╝ ╚═════╝  ╚═════╝    ╚══════╝╚═╝  ╚═╝╚═╝     ╚══════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝
             --  This file is a part of the SOC Explorer Software
             --  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 <abstractbinfile.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
             //! 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.
                 socexplorerplugin(QWidget *parent = 0,bool createPyObject=true):QDockWidget(parent)
                 {
+                    Q_UNUSED(createPyObject)
                     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;
                 }
                 //! 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 SocExplorer and it can be user accessible if you want.
                 virtual void setBaseAddress(unsigned int baseAddress);
                 QList<socexplorerplugin*> childs;
                 socexplorerplugin* parent;
                 QAction* closeAction;
                 QString  instanceName();
                 QString  instance(){return 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);
                 virtual bool dumpMemory(unsigned int address,unsigned int count,QString file);
                 virtual bool memSet(unsigned int address,int value, unsigned int count);
                 virtual bool loadbin(unsigned int address,QString file);
                 virtual bool loadfile(abstractBinFile* file);
                 virtual bool dumpMemory(unsigned int address,unsigned int count,QString file,const QString& format);
                 QVariantList Read(unsigned int address, unsigned int count);
                 void Write(unsigned int address, QList<QVariant> dataList);
                 socexplorerplugin* parentPlugin(){return this->parent;}
                 socexplorerplugin* toPlugin(){return (socexplorerplugin*)this;}
             protected:
                 int BaseAddress;
                 bool Connected;
                 QString* _Name;
                 QString* _Author;
                 QString* _Version;
                 QString* _Description;
                 QString  _instanceName;
                 int _canBeChild;
                 int _canBeRoot;
                 int _VID;
                 int _PID;
             };
             #endif // SOCEXPLORERPLUGIN_H

src/SocExplorerEngine/proxy/socexplorerproxy.cpp +70 -7

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  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;
+            QStringList* socexplorerproxy::linearDriverPathList=NULL;
             socexplorerproxy::socexplorerproxy(QObject *parent) :
                 QObject(parent)
             {
                 cache = new PluginsCache;
                 drivers = new QList<socexplorerplugin*>;
                 linearDriverList=new QList<socexplorerplugin*>;
+                linearDriverPathList=new QStringList;
                 root = NULL;
             }
             socexplorerproxy::socexplorerproxy(QMainWindow *Mainwindow, QObject *parent):
                 QObject(parent)
             {
                 mainWindow = Mainwindow;
                 cache = new PluginsCache;
                 drivers = new QList<socexplorerplugin*>;
                 linearDriverList=new QList<socexplorerplugin*>;
+                linearDriverPathList=new QStringList;
                 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);
+                    loadSysDriver(driver,driverName,name);
                 }
             }
             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);
+                    loadSysDriver(driver,instanceName,name);
                 }
             }
-            void socexplorerproxy::loadSysDriver(socexplorerplugin *driver, const QString instanceName)
+            void socexplorerproxy::loadSysDriver(socexplorerplugin *driver, const QString instanceName, const QString path)
             {
                 if(!_self)init();
                 driver->setInstanceName(instanceName);
                 driver->parent = NULL;
                 drivers->append(driver);
                 linearDriverList->append(driver);
+                if(path.isEmpty())
+                    linearDriverPathList->append(driver->baseName());
+                else
+                    linearDriverPathList->append(path);
                 connectChildToProxy(driver);
                 emit _self->addPluginGUI(driver);
                 emit _self->clearMenu();
                 emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
                 SocExplorerEngine::addSOC(driver);
                 driver->postInstantiationTrigger();
             }
             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);
+                        if(parent!=NULL)_self->loadSysDriverToParent(driver,parent,driverName,child);
                     }
                 }
             }
             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);
+                        if(parent!=NULL)loadSysDriverToParent(driver,parent,driverName,name);
                     }
                 }
             }
             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);
+                        if(parent!=NULL)loadSysDriverToParent(driver,parent,instanceName,name);
                     }
                 }
             }
-            void socexplorerproxy::loadSysDriverToParent(socexplorerplugin *driver,socexplorerplugin *parent, const QString instanceName)
+            void socexplorerproxy::loadSysDriverToParent(socexplorerplugin *driver,socexplorerplugin *parent, const QString instanceName,const QString path)
             {
                 if(!_self)init();
                 linearDriverList->append(driver);
+                if(path.isEmpty())
+                    linearDriverPathList->append(driver->baseName());
+                else
+                    linearDriverPathList->append(path);
                 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::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;
             }
+            QStringList socexplorerproxy::getPluginsList()
+            {
+                if(!_self)init();
+                QStringList result;
+                socexplorerplugin* plugin;
+                for(int i=0; i<linearDriverList->count();i++)
+                {
+                    QString parent="";
+                    plugin=linearDriverList->at(i);
+                    if(plugin->parent)parent=plugin->parent->instanceName();
+                    result.append(linearDriverList->at(i)->instanceName()+":"+parent+":"+linearDriverPathList->at(i));
+                }
+                return result;
+            }
+            bool socexplorerproxy::loadPluginsList(QStringList plugins)
+            {
+                if(!_self)init();
+                QString plugin;
+                int lastLoadedPlugins=-1;
+                QStringList loadedPlugins;
+                while(plugins.count() && lastLoadedPlugins!=loadedPlugins.count())
+                {
+                    lastLoadedPlugins=loadedPlugins.count();
+                    for (int i = 0; i < plugins.count(); i++)
+                    {
+                        plugin=plugins[i];
+                        QStringList args=plugin.split(':',QString::KeepEmptyParts);
+                        if(args.count()==3)
+                        {
+                            if(args[1].isEmpty())
+                            {
+                                _self->loadSysDriver(args[2],args[0]);
+                                loadedPlugins.append(args[0]);
+                                plugins.removeAt(i);
+                            }
+                            else if(loadedPlugins.contains(args[1]))
+                            {
+                                _self->loadSysDriverToParent(args[2],args[0],args[1]);
+                                loadedPlugins.append(args[0]);
+                                plugins.removeAt(i);
+                            }
+                        }
+                        else
+                        {
+                            plugins.removeAt(i);
+                        }
+                    }
+                }
+            }
             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());
+                    linearDriverPathList->removeAt(linearDriverList->indexOf(driver));
                     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 +5 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  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);
+                static QStringList getPluginsList();
+                static bool loadPluginsList( QStringList plugins);
                 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 loadSysDriver(socexplorerplugin* driver,const QString instanceName,const QString path="");
                 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 loadSysDriverToParent(socexplorerplugin *driver,socexplorerplugin *parent, const QString instanceName,const QString path="");
                 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 QStringList* linearDriverPathList;
                 static socexplorerplugin* root;
                 static socexplorerplugin* parent;
                 static PluginsCache* cache;
             };
             #endif // SOCEXPLORERPROXY_H

src/mainwindow.cpp +76 -6

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011-2015, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "mainwindow.h"
             #include <QDockWidget>
             #include <socexplorersettings.h>
             #include <socexplorerconfigkeys.h>
             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();
                 SocExplorerSettings::init();
-                SocExplorerSettings::loadSession("Session1");
                 this->makeConnections();
                 this->setWindowIcon(QIcon(":/images/icon.png"));
                 this->setAcceptDrops(true);
                 this->pluginManager->setRootLoadable(true);
                 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
                 QFile file(":/styles/SocExplorer.css");
                 if(file.open(QIODevice::ReadOnly | QIODevice::Text))
                 {
                     qApp->setStyleSheet(file.readAll());
                     file.close();
                 }
             }
             void SocExplorerMainWindow::makeObjects(QString ScriptToEval)
             {
                 Q_UNUSED(ScriptToEval)
                 this->p_pluginGUIlist = new QList<QDockWidget*>();
                 pluginsDockContainer = new QMainWindow;
+                pluginsDockContainer->setObjectName("pluginsDockContainer");
                 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);
                 this->p_SessionManagerDialog = new SessionManagerDialog();
                 socexplorerproxy::setMainWindow(this);
                 SocExplorerEngine::setMainWindow(this);
                 SocExplorerEngine::xmlModel()->scanXmlFiles();
                 this->regExplorer = new RegsExplorer();
                 this->regExplorer->setAllowedAreas(Qt::AllDockWidgetAreas);
+                this->regExplorer->setObjectName("regExplorer");
                 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->toolpane->setObjectName("toolpane");
                 this->p_about = new aboutsocexplorer();
             }
             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 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()));
-                connect(this->sessionManagerAction, SIGNAL(triggered(bool)),this->p_SessionManagerDialog,SLOT(show()));
+                connect(this->sessionManagerAction, SIGNAL(triggered(bool)),this,SLOT(showSessionManager(bool)));
+                connect(this->p_SessionManagerDialog, SIGNAL(switchSession(QString)),this,SLOT(setActiveSession(QString)));
                 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 SocExplorerMainWindow::launchPluginManager()
             {
                 if(this->pluginManager->isHidden())
                 {
                     this->pluginManager->setHidden(false);
                 }
             }
             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 SocExplorerMainWindow::removePluginInterface(QDockWidget *plugin)
             {
                 p_pluginGUIlist->removeOne(plugin);
                 this->pluginsDockContainer->removeDockWidget(plugin);
             }
             void SocExplorerMainWindow::clearMenu()
             {
                 this->menuBar()->clear();
                 this->makeMenu();
             }
             void SocExplorerMainWindow::makeMenu()
             {
                 this->FileMenu = menuBar()->addMenu(tr("&File"));
                 this->SessionsMenu = this->FileMenu->addMenu(tr("&Sessions"));
+                this->loadSessions();
                 this->sessionManagerAction = this->FileMenu->addAction(tr("&Session manager..."));
                 this->SettingsMenu = menuBar()->addMenu(tr("&Settings"));
                 SocExplorerGUI::registerMenuBar(menuBar(),this->FileMenu,this->SettingsMenu);
                 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);
             }
             void SocExplorerMainWindow::loadSessions()
             {
                 p_Sessions=this->p_SessionManagerDialog->getSessionsList();
+                sessionsActions_t* sact;
+                QString stext;
+                foreach (sact, sessionsActions)
+                {
+                      sessionsActions.removeAll(sact);
+                      SessionsMenu->removeAction(sact);
+                      disconnect(sact);
+                      delete sact;
+                }
+                foreach (stext, p_Sessions)
+                {
+                    sact = new sessionsActions_t(stext,this);
+                    sact->setCheckable(true);
+                    connect(sact,SIGNAL(triggered(QString)),this,SLOT(setActiveSession(QString)));
+                    sessionsActions.append(sact);
+                    SessionsMenu->addAction(sact);
+                }
+            }
+            void SocExplorerMainWindow::savePlugins()
+            {
+            }
+            void SocExplorerMainWindow::saveCurrentSession()
+            {
+                if(p_currentSession.isEmpty())
+                {
+                    SocExplorerSettings::loadSession("default");
+                }
+                SocExplorerSettings::setValue("GLOBAL","LastModified",QDate::currentDate().toString(),SocExplorerSettings::Session);
+                SocExplorerSettings::setValue(this,"DOCK_LOCATIONS",this->saveState(0),SocExplorerSettings::Session);
+                SocExplorerSettings::setValue(this,"MAIN_WINDOW_GEOMETRY",this->saveGeometry(),SocExplorerSettings::Session);
+                QStringList plugins = socexplorerproxy::getPluginsList();
+                SocExplorerSettings::setValue(this,"LOADED_PLUGINS",QVariant(plugins),SocExplorerSettings::Session);
+                SocExplorerSettings::sync();
+            }
+            void SocExplorerMainWindow::loadCurrentSession()
+            {
+                QStringList plugins = SocExplorerSettings::value(this,"LOADED_PLUGINS",QVariant(),SocExplorerSettings::Session).toStringList();
+                socexplorerproxy::loadPluginsList(plugins);
+                this->restoreGeometry(SocExplorerSettings::value(this,"MAIN_WINDOW_GEOMETRY",QVariant(),SocExplorerSettings::Session).toByteArray());
+                this->restoreState(SocExplorerSettings::value(this,"DOCK_LOCATIONS",QVariant(),SocExplorerSettings::Session).toByteArray());
             }
             SocExplorerMainWindow::~SocExplorerMainWindow()
             {
-                SocExplorerSettings::setValue("GLOBAL","LastModified",QDate::currentDate().toString(),SocExplorerSettings::Session);
-                SocExplorerSettings::sync();
             }
             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 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 SocExplorerMainWindow::updateText()
             {
                 emit this->translateSig();
             }
             void SocExplorerMainWindow::showAboutBox()
             {
                 p_about->show();
             }
             void SocExplorerMainWindow::pluginselected(const QString &instanceName)
             {
                 socexplorerplugin* drv=socexplorerproxy::self()->getSysDriver(instanceName);
                 if(drv)
                     drv->raise();
             }
+            void SocExplorerMainWindow::setActiveSession(const QString &session)
+            {
+                if(!(p_currentSession.isNull() && session=="default"))
+                    saveCurrentSession();
+                socexplorerproxy::self()->close();
+                this->p_currentSession = session;
+                sessionsActions_t* sact;
+                SocExplorerSettings::loadSession(session);
+                loadCurrentSession();
+                foreach (sact, sessionsActions)
+                {
+                      if(sact->text().compare(session))
+                          sact->setChecked(false);
+                      else
+                          sact->setChecked(true);
+                }
+            }
+            void SocExplorerMainWindow::showSessionManager(bool)
+            {
+                this->p_SessionManagerDialog->show();
+            }
             void SocExplorerMainWindow::closeEvent(QCloseEvent *event)
             {
+                saveCurrentSession();
                 socexplorerproxy::self()->close();
                 qApp->closeAllWindows();
                 event->accept();
             }

src/mainwindow.h +26 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  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"
             #include "socexplorergui.h"
             #include "sessionmanagerdialog.h"
+            class sessionsActions_t: public QAction
+            {
+                Q_OBJECT
+            public:
+                sessionsActions_t(const QString &text, QObject* parent)
+                    :  QAction(text,parent)
+                {
+                    connect(this,SIGNAL(triggered(bool)),this,SLOT(p_triggered(bool)));
+                }
+            signals:
+                 void triggered(const QString & session);
+            private slots:
+                 void p_triggered(bool checked = false)
+                 {
+                     Q_UNUSED(checked)
+                     emit triggered(this->text());
+                 }
+            };
             class SocExplorerMainWindow : public QMainWindow
             {
                 Q_OBJECT
             public:
                 SocExplorerMainWindow(QString ScriptToEval,QWidget *parent = 0);
                 ~SocExplorerMainWindow();
                 QAction* Quit,*LoadPlugin,*ManagePlugins,*help,*regsManager,*exploreRegs,*about,*translateAction,*sessionManagerAction;
+                QList<sessionsActions_t*> sessionsActions;
                 QActionGroup*langActionGrp;
                 QMenu* FileMenu,*SettingsMenu,*PluginsMenu,*ToolsMenu,*langMenu,*helpMenu,*SessionsMenu;
                 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);
+                void setActiveSession(const QString & session);
+                void showSessionManager(bool);
             signals:
                 void translateSig();
                 void registerObject(QObject* object,const QString& instanceName);
             private:
                 void makeObjects(QString ScriptToEval);
                 void makeLayout();
                 void makeConnections();
                 void makeMenu();
                 void loadSessions();
+                void savePlugins();
+                void saveCurrentSession();
+                void loadCurrentSession();
                 QMainWindow* pluginsDockContainer;
                 QSplitter* mainWidget;
                 PythonConsole* PythonConsoleInst;
                 dockablePluginManager* pluginManager;
                 RegsExplorer* regExplorer;
                 aboutsocexplorer* p_about;
                 QList<QDockWidget*>* p_pluginGUIlist;
                 QStringList p_Sessions;
+                QString p_currentSession;
                 SessionManagerDialog* p_SessionManagerDialog;
             };
             #endif // MAINWINDOW_H

src/sessionmanagerdialog.cpp +38 -7

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "sessionmanagerdialog.h"
             #include "ui_sessionmanagerdialog.h"
             #include <socexplorersettings.h>
             #include <socexplorerconfigkeys.h>
             #include <QInputDialog>
             #include <QMessageBox>
             SessionManagerDialog::SessionManagerDialog(QWidget *parent) :
                 QDialog(parent),
                 ui(new Ui::SessionManagerDialog)
             {
                 ui->setupUi(this);
                 connect(this->ui->NewQPB,SIGNAL(clicked(bool)),this,SLOT(newSession()));
                 connect(this->ui->DeleteQPB,SIGNAL(clicked(bool)),this,SLOT(deleteSession()));
+                connect(this->ui->RenameQPB,SIGNAL(clicked(bool)),this,SLOT(renameSession()));
+                connect(this->ui->SwitchToQPB,SIGNAL(clicked(bool)),this,SLOT(switchSession()));
             }
             SessionManagerDialog::~SessionManagerDialog()
             {
                 delete ui;
             }
             QStringList SessionManagerDialog::getSessionsList()
             {
                 QStringList result;
                 QList<QList<QVariant> > sessions = SocExplorerSettings::arrays(SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_SCOPE,QStringList()<<SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_NAME);
                 for(int i=0;i<sessions.count();i++)
                 {
                     if(sessions.at(i).count()>=1)
                     {
                         result.append(sessions.at(i).at(0).toString());
                     }
                 }
                 // May always return at least default session
                 if(result.count()==0)
                 {
                     result.append("default");
                 }
                 return result;
             }
             void SessionManagerDialog::show()
             {
                 QStringList sessions = getSessionsList();
+                this->ui->listWidget->clear();
                 this->ui->listWidget->addItems(sessions);
                 QDialog::show();
             }
             void SessionManagerDialog::newSession()
             {
                 bool ok=true,exists=false;
                 QString text;
                 do
                 {
-                    text = QInputDialog::getText(this, tr("QInputDialog::getText()"),
+                    text = QInputDialog::getText(this, tr("SocExplorer Session Manager"),
                                                  tr("Session name:"), QLineEdit::Normal,
                                                  "New Session", &ok);
                     exists = sessionExists(text);
                     if(exists && ok)
                     {
                         QMessageBox::warning(this, tr("SocExplorer Session Manager"),
                                              tr("The session ")+text+tr(" already exists."),
                                              QMessageBox::Ok);
                     }
-                }while(ok && !text.isEmpty() && exists);
+                }while(ok && (text.isEmpty() || exists));
                 if (ok && !text.isEmpty())
                 {
                     this->newSession(text);
                 }
             }
             void SessionManagerDialog::newSession(QString session)
             {
                 if (!session.isEmpty())
                 {
                     this->ui->listWidget->addItem(session);
                     updateSessionList();
                 }
             }
             void SessionManagerDialog::renameSession()
             {
+                bool ok=true;
+                int exists=0;
+                QListWidgetItem* item = this->ui->listWidget->currentItem();
+                QString text= item->text();
+                do
+                {
+                    text = QInputDialog::getText(this, tr("SocExplorer Session Manager"),
+                                                 tr("New session name:"), QLineEdit::Normal,
+                                                 text, &ok);
+                    exists = sessionExists(text);
+                    if(exists&& ok)
+                    {
+                        QMessageBox::warning(this, tr("SocExplorer Session Manager"),
+                                             tr("The session ")+text+tr(" already exists."),
+                                             QMessageBox::Ok);
+                    }
+                }while(ok && text.isEmpty());
+                if (ok && !text.isEmpty())
+                {
+                    item->setText(text);
+                }
             }
             void SessionManagerDialog::deleteSession()
             {
                 if(this->ui->listWidget->selectedItems().count())
                 {
                     QListWidgetItem* item = this->ui->listWidget->currentItem();
                     if(item && item->text().compare("default"))
                     {
                         this->ui->listWidget->removeItemWidget(item);
-                        //TODO delete session FILE!
+                        SocExplorerSettings::deleteSession(item->text());
                         delete item;
                         updateSessionList();
                     }
                 }
             }
-            bool SessionManagerDialog::sessionExists(QString session)
+            void SessionManagerDialog::switchSession()
             {
-                bool diff=true;
+                QListWidgetItem* item = this->ui->listWidget->currentItem();
+                if(item)
+                    emit switchSession(item->text());
+            }
+            int SessionManagerDialog::sessionExists(QString session)
+            {
+                int exists=0;
                 for(int i=0;i< this->ui->listWidget->count();i++)
                 {
-                    diff &= (this->ui->listWidget->item(i)->text().compare(session)!=0);
+                    exists += (this->ui->listWidget->item(i)->text().compare(session)==0);
                 }
-                return !diff;
+                return exists;
             }
             void SessionManagerDialog::updateSessionList()
             {
                 QList<QList<QVariant> >  sessions;
                 for(int i=0;i< this->ui->listWidget->count();i++)
                 {
                     QList<QVariant> sess;
                     sess.append(this->ui->listWidget->item(i)->text());
                     sessions.append(sess);
                 }
                 SocExplorerSettings::setArrays(SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_SCOPE,QStringList()<<SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_NAME,sessions);
             }

src/sessionmanagerdialog.h +6 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef SESSIONMANAGERDIALOG_H
             #define SESSIONMANAGERDIALOG_H
             #include <QDialog>
             namespace Ui {
             class SessionManagerDialog;
             }
             class SessionManagerDialog : public QDialog
             {
                 Q_OBJECT
             public:
                 explicit SessionManagerDialog(QWidget *parent = 0);
                 ~SessionManagerDialog();
                 QStringList getSessionsList();
             public slots:
                 void show();
+                void newSession(QString session);
+                int sessionExists(QString session);
+            private slots:
                 void newSession();
-                void newSession(QString session);
                 void renameSession();
                 void deleteSession();
-                bool sessionExists(QString session);
+                void switchSession();
+            signals:
+                void switchSession(QString session);
             private:
                 void updateSessionList();
                 Ui::SessionManagerDialog *ui;
             };
             #endif // SESSIONMANAGERDIALOG_H

src/sessionmanagerdialog.ui +1 -1

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>SessionManagerDialog</class>
              <widget class="QDialog" name="SessionManagerDialog">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>553</width>
                 <height>275</height>
                </rect>
               </property>
               <property name="windowTitle">
-               <string>Dialog</string>
+               <string>SocExplorer Session Manager</string>
               </property>
               <layout class="QGridLayout" name="gridLayout">
                <item row="0" column="0">
                 <widget class="QListWidget" name="listWidget"/>
                </item>
                <item row="0" column="1">
                 <widget class="QWidget" name="widget" native="true">
                  <layout class="QVBoxLayout" name="verticalLayout">
                   <item>
                    <widget class="QPushButton" name="NewQPB">
                     <property name="text">
                      <string>New</string>
                     </property>
                    </widget>
                   </item>
                   <item>
                    <widget class="QPushButton" name="RenameQPB">
                     <property name="text">
                      <string>Rename</string>
                     </property>
                    </widget>
                   </item>
                   <item>
                    <widget class="QPushButton" name="CloneQPB">
                     <property name="text">
                      <string>Clone</string>
                     </property>
                    </widget>
                   </item>
                   <item>
                    <widget class="QPushButton" name="DeleteQPB">
                     <property name="text">
                      <string>Delete</string>
                     </property>
                    </widget>
                   </item>
                   <item>
                    <widget class="QPushButton" name="SwitchToQPB">
                     <property name="text">
                      <string>Switch to</string>
                     </property>
                    </widget>
                   </item>
                   <item>
                    <spacer name="verticalSpacer">
                     <property name="orientation">
                      <enum>Qt::Vertical</enum>
                     </property>
                     <property name="sizeHint" stdset="0">
                      <size>
                       <width>20</width>
                       <height>40</height>
                      </size>
                     </property>
                    </spacer>
                   </item>
                  </layout>
                 </widget>
                </item>
                <item row="1" column="0" colspan="2">
                 <widget class="QDialogButtonBox" name="buttonBox">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="standardButtons">
                   <set>QDialogButtonBox::Close</set>
                  </property>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources/>
              <connections>
               <connection>
                <sender>buttonBox</sender>
                <signal>accepted()</signal>
                <receiver>SessionManagerDialog</receiver>
                <slot>accept()</slot>
                <hints>
                 <hint type="sourcelabel">
                  <x>248</x>
                  <y>254</y>
                 </hint>
                 <hint type="destinationlabel">
                  <x>157</x>
                  <y>274</y>
                 </hint>
                </hints>
               </connection>
               <connection>
                <sender>buttonBox</sender>
                <signal>rejected()</signal>
                <receiver>SessionManagerDialog</receiver>
                <slot>reject()</slot>
                <hints>
                 <hint type="sourcelabel">
                  <x>316</x>
                  <y>260</y>
                 </hint>
                 <hint type="destinationlabel">
                  <x>286</x>
                  <y>274</y>
                 </hint>
                </hints>
               </connection>
              </connections>
             </ui>

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