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

@@ -197,6 +197,59 bool SocExplorerSettings::loadSession(co
197	return false;	197	return false;
198	}	198	}
199		199
		200	bool SocExplorerSettings::deleteSession()
		201	{
		202	INIT();
		203	if(m_sessionSettings)
		204	{
		205	m_sessionSettings->clear();
		206	QString filename= m_sessionSettings->fileName();
		207	if(QFile::exists(filename))
		208	{
		209	delete m_sessionSettings;
		210	QFile::remove(filename);
		211	}
		212	else
		213	delete m_sessionSettings;
		214	m_sessionSettings = NULL;
		215	return true;
		216	}
		217	return false;
		218	}
		219
		220	bool SocExplorerSettings::deleteSession(const QString &session)
		221	{
		222	QFileInfo sessionInfo(m_settings->fileName());
		223	QString fullpath=sessionInfo.absoluteDir().absolutePath() +"/"+session+".conf";
		224	if(m_sessionSettings)
		225	{
		226	if(m_sessionSettings->fileName()==fullpath)
		227	{
		228	deleteSession();
		229	return true;
		230	}
		231	}
		232	QSettings* sessionSettings = new QSettings(fullpath,QSettings::NativeFormat,self());
		233	if(sessionSettings)
		234	{
		235	if(sessionSettings->status()==QSettings::NoError)
		236	{
		237	sessionSettings->clear();
		238	QString filename= m_sessionSettings->fileName();
		239	if(QFile::exists(filename))
		240	{
		241	delete sessionSettings;
		242	QFile::remove(filename);
		243	}
		244	else
		245	delete sessionSettings;
		246	return true;
		247	}
		248	delete sessionSettings;
		249	}
		250	return false;
		251	}
		252
200	void SocExplorerSettings::popConfigDialog()	253	void SocExplorerSettings::popConfigDialog()
201	{	254	{
202	m_configDialog->popConfigDialog(NULL);	255	m_configDialog->popConfigDialog(NULL);

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

                 //! \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:

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

                 //! 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;

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

             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;
             }
                 cache = new PluginsCache;
                 drivers = new QList<socexplorerplugin*>;
                 linearDriverList=new QList<socexplorerplugin*>;
+                linearDriverPathList=new QStringList;
                 root = NULL;
             }
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(name);
                     QString driverName = _self->getinstanceName(driver->baseName());
-                    loadSysDriver(driver,driverName);
+                    loadSysDriver(driver,driverName,name);
                 }
             }
                 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();
                     bool ok=true;
                     if(ok)
                     {
-                        if(parent!=NULL)_self->loadSysDriverToParent(driver,parent,driverName);
+                        if(parent!=NULL)_self->loadSysDriverToParent(driver,parent,driverName,child);
                     }
                 }
             }
                     if(ok)
                     {
                         socexplorerplugin* parent=_self->getSysDriver(ParentInst);
-                        if(parent!=NULL)loadSysDriverToParent(driver,parent,driverName);
+                        if(parent!=NULL)loadSysDriverToParent(driver,parent,driverName,name);
                     }
                 }
             }
                     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);
                 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);
                     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)
                     {

src/SocExplorerEngine/proxy/socexplorerproxy.h +5 -2

                 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);
             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);
                 static QMainWindow* mainWindow;
                 static QList<socexplorerplugin*>* drivers;
                 static QList<socexplorerplugin*>* linearDriverList;
+                static QStringList* linearDriverPathList;
                 static socexplorerplugin* root;
                 static socexplorerplugin* parent;
                 static PluginsCache* cache;

src/mainwindow.cpp +76 -6

                 this->makeLayout();
                 this->makeMenu();
                 SocExplorerSettings::init();
-                SocExplorerSettings::loadSession("Session1");
                 this->makeConnections();
                 this->setWindowIcon(QIcon(":/images/icon.png"));
                 this->setAcceptDrops(true);
                 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);
                 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();
             }
                 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);
                 }
             }
             {
                 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);
             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();
             }
                     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

             #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 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);
                 void makeConnections();
                 void makeMenu();
                 void loadSessions();
+                void savePlugins();
+                void saveCurrentSession();
+                void loadCurrentSession();
                 QMainWindow* pluginsDockContainer;
                 QSplitter* mainWidget;
                 PythonConsole* PythonConsoleInst;
                 aboutsocexplorer* p_about;
                 QList<QDockWidget*>* p_pluginGUIlist;
                 QStringList p_Sessions;
+                QString p_currentSession;
                 SessionManagerDialog* p_SessionManagerDialog;
             };

src/sessionmanagerdialog.cpp +38 -7

                 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()
             void SessionManagerDialog::show()
             {
                 QStringList sessions = getSessionsList();
+                this->ui->listWidget->clear();
                 this->ui->listWidget->addItems(sessions);
                 QDialog::show();
             }
                 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);
                                              tr("The session ")+text+tr(" already exists."),
                                              QMessageBox::Ok);
                     }
-                }while(ok && !text.isEmpty() && exists);
+                }while(ok && (text.isEmpty() || exists));
                 if (ok && !text.isEmpty())
                 {
             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(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()

src/sessionmanagerdialog.h +6 -2

                 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();

src/sessionmanagerdialog.ui +1 -1

                </rect>
               </property>
               <property name="windowTitle">
-               <string>Dialog</string>
+               <string>SocExplorer Session Manager</string>
               </property>
               <layout class="QGridLayout" name="gridLayout">
                <item row="0" column="0">

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