HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r93:0dab228f7441

Working on session manager.

Jeandet Alexis -

r93:0dab228f7441 default

parent child

Context file:

r93:0dab228f7441

Collapse all files

src/SocExplorerEngine/engine/socexplorersettings.cpp +44 -1

             /*------------------------------------------------------------------------------
             --  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;
             }
             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(i)));
+                            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);
             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/mainwindow.cpp +1 -11

             /*------------------------------------------------------------------------------
             --  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->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->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 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()));
                 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->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()
             {
-            //    QStringList sessions = SocExplorerSettings::value();
+                p_Sessions=this->p_SessionManagerDialog->getSessionsList();
-                QList<QList<QVariant> > sessions = SocExplorerSettings::arrays(SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_SCOPE,QStringList()<<SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_NAME);
-                p_Sessions.clear();
-                for(int i=0;i<sessions.count();i++)
-                    if(sessions.at(i).count()>=1)
-                        p_Sessions.append(sessions.at(i).at(0).toString());
             }
             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::closeEvent(QCloseEvent *event)
             {
                 socexplorerproxy::self()->close();
                 qApp->closeAllWindows();
                 event->accept();
             }

src/sessionmanagerdialog.cpp +129 0

@@ -1,14 +1,143
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the SocExplorer Software
		3	-- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 2 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------*/
		19	/*-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@lpp.polytechnique.fr
		21	----------------------------------------------------------------------------*/
1	#include "sessionmanagerdialog.h"	22	#include "sessionmanagerdialog.h"
2	#include "ui_sessionmanagerdialog.h"	23	#include "ui_sessionmanagerdialog.h"
		24	#include <socexplorersettings.h>
		25	#include <socexplorerconfigkeys.h>
		26	#include <QInputDialog>
		27	#include <QMessageBox>
3		28
4	SessionManagerDialog::SessionManagerDialog(QWidget *parent) :	29	SessionManagerDialog::SessionManagerDialog(QWidget *parent) :
5	QDialog(parent),	30	QDialog(parent),
6	ui(new Ui::SessionManagerDialog)	31	ui(new Ui::SessionManagerDialog)
7	{	32	{
8	ui->setupUi(this);	33	ui->setupUi(this);
		34	connect(this->ui->NewQPB,SIGNAL(clicked(bool)),this,SLOT(newSession()));
		35	connect(this->ui->DeleteQPB,SIGNAL(clicked(bool)),this,SLOT(deleteSession()));
9	}	36	}
10		37
11	SessionManagerDialog::~SessionManagerDialog()	38	SessionManagerDialog::~SessionManagerDialog()
12	{	39	{
13	delete ui;	40	delete ui;
14	}	41	}
		42
		43
		44	QStringList SessionManagerDialog::getSessionsList()
		45	{
		46	QStringList result;
		47	QList<QList<QVariant> > sessions = SocExplorerSettings::arrays(SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_SCOPE,QStringList()<<SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_NAME);
		48	for(int i=0;i<sessions.count();i++)
		49	{
		50	if(sessions.at(i).count()>=1)
		51	{
		52	result.append(sessions.at(i).at(0).toString());
		53	}
		54	}
		55	// May always return at least default session
		56	if(result.count()==0)
		57	{
		58	result.append("default");
		59	}
		60	return result;
		61	}
		62
		63	void SessionManagerDialog::show()
		64	{
		65	QStringList sessions = getSessionsList();
		66	this->ui->listWidget->addItems(sessions);
		67	QDialog::show();
		68	}
		69
		70	void SessionManagerDialog::newSession()
		71	{
		72	bool ok=true,exists=false;
		73	QString text;
		74	do
		75	{
		76	text = QInputDialog::getText(this, tr("QInputDialog::getText()"),
		77	tr("Session name:"), QLineEdit::Normal,
		78	"New Session", &ok);
		79	exists = sessionExists(text);
		80	if(exists && ok)
		81	{
		82	QMessageBox::warning(this, tr("SocExplorer Session Manager"),
		83	tr("The session ")+text+tr(" already exists."),
		84	QMessageBox::Ok);
		85	}
		86	}while(ok && !text.isEmpty() && exists);
		87
		88	if (ok && !text.isEmpty())
		89	{
		90	this->newSession(text);
		91	}
		92	}
		93
		94	void SessionManagerDialog::newSession(QString session)
		95	{
		96	if (!session.isEmpty())
		97	{
		98	this->ui->listWidget->addItem(session);
		99	updateSessionList();
		100	}
		101	}
		102
		103	void SessionManagerDialog::renameSession()
		104	{
		105
		106	}
		107
		108	void SessionManagerDialog::deleteSession()
		109	{
		110	if(this->ui->listWidget->selectedItems().count())
		111	{
		112	QListWidgetItem* item = this->ui->listWidget->currentItem();
		113	if(item && item->text().compare("default"))
		114	{
		115	this->ui->listWidget->removeItemWidget(item);
		116	//TODO delete session FILE!
		117	delete item;
		118	updateSessionList();
		119	}
		120	}
		121	}
		122
		123	bool SessionManagerDialog::sessionExists(QString session)
		124	{
		125	bool diff=true;
		126	for(int i=0;i< this->ui->listWidget->count();i++)
		127	{
		128	diff &= (this->ui->listWidget->item(i)->text().compare(session)!=0);
		129	}
		130	return !diff;
		131	}
		132
		133	void SessionManagerDialog::updateSessionList()
		134	{
		135	QList<QList<QVariant> > sessions;
		136	for(int i=0;i< this->ui->listWidget->count();i++)
		137	{
		138	QList<QVariant> sess;
		139	sess.append(this->ui->listWidget->item(i)->text());
		140	sessions.append(sess);
		141	}
		142	SocExplorerSettings::setArrays(SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_SCOPE,QStringList()<<SOCEXPLORERGLOBAL_SETTINGS_SESSIONS_NAME,sessions);
		143	}

src/sessionmanagerdialog.h +31 0

+            /*------------------------------------------------------------------------------
+            --  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();
+                void newSession(QString session);
+                void renameSession();
+                void deleteSession();
+                bool sessionExists(QString session);
             private:
+                void updateSessionList();
                 Ui::SessionManagerDialog *ui;
             };
             #endif // SESSIONMANAGERDIALOG_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