HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r97:9f8fee223cb9

Session manager ready for release.

jeandet -

r97:9f8fee223cb9 default

parent child

Context file:

r97:9f8fee223cb9

src/mainwindow.cpp +37 -9

             /*------------------------------------------------------------------------------
             --  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();
                 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->sessionsActions = new QActionGroup(this);
                 this->sessionManagerAction =new QAction(tr("&Session manager"),this);
                 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,SLOT(showSessionManager(bool)));
                 connect(this->p_SessionManagerDialog, SIGNAL(switchSession(QString)),this,SLOT(setActiveSession(QString)));
+                connect(this->p_SessionManagerDialog, SIGNAL(sessionRenamed(QString,QString)),this,SLOT(renameSession(QString,QString)));
+                connect(this->p_SessionManagerDialog, SIGNAL(sessionAdded(QString)),this,SLOT(addSession(QString)));
+                connect(this->p_SessionManagerDialog, SIGNAL(sessionRemoved(QString)),this,SLOT(removeSession(QString)));
                 connect(this->sessionsActions,SIGNAL(triggered(QAction*)),this,SLOT(setActiveSession(QAction*)));
                 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->FileMenu->addAction(this->sessionManagerAction);
                 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();
                 QAction* sact;
                 QString stext;
                 QList<QAction*> sessions=sessionsActions->actions();
                 foreach (sact, sessions)
                 {
                       sessionsActions->removeAction(sact);
                       SessionsMenu->removeAction(sact);
                       delete sact;
                 }
                 foreach (stext, p_Sessions)
                 {
-                    sact = new QAction(stext,this);
+                    addSession(stext);
-                    sact->setCheckable(true);
-                    sact->setData(stext);
-                    if(p_currentSession==stext)
-                       sact->setChecked(true);
-                    sessionsActions->addAction(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,"PLUGINS_DOCK_LOCATIONS",this->pluginsDockContainer->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());
                 this->pluginsDockContainer->restoreState(SocExplorerSettings::value(this,"PLUGINS_DOCK_LOCATIONS",QVariant(),SocExplorerSettings::Session).toByteArray());
             }
             SocExplorerMainWindow::~SocExplorerMainWindow()
             {
             }
             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;
                 SocExplorerSettings::loadSession(session);
                 loadCurrentSession();
             }
             void SocExplorerMainWindow::setActiveSession(QAction *session)
             {
                 this->setActiveSession(session->text());
             }
             void SocExplorerMainWindow::showSessionManager(bool)
             {
                 this->p_SessionManagerDialog->show();
             }
-            //TODO handle rename
+            void SocExplorerMainWindow::renameSession(const QString &oldName, const QString &newName)
-            void SocExplorerMainWindow::sessionListChanged()
+                for(int i=0;i<sessionsActions->actions().count();i++)
+                {
+                    if(Q_UNLIKELY(sessionsActions->actions().at(i)->text()==oldName))
+                    {
+                        sessionsActions->actions().at(i)->setText(newName);
+                    }
+                }
+            }
+            void SocExplorerMainWindow::addSession(const QString &newSession)
             {
+                QAction* sact = new QAction(newSession,this);
+                sact->setCheckable(true);
+                sact->setData(newSession);
+                if(Q_UNLIKELY(p_currentSession==newSession))
+                   sact->setChecked(true);
+                sessionsActions->addAction(sact);
+                SessionsMenu->addAction(sact);
+            }
+            void SocExplorerMainWindow::removeSession(const QString &session)
+            {
+                QAction* sact;
+                foreach (sact, sessionsActions->actions())
+                {
+                    if(Q_UNLIKELY(sact->text()==session))
+                    {
+                        sessionsActions->removeAction(sact);
+                        SessionsMenu->removeAction(sact);
+                        delete sact;
+                    }
+                }
             }
             void SocExplorerMainWindow::closeEvent(QCloseEvent *event)
             {
                 saveCurrentSession();
                 socexplorerproxy::self()->close();
                 qApp->closeAllWindows();
                 event->accept();
             }

src/mainwindow.h +3 -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 SocExplorerMainWindow : public QMainWindow
             {
                 Q_OBJECT
             public:
                 SocExplorerMainWindow(QString ScriptToEval,QWidget *parent = 0);
                 ~SocExplorerMainWindow();
                 QAction* Quit,*LoadPlugin,*ManagePlugins,*help,*regsManager,*exploreRegs,*about,*translateAction,*sessionManagerAction;
                 QActionGroup*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 setActiveSession(QAction* session);
                 void showSessionManager(bool);
-                void sessionListChanged();
+                void renameSession(const QString& oldName,const QString& newName);
+                void addSession(const QString& newSession);
+                void removeSession(const QString& session);
             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 +4 -1

             /*------------------------------------------------------------------------------
             --  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("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));
                 if (ok && !text.isEmpty())
                 {
                     this->newSession(text);
                 }
             }
             void SessionManagerDialog::newSession(QString session)
             {
                 if (!session.isEmpty())
                 {
                     this->ui->listWidget->addItem(session);
                     updateSessionList();
+                    emit sessionAdded(session);
                 }
             }
             void SessionManagerDialog::renameSession()
             {
                 bool ok=true;
                 int exists=0;
                 QListWidgetItem* item = this->ui->listWidget->currentItem();
                 QString text= item->text();
                 QString OldText= 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);
-                    SocExplorerSettings::renameSession(text,OldText);
+                    SocExplorerSettings::renameSession(OldText,text);
+                    emit sessionRenamed(OldText,text);
                     updateSessionList();
                     emit sessionListChanged();
                 }
             }
             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);
                         SocExplorerSettings::deleteSession(item->text());
+                        emit sessionRemoved(item->text());
                         delete item;
                         updateSessionList();
                     }
                 }
             }
             void SessionManagerDialog::switchSession()
             {
                 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++)
                 {
                     exists += (this->ui->listWidget->item(i)->text().compare(session)==0);
                 }
                 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 +3 -1

             /*------------------------------------------------------------------------------
             --  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 renameSession();
                 void deleteSession();
                 void switchSession();
             signals:
                 void switchSession(QString session);
                 void sessionListChanged();
+                void sessionRenamed(const QString& oldName,const QString& newName);
+                void sessionRemoved(const QString& session);
+                void sessionAdded(const QString& newSession);
             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