HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r10:536aeec6c7cb

Some cleaning.

jeandet -

r10:536aeec6c7cb default

parent child

Context file:

r10:536aeec6c7cb

Collapse all files

.hgsubstate +1 -1

	@@ -1,1 +1,1
	1	~~b05d3dada0406dd7c1700d5d53719a901d214281~~ src/SocExplorerEngine/PeripheralWidget		1	e3a98a04d9ec8685bf222f8d687a614a71927549 src/SocExplorerEngine/PeripheralWidget

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "socexplorerengine.h"
             #include <proxy/socexplorerproxy.h>
             SocExplorerEngine* SocExplorerEngine::_self = NULL;
             socExplorerXmlModel* SocExplorerEngine::p_xmlmodel=NULL;
             QMainWindow* SocExplorerEngine::mainWindow=NULL;
             QList<SOCModel*>* SocExplorerEngine::SOCs=NULL;
             int SocExplorerEngine::loglvl=1;
             SocExplorerEngine::SocExplorerEngine(QObject *parent) :
                 QObject(parent)
             {
                 if(SOCs==NULL)
                 {
                     SOCs = new QList<SOCModel*>;
                 }
             }
             void SocExplorerEngine::init()
             {
                 QDir dir;
                 if(!_self)
                 {
                     _self= new SocExplorerEngine;
                 }
                 if(!dir.exists(configFolder()))
                     dir.mkdir(configFolder());
                 p_xmlmodel = new socExplorerXmlModel(_self);
                 p_xmlmodel->updateSOClist();
             }
             QString SocExplorerEngine::configFolder()
             {
                 return QString(SOCEXPLORER_CONFIG_PATH);
             }
             SOCModel *SocExplorerEngine::plugin2Soc(socexplorerplugin *plugin)
             {
                 if(!_self)
                     init();
                 if(plugin)
                 {
                     while (plugin->parent!=NULL) {
                         plugin = plugin->parent;
                     }
                     for(int i=0;i<SOCs->count();i++)
                     {
                         if(SOCs->at(i)->isRootDev(plugin))
                             return SOCs->at(i);
                     }
                     //no soc found so create a new one
                     SOCModel* soc=new SOCModel(plugin);
                     SOCs->append(soc);
                     return soc;
                 }
                 return NULL;
             }
             int SocExplorerEngine::addEnumDevice(socexplorerplugin* rootPlugin,int VID, int PID, qint32 baseAddress, const QString &name)
             {
                 if(!_self)
                     init();
                 SOCModel* soc = plugin2Soc(rootPlugin);
                 if(soc && !soc->enumDeviceExists(baseAddress))
                 {
                     emit _self->enumDeviceAdded(soc->addEnumDevice(VID,PID,baseAddress,name));
                     return 1;
                 }
                 return 0;
             }
             QList<SOCModel *> *SocExplorerEngine::getSOCs()
             {
                 if(!_self)
                     init();
                 return SOCs;
             }
             qint32 SocExplorerEngine::getEnumDeviceBaseAddress(const QString& rootPlugin,int VID, int PID, int count)
             {
                 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
                 if(plugin==NULL)return -1;
                 SOCModel* soc = plugin2Soc(plugin);
                 if(soc==NULL)
                     return -1;
                 return soc->getEnumDeviceBaseAddress(VID,PID,count);
             }
             qint32 SocExplorerEngine::getEnumDeviceBaseAddress(socexplorerplugin *plugin, int VID, int PID, int count)
             {
                 if(plugin==NULL)return -1;
                 SOCModel* soc = plugin2Soc(plugin);
                 if(soc==NULL)
                     return -1;
                 return soc->getEnumDeviceBaseAddress(VID,PID,count);
             }
             int SocExplorerEngine::addEnumDevice(const QString &rootPlugin, int VID, int PID, qint32 baseAddress, const QString &name)
             {
                 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
                 if(plugin==NULL)return -1;
                 SOCModel* soc = plugin2Soc(plugin);
                 if(soc==NULL)
                     return -1;
                 soc->addEnumDevice(VID,PID,baseAddress,name);
                 return  1;
             }
             QString SocExplorerEngine::getDevName(int VID, int PID)
             {
                 QList<QDomNodeList> list=p_xmlmodel->getAllNodes("peripheral");
                 for(int i=0;i<list.count();i++)
                 {
                     QDomNodeList nodes=list.at(i);
                     for(int l=0;l<nodes.count();l++)
                     {
                         QDomElement node=nodes.at(l).toElement();
                         int nodeVID=node.attribute("vid","0").toInt();
                         int nodePID=node.attribute("pid","0").toInt();
                         if((nodeVID==VID)&&(nodePID==PID))
                         {
                             return node.attribute("name","Unknow device");
                         }
                     }
                 }
                 return QString("Unknow device");
             }
             QString SocExplorerEngine::SocExplorerVersion(){return QString(SOCEXPLORER_VERSION);}
             QString SocExplorerEngine::SocExplorerChangeset(){return QString(SOCEXPLORER_CHAGESET).split(" ").at(0);}
             QString SocExplorerEngine::SocExplorerBranch(){return QString(SOCEXPLORER_BRANCH);}
             socExplorerXmlModel *SocExplorerEngine::xmlModel()
             {
                 if(!_self)
                     init();
                 return p_xmlmodel;
             }
             void SocExplorerEngine::setMainWindow(QMainWindow *Mainwindow)
             {
                 if(!_self)
                     init();
                 mainWindow=Mainwindow;
             }
             QProgressBar *SocExplorerEngine::getProgressBar(const QString& format, int max)
             {
                 if(!_self)
                     init();
                 QProgressBar* progressBar;
                 if(mainWindow!=NULL)
                 {
                     progressBar = new QProgressBar(mainWindow);
                     mainWindow->statusBar()->addWidget(progressBar);
                 }
                 else
                 {
                     progressBar = new QProgressBar();
                 }
                 progressBar->setMaximum(max);
                 progressBar->setFormat(format);
                 return progressBar;
             }
             void SocExplorerEngine::deleteProgressBar(QProgressBar *progressBar)
             {
                 if(mainWindow!=NULL)
                 {
                     mainWindow->statusBar()->removeWidget(progressBar);
                 }
                 delete progressBar;
             }
             void SocExplorerEngine::addSOC(socexplorerplugin *rootPlugin)
             {
                 plugin2Soc(rootPlugin);
             }
             void SocExplorerEngine::removeSOC(socexplorerplugin *rootPlugin)
             {
                 SOCModel* soc=plugin2Soc(rootPlugin);
                 SOCs->removeAll(soc);
                 delete soc;
             }
             void SocExplorerEngine::message(socexplorerplugin *sender, const QString &message, int debugLevel)
             {
                 // TODO add multi output message manager IE also log in files
                 if(!_self)
                     init();
                 if(loglvl>=debugLevel)
-                    qDebug()<< QTime::currentTime().toString()+" " + sender->instanceName+":"+message;
+                    qDebug()<< QTime::currentTime().toString()+" " + sender->instanceName()+":"+message;
             }

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "pluginmanagerWDGT.h"
             #include "pluginloader.h"
             #include <QFileDialog>
             #include <unistd.h>
             #include <qsvgicon.h>
             #include <socexplorerengine.h>
             #define mkbutton(button,text,image)button = new QPushButton();\
             button->setIcon(QSvgIcon(image));\
             button->setIconSize(QSize(16,16));\
             button->setToolTip(text)
             pluginmanagerWDGT::pluginmanagerWDGT(QWidget *parent) :
                 QSplitter(parent)
             {
                 this->setWindowTitle("Plugin Manager");
                 this->setOrientation(Qt::Vertical);
                 this->pluginListWidgetContainer = new QWidget();
                 this->mainlayoutSpliter = new QSplitter;
                 this->pluginListLayout = new QVBoxLayout();
                 this->mainlayoutSpliter->setOrientation(Qt::Vertical);
                 this->treeview = new plugintree();
                 this->pluginTable = new PluginList;
                 this->ButtonsLayout = new QHBoxLayout();
                 this->ButtonsLayout->addStretch();
                 this->pluginListLayout->addLayout(this->ButtonsLayout);
                 this->addWidget(this->treeview);
                 this->pluginListWidgetContainer->setLayout(this->pluginListLayout);
                 this->addWidget(this->pluginListWidgetContainer);
                 this->pluginListLayout->addWidget(this->pluginTable);
                 this->pluginInfos = new pluginInfosWdgt;
                 mkbutton(this->addPluginBt,tr("add plugin"),":/images/open.svg");
                 mkbutton(this->removePluginBt,tr("remove plugin(s)"),":/images/trash.svg");
                 mkbutton(this->refreshPluginListBt,tr("Refresh Plugin(s) list"),":/images/refresh.svg");
                 this->ButtonsLayout->addWidget(this->addPluginBt);
                 this->ButtonsLayout->addWidget(this->refreshPluginListBt);
                 this->ButtonsLayout->addWidget(this->removePluginBt);
                 this->addWidget(this->pluginInfos);
                 connect(this->treeview,SIGNAL(geteplugintree()),this,SIGNAL(geteplugintree()));
                 connect(this,SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->treeview,SLOT(treeChanged(QList<socexplorerplugin*>)));
                 connect(this->pluginTable,SIGNAL(currentRowChanged(int)),this,SLOT(libselected(int)));
                 connect(this->pluginTable,SIGNAL(itemSelectionChanged(QStringList)),this->pluginInfos,SLOT(updateInfos(QStringList)));
                 connect(this->addPluginBt,SIGNAL(clicked()),this,SLOT(addPlugin()));
                 connect(this->removePluginBt,SIGNAL(clicked()),this,SLOT(removePlugin()));
                 connect(this->pluginTable,SIGNAL(itemDoubleClicked(QListWidgetItem*)),this,SLOT(loadplugin(QListWidgetItem*)));
                 connect(this->refreshPluginListBt,SIGNAL(clicked()),this->pluginTable,SLOT(refreshPluginList()));
                 connect(this->treeview,SIGNAL(loadSysDriver(QString)),this,SIGNAL(loadSysDrviver(QString)));
                 connect(this->treeview,SIGNAL(loadSysDriverToParent(QString,QString)),this,SIGNAL(loadSysDriverToParent(QString,QString)));
                 connect(this->treeview,SIGNAL(changeSysDriverInstName(QString,QString)),this,SIGNAL(changeSysDriverInstName(QString,QString)));
                 connect(this->treeview,SIGNAL(closeSysDriver(QString)),this,SIGNAL(closeSysDriver(QString)));
+                connect(this->treeview,SIGNAL(pluginselected(QString)),this,SIGNAL(pluginselected(QString)));
                 this->rootLoadable = false;
                 this->childLoadable = false;
                 this->pluginTable->refreshPluginList();
                 this->pluginTable->refreshPluginList();
             }
             void pluginmanagerWDGT::setRootLoadable(bool flag)
             {
                 this->rootLoadable = flag;
             }
             void pluginmanagerWDGT::setChildLoadable(bool flag)
             {
                 this->childLoadable = flag;
             }
             void pluginmanagerWDGT::addPlugin()
             {
                 QString fileName = QFileDialog::getOpenFileName(this,tr("Open Plugin"), QDir::homePath(), tr("Plugin Files Files (*.dll *.so *.so.*)"));
                 if(pluginloader::checklibrary(fileName))
                 {
                     QFile::copy(fileName,QString(SocExplorerEngine::pluginFolder())+"/"+ fileName.section('/',-1));
                 }
                 this->pluginTable->refreshPluginList();
             }
             void pluginmanagerWDGT::removePlugin()
             {
                 for(int i=0;i<this->pluginTable->selectedItems().count();i++)
                 {
                     QListWidgetItem* item = this->pluginTable->selectedItems().at(i);
                     if(item!=NULL)
                     {
                         QFile::remove(QString(SocExplorerEngine::pluginFolder())+"/"+item->text());
                     }
                 }
                 this->pluginTable->refreshPluginList();
             }
             void pluginmanagerWDGT::loadplugin()
             {
                 for(int i=0;i<this->pluginTable->selectedItems().count();i++)
                 {
                     QListWidgetItem* item = this->pluginTable->selectedItems().at(i);
                     if(item!=NULL)
                     {
                         QString plugin = QString(SocExplorerEngine::pluginFolder())+"/"+item->text();
                         emit this->loadSysDrviver(plugin);
                     }
                 }
                 this->pluginTable->refreshPluginList();
             }

src/SocExplorerEngine/pluginManagerWdgt/pluginmanagerWDGT.h +2 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PLUGINMANAGERWDGT_H
             #define PLUGINMANAGERWDGT_H
             #include <QApplication>
             #include <QWidget>
             #include <QDockWidget>
             #include <QVBoxLayout>
             #include <QHBoxLayout>
             #include <QTableWidget>
             #include <QDir>
             #include <QStringList>
             #include <QFileInfoList>
             #include <QFileInfo>
             #include <QTextEdit>
             #include <QPushButton>
             #include <QSplitter>
             #include "plugininfoswdgt.h"
             #include "pluginlist.h"
             #include <socexplorerplugin.h>
             #include <QList>
             #include "plugintree.h"
             #if defined(SOCEXPLORER_SDK_BUILD)
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
             #else
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
             #endif
             class pluginmanagerWDGT : public QSplitter
             {
                 Q_OBJECT
             public:
             SOCEXPLORER_SDK_EXPORT        explicit pluginmanagerWDGT(QWidget *parent = 0);
             SOCEXPLORER_SDK_EXPORT        void setRootLoadable(bool flag);
             SOCEXPLORER_SDK_EXPORT        void setChildLoadable(bool flag);
             signals:
                 void updatepluginInfo(const QString libname);
                 void loadSysDrviver(const QString name);
                 void loadSysDriverToParent(const QString name, const QString instanceName);
                 void geteplugintree(void);
                 void treeChanged(const QList<socexplorerplugin*>& drivers);
                 void changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName);
                 void closeSysDriver(const QString instanceName);
+                void pluginselected(const QString& instanceName);
             public slots:
                 //void libselected(int row);
                 void addPlugin();
                 void removePlugin();
                 void loadplugin();
                 //void loadplugin(QListWidgetItem*);
             private:
                 bool rootLoadable;
                 bool childLoadable;
                 QWidget* pluginListWidgetContainer;
                 QVBoxLayout* pluginListLayout;
                 QHBoxLayout* ButtonsLayout;
                 QSplitter* mainlayoutSpliter;
                 PluginList* pluginTable;
                 pluginInfosWdgt* pluginInfos;
                 plugintree* treeview;
                 QPushButton* addPluginBt;
                 QPushButton* removePluginBt;
                 QPushButton* loadPluginBt;
                 QPushButton* refreshPluginListBt;
             };
             #endif // PLUGINMANAGERWDGT_H

src/SocExplorerEngine/pluginManagerWdgt/plugintree.cpp +11 -2

             #include "plugintree.h"
             #include "pluginloader.h"
             #include <QApplication>
             #include "qsvgicon.h"
             #include <QHeaderView>
             #include <QString>
             plugintree::plugintree(QWidget *parent) :
                 QTreeWidget(parent)
             {
                 this->editingItem=false;
                 this->editeditemprev=new QString;
                 this->setAcceptDrops(true);
                 this->setDragDropMode(QAbstractItemView::DropOnly);
                 connect(this,SIGNAL(itemChanged(QTreeWidgetItem*,int)),this,SLOT(pluginselectedslt(QTreeWidgetItem*,int)));
+                connect(this,SIGNAL(itemSelectionChanged()),this,SLOT(itemSelectionChangedslt()));
                 this->setHeaderLabels(QStringList()<<"Loaded plugins");
                 emit this->geteplugintree();
             }
             void plugintree::pluginselectedslt(QTreeWidgetItem *item, int column)
             {
                 Q_UNUSED(column)
                 emit this->pluginselected(item->text(0));
             }
+            void plugintree::itemSelectionChangedslt()
+            {
+                if(this->selectedItems().count()==1)
+                {
+                    emit this->pluginselected(this->selectedItems().first()->text(0));
+                }
+            }
             void plugintree::treeChanged(const QList<socexplorerplugin*>& drivers)
             {
                 this->clear();
                 for(int i=0;i<drivers.count();i++)
                 {
                     QTreeWidgetItem* currentItem=new QTreeWidgetItem;
                     currentItem->setIcon(0,QSvgIcon(":/images/server.svg"));
-                    currentItem->setText(0,drivers.at(i)->instanceName);
+                    currentItem->setText(0,drivers.at(i)->instanceName());
                     this->addTopLevelItem(currentItem);
                     if(drivers.at(i)->childs.count()!=0)
                     {
                             this->addplugin(drivers.at(i),currentItem);
                     }
                     currentItem->setExpanded(true);
                 }
             }
             void plugintree::addplugin(socexplorerplugin *driver, QTreeWidgetItem *item)
             {
                 for(int i=0;i<driver->childs.count();i++)
                 {
                     QTreeWidgetItem* currentItem=new QTreeWidgetItem;
                     currentItem->setIcon(0,QSvgIcon(":/images/server.svg"));
-                    currentItem->setText(0,driver->childs.at(i)->instanceName);
+                    currentItem->setText(0,driver->childs.at(i)->instanceName());
                     item->addChild(currentItem);
                     if(driver->childs.at(i)->childs.count()!=0)
                     {
                             this->addplugin(driver->childs.at(i),currentItem);
                     }
                     currentItem->setExpanded(true);
                 }
             }
             void plugintree::dragEnterEvent(QDragEnterEvent *event)
             {
                 if (event->mimeData()->hasFormat("socexplorer/pluginName"))
                 {
                     if(pluginloader::isvalid(event->mimeData()->text()))
                     {
                         event->acceptProposedAction();
                     }else
                         {
                             event->ignore();
                         }
                 } else
                 {
                     event->ignore();
                 }
             }
             void plugintree::dragMoveEvent(QDragMoveEvent *event)
             {
                 if (event->mimeData()->hasFormat("socexplorer/pluginName"))
                 {
                     if(pluginloader::isvalid(event->mimeData()->text()))
                     {
                         this->clearSelection();
                         if(this->itemAt(event->pos())!=NULL)
                         {
                             this->itemAt(event->pos())->setSelected(true);
                             event->acceptProposedAction();
                         }
                         else
                             if(pluginloader::libcanberoot(event->mimeData()->text()))
                             {
                                 event->acceptProposedAction();
                             }
                             else
                             {
                                 event->ignore();
                             }
                     }else
                     {
                         event->ignore();
                     }
                 } else
                 {
                     event->ignore();
                 }
             }
             void plugintree::mouseDoubleClickEvent(QMouseEvent *event)
             {
                 this->clearSelection();
                 this->editeditem=this->itemAt(event->pos());
                 if(this->editeditem!=NULL && this->editingItem==false)
                 {
                     *this->editeditemprev=this->editeditem->text(0);
                     this->openPersistentEditor(this->editeditem);
                     this->editingItem=true;
                 }
                 QTreeWidget::mouseDoubleClickEvent(event);
             }
             void plugintree::mousePressEvent(QMouseEvent *event)
             {
                 QTreeWidget::mousePressEvent(event);
                 if(this->editingItem==true && this->editeditem!=this->itemAt(event->pos()))
                 {
                     this->closePersistentEditor(this->editeditem);
                     if(QString::compare(this->editeditem->text(0),this->editeditemprev))
                     {
                         emit this->changeSysDriverInstName(this->editeditem->text(0),QString(*this->editeditemprev));
                     }
                     this->editingItem=false;
                 }
             }
             void plugintree::keyPressEvent(QKeyEvent *event)
             {
                 {
                     switch(event->key())
                     {
                     case Qt::Key_Return:
                         if(this->editingItem==true)
                         {
                             this->closePersistentEditor(this->editeditem);
                             if(QString::compare(this->editeditem->text(0),this->editeditemprev))
                             {
                                 emit this->changeSysDriverInstName(this->editeditem->text(0),QString(*this->editeditemprev));
                             }
                             this->editingItem=false;
                         }
                         break;
                     case Qt::Key_Delete:
                         if(this->selectedItems().count()==1)
                         {
                             emit this->closeSysDriver(this->selectedItems().first()->text(0));
                         }
                         break;
                     default:
                         break;
                     }
                 }
             }
             void plugintree::dropEvent(QDropEvent *event)
             {
                 if (event->mimeData()->hasFormat("socexplorer/pluginName"))
                 {
                     QTreeWidgetItem* item=this->itemAt(event->pos());
                     if(item!=NULL)
                     {
                         emit this->loadSysDriverToParent(event->mimeData()->text(),item->text(0));
                         event->acceptProposedAction();
                     }
                     else if(pluginloader::libcanberoot(event->mimeData()->text()))
                     {
                         QString test(event->mimeData()->text());
                         emit this->loadSysDriver(event->mimeData()->text());
                     }
                     if (event->source() == this)
                     {
                         event->setDropAction(Qt::MoveAction);
                         event->accept();
                     } else {
                         if(pluginloader::checklibrary(event->mimeData()->text())!=0) //lib ok
                         {
                             if(pluginloader::libcanberoot(event->mimeData()->text()))
                                 event->acceptProposedAction();
                         }
                     }
                 } else
                 {
                     event->ignore();
                 }
             }

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PLUGINTREE_H
             #define PLUGINTREE_H
             #include <QWidget>
             #include <QTreeWidget>
             #include <socexplorerplugin.h>
             #include <QList>
             #include <QtGui/QDragEnterEvent>
             #include <QtGui/QDragLeaveEvent>
             #include <QtGui/QDragMoveEvent>
             #include <QtGui/QDropEvent>
             #include <QtCore/QMimeData>
             #include <QtCore/QUrl>
             #include <QtCore/QList>
             #include <QPoint>
             #include <QLabel>
             class plugintree : public QTreeWidget
             {
                 Q_OBJECT
             public:
                 explicit plugintree(QWidget *parent = 0);
             protected:
                 void dragEnterEvent(QDragEnterEvent *event);
                 void dragMoveEvent(QDragMoveEvent *event);
                 void dropEvent(QDropEvent *event);
                 void mousePressEvent(QMouseEvent *event);
                 void mouseDoubleClickEvent(QMouseEvent *event);
                 void keyPressEvent(QKeyEvent *event);
             signals:
                     void geteplugintree(void);
                     void pluginselected(const QString& Name);
                     void loadSysDriverToParent(const QString name, const QString instanceName);
                     void loadSysDriver(const QString name);
                     void closeSysDriver(const QString instanceName);
                     void changeSysDriverInstName(const QString instanceName);
                     void changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName);
             public slots:
                     void treeChanged(const QList<socexplorerplugin*>& drivers);
                     void pluginselectedslt( QTreeWidgetItem * item, int column);
+                    void itemSelectionChangedslt();
             private:
                     void addplugin(socexplorerplugin* driver,QTreeWidgetItem* item);
                     QTreeWidgetItem* editeditem;
                     QString* editeditemprev;
                     bool editingItem;
             };
             #endif // PLUGINTREE_H

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

             #include <genericPySysdriver.h>
             #include <socexplorerplugin.h>
             #ifdef WIN32
             #include <stdlib.h>
             #define socexplorerBswap32(X) _byteswap_ulong(X)
             #else
             #ifdef UNIX
             #include <byteswap.h>
             #define socexplorerBswap32(X) bswap_32(X)
             #endif
             #endif
             genericPySysdriver::genericPySysdriver(socexplorerplugin* plugin,QObject* parent):
                 QObject(parent)
             {
                 Q_UNUSED(parent)
                 this->plugin = plugin;
             }
             QVariantList genericPySysdriver::Read(unsigned int address,unsigned int count)
             {
                 unsigned int data[count];
                 QVariantList result;
                 this->plugin->Read(data,count,address);
                 for(unsigned int i = 0;i<count;i++)
                 {
                     result.append(QVariant((int)data[i]));
                 }
                 return result;
             }
             void genericPySysdriver::Write(unsigned int address,QList<QVariant> dataList)
             {
                 unsigned int data[dataList.count()];
                 for(int i = 0;i<dataList.count();i++)
                 {
                     data[i] = (unsigned int)dataList.at(i).toUInt();
                 }
                 this->plugin->Write(data,dataList.count(),address);
             }
             bool genericPySysdriver::dumpMemory(unsigned int address,unsigned int count,QString file)
             {
                 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
                 if(buffer!=NULL)
                 {
                     this->plugin->Read(buffer,count,address);
                     QFile outfile(file);
                     if (!outfile.open(QIODevice::ReadWrite | QIODevice::Text))
                         return false;
                     QTextStream out(&outfile);
                     for(int i=0;(unsigned int)i<count;i++)
                         out << "0x"+QString::number(address+(i*4),16) + ": 0x" + QString::number(buffer[i],16) + "\n";
                     free(buffer);
                     out.flush();
                     outfile.close();
                     return true;
                 }
                 return false;
             }
             bool genericPySysdriver::memSet(unsigned int address,int value, unsigned int count)
             {
                 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
                 if(buffer!=NULL)
                 {
                     memset((void*)buffer,value,count*sizeof(unsigned int));
                     this->plugin->Write(buffer,count,address);
                     free(buffer );
                     return true;
                 }
                 return false;
             }
             bool genericPySysdriver::loadbin(unsigned int address,QString file)
             {
                 QFile infile(file);
                 if (!infile.open(QIODevice::ReadOnly))
                     return false;
                 uint32_t* buffer = (uint32_t*)malloc(infile.size());
                 if(buffer!=NULL)
                 {
                     infile.read((char*)buffer,infile.size());
                     for(int i=0;i<(infile.size()/4);i++)
                     {
                         buffer[i] = socexplorerBswap32(buffer[i]);
                     }
                     this->plugin->Write(buffer,infile.size()/4,address);
                     free(buffer);
                     return true;
                 }
                 return false;
             }
             QString genericPySysdriver::instance()
             {
-                return plugin->instanceName;
+                return plugin->instanceName();
             }

src/SocExplorerEngine/plugins/socexplorerplugin.cpp +11 -4

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include <socexplorerplugin.h>
             int socexplorerplugin::isConnected(){return this->Connected;}
             QString socexplorerplugin::baseName(){return *_Name;}
             int socexplorerplugin::baseAddress(){return this->BaseAddress;}
             void socexplorerplugin::setBaseAddress(unsigned int baseAddress){this->BaseAddress = baseAddress;}
+            QString socexplorerplugin::instanceName()
+            {
+                return this->_instanceName;
+            }
             int socexplorerplugin::registermenu(QMenu *menu)
             {
-                this->menu = menu->addMenu(this->instanceName);
+                this->menu = menu->addMenu(this->_instanceName);
                 this->closeAction = this->menu->addAction(tr("Close plugin"));
                 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
                 this->ChildsMenu = this->menu->addMenu(QString("Childs"));
                 for(int i=0;i<this->childs.count();i++)
                 {
                     this->childs.at(i)->registermenu(this->ChildsMenu);
                 }
-                if(this->pyObject!=NULL)emit this->registerObject((QObject*)this->pyObject,this->instanceName);
+                if(this->pyObject!=NULL)emit this->registerObject((QObject*)this->pyObject,this->instanceName());
                 return 0;
             }
             void socexplorerplugin::postInstantiationTrigger()
             {
                 return;
             }
             unsigned int socexplorerplugin::Write(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 if(parent!=NULL)
                 {
                     return parent->Write(Value,count,address);
                 }
                 return 0;
             }
             unsigned int socexplorerplugin::Read(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 if(parent!=NULL)
                 {
                     return parent->Read(Value,count,address);
                 }
                 return 0;
             }
             void socexplorerplugin::closeMe(){emit this->closePlugin(this);}
             void socexplorerplugin::activate(bool flag){this->setEnabled(flag);emit this->activateSig(flag);}
             void socexplorerplugin::setInstanceName(const QString &newName)
             {
-                this->instanceName = newName;
+                this->_instanceName = newName;
-                this->menu->setTitle(this->instanceName);
+                if(this->menu)
+                    this->menu->setTitle(this->_instanceName);
+                this->setWindowTitle(newName);
             }
             void socexplorerplugin::makeGenericPyWrapper()
             {
                 this->pyObject = new genericPySysdriver(this);
             }

src/SocExplorerEngine/plugins/socexplorerplugin.h +6 -2

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

src/SocExplorerEngine/proxy/socexplorerproxy.cpp +8 -12

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "socexplorerproxy.h"
             #include <pluginmanagerWDGT.h>
             #include <socexplorerengine.h>
             #include <pluginloader.h>
             #include <socexplorerplugin.h>
             socexplorerproxy* socexplorerproxy::_self=NULL;
             QMainWindow* socexplorerproxy::mainWindow=NULL;
             QList<socexplorerplugin*>* socexplorerproxy::drivers=NULL;
             QList<socexplorerplugin*>* socexplorerproxy::linearDriverList=NULL;
             socexplorerplugin* socexplorerproxy::root=NULL;
             socexplorerplugin* socexplorerproxy::parent=NULL;
             PluginsCache* socexplorerproxy::cache=NULL;
             socexplorerproxy::socexplorerproxy(QObject *parent) :
                 QObject(parent)
             {
                 cache = new PluginsCache;
                 drivers = new QList<socexplorerplugin*>;
                 linearDriverList=new QList<socexplorerplugin*>;
                 root = NULL;
             }
             socexplorerproxy::socexplorerproxy(QMainWindow *Mainwindow, QObject *parent):
                 QObject(parent)
             {
                 mainWindow = Mainwindow;
                 cache = new PluginsCache;
                 drivers = new QList<socexplorerplugin*>;
                 linearDriverList=new QList<socexplorerplugin*>;
                 root = NULL;
             }
             void socexplorerproxy::init()
             {
                 if(!_self)
                 {
                     _self = new socexplorerproxy();
                     mainWindow = NULL;
                 }
             }
             void socexplorerproxy::setMainWindow(QMainWindow *Mainwindow)
             {
                 if(!_self)init();
                 mainWindow=Mainwindow;
             }
             void socexplorerproxy::loadSysDriver(const QString name)
             {
                 if(!_self)init();
                 if(pluginloader::libcanberoot(name))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(name);
                     QString driverName = _self->getinstanceName(driver->baseName());
                     loadSysDriver(driver,driverName);
                 }
             }
             void socexplorerproxy::loadSysDriver(const QString name, const QString instanceName)
             {
                 if(!_self)init();
                 if(pluginloader::libcanberoot(name) && !_self->instanceExists(instanceName))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(name);
                     loadSysDriver(driver,instanceName);
                 }
             }
             void socexplorerproxy::loadSysDriver(socexplorerplugin *driver, const QString instanceName)
             {
                 if(!_self)init();
-                driver->instanceName.append(instanceName);
+                driver->setInstanceName(instanceName);
                 driver->parent = NULL;
                 drivers->append(driver);
                 linearDriverList->append(driver);
                 connectChildToProxy(driver);
                 emit _self->addPluginGUI(driver);
                 emit _self->clearMenu();
                 emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
                 SocExplorerEngine::addSOC(driver);
             }
             void socexplorerproxy::loadChildSysDriver(socexplorerplugin *parent, const QString child)
             {
                 if(!_self)init();
                 if(pluginloader::libcanbechild(child))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(child);
                     QString driverName = _self->getinstanceName(driver->baseName());
                     bool ok=true;
                     if(ok)
                     {
                         if(parent!=NULL)_self->loadSysDriverToParent(driver,parent,driverName);
                     }
                 }
             }
             void socexplorerproxy::loadSysDriverToParent(const QString name,const QString ParentInst)
             {
                 if(!_self)init();
                 if(pluginloader::libcanbechild(name))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(name);
                     QString driverName = _self->getinstanceName(driver->baseName());
                     bool ok=true;
                     if(ok)
                     {
                         socexplorerplugin* parent=_self->getSysDriver(ParentInst);
                         if(parent!=NULL)loadSysDriverToParent(driver,parent,driverName);
                     }
                 }
             }
             void socexplorerproxy::loadSysDriverToParent(const QString name,const QString instanceName,const QString ParentInst)
             {
                 if(!_self)init();
                 if(pluginloader::libcanbechild(name) && !_self->instanceExists(instanceName))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(name);
                     bool ok=true;
                     if(ok)
                     {
                         socexplorerplugin* parent=_self->getSysDriver(ParentInst);
                         if(parent!=NULL)loadSysDriverToParent(driver,parent,instanceName);
                     }
                 }
             }
             void socexplorerproxy::loadSysDriverToParent(socexplorerplugin *driver,socexplorerplugin *parent, const QString instanceName)
             {
                 if(!_self)init();
                 linearDriverList->append(driver);
                 driver->parent = parent;
-                driver->instanceName.append(instanceName);
+                driver->setInstanceName(instanceName);
                 parent->childs.append(driver);
                 connectChildToProxy(driver);
                 connectChildToParent(parent,driver);
                 emit _self->clearMenu();
                 emit _self->addPluginGUI(driver);
                 emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
                 driver->postInstantiationTrigger();
             }
             void socexplorerproxy::changeSysDriverInstName(const QString instanceName)
             {
                 Q_UNUSED(instanceName)
             }
             void socexplorerproxy::changeSysDriverInstName(const QString newinstanceName, const QString previnstanceName)
             {
                 if(!_self)init();
                 socexplorerplugin*temp=_self->getSysDriver(previnstanceName);
                 if(temp!=NULL)
                 {
                     if(NULL!=_self->getSysDriver(newinstanceName))
                     {
                         emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
                         return;
                     }
                     temp->setInstanceName(newinstanceName);
                 }
                 emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
             }
             void socexplorerproxy::loadChild(socexplorerplugin *parent)
             {
                 if(!_self)init();
                 parent = parent;
                 pluginmanagerWDGT* pluginmanager0 = new pluginmanagerWDGT;
                 pluginmanager0->setChildLoadable(true);
                 pluginmanager0->connect(pluginmanager0,SIGNAL(loadSysDrviver(QString)),_self,SLOT(loadSysDriverToParent(QString)));
                 pluginmanager0->show();
             }
             void socexplorerproxy::connectChildToParent(socexplorerplugin *parent, socexplorerplugin *child)
             {
                 if(!_self)init();
-                //connect(child,SIGNAL(WriteSig(uint*,uint,uint)),parent,SLOT(Write(uint*,uint,uint)));
+                connect(parent,SIGNAL(activateSig(bool)),child,SLOT(activate(bool)));
-                //connect(child,SIGNAL(ReadSig(uint*,uint,uint)),parent,SLOT(Read(uint*,uint,uint)));
-                connect(parent,SIGNAL(activateSig(bool)),child,SLOT(activate(bool)));//,Qt::DirectConnection);
                 child->activate(parent->isConnected());
             }
             void socexplorerproxy::disconnectChildToParent(socexplorerplugin *child)
             {
                 if(!_self)init();
-                //disconnect(child,SIGNAL(WriteSig(uint*,uint,uint)),child->parent,SLOT(Write(uint*,uint,uint)));
+                disconnect(child->parent,SIGNAL(activateSig(bool)),child,SLOT(activate(bool)));
-               // disconnect(child,SIGNAL(ReadSig(uint*,uint,uint)),child->parent,SLOT(Read(uint*,uint,uint)));
-                disconnect(child->parent,SIGNAL(activateSig(bool)),child,SLOT(activate(bool)));//,Qt::DirectConnection);
             }
             void socexplorerproxy::connectChildToProxy(socexplorerplugin *child)
             {
                 if(!_self)init();
                 connect(child,SIGNAL(registerObject(QObject*,QString)),_self,SIGNAL(registerObject(QObject*,QString)));
                 connect(child,SIGNAL(closePlugin(socexplorerplugin*)),_self,SLOT(closeSysDriver(socexplorerplugin*)));
             }
             void socexplorerproxy::disconnectChildToProxy(socexplorerplugin *child)
             {
                 if(!_self)init();
                 disconnect(child,SIGNAL(registerObject(QObject*,QString)),_self,SIGNAL(registerObject(QObject*,QString)));
                 disconnect(child,SIGNAL(closePlugin(socexplorerplugin*)),_self,SLOT(closeSysDriverFromDriver(socexplorerplugin*)));
             }
             QString socexplorerproxy::getinstanceName(const QString& baseName)
             {
                 if(!_self)init();
                 int i=0;
                 QString name;
                 bool validName = false;
                 while(!validName)
                 {
                     name.clear();
                     name.append(baseName+QString::number(i));
                     validName = instanceNameIsValid(name);
                     i++;
                 }
                 return name;
             }
             void socexplorerproxy::changeSysDriverInstName(socexplorerplugin* driver)
             {
                 if(!_self)init();
-                QString prevName(driver->instanceName);
+                QString prevName(driver->instanceName());
             }
             bool socexplorerproxy::instanceNameIsValid(const QString& instanceName)
             {
                 if(!_self)init();
                 for(int k=0;k<linearDriverList->count();k++)
                 {
-                    if(!linearDriverList->at(k)->instanceName.compare(instanceName))
+                    if(!linearDriverList->at(k)->instanceName().compare(instanceName))
                         return false;
                 }
                 return true;
             }
             socexplorerplugin *socexplorerproxy::findPlugin(const QString &instanceName)
             {
                 if(!_self)init();
                 for(int k=0;k<linearDriverList->count();k++)
                 {
-                    if(linearDriverList->at(k)->instanceName.compare(instanceName))
+                    if(linearDriverList->at(k)->instanceName().compare(instanceName))
                         return linearDriverList->at(k);
                 }
                 return NULL;
             }
             bool socexplorerproxy::instanceExists(const QString &instanceName)
             {
                 return !socexplorerproxy::instanceNameIsValid(instanceName);
             }
             void socexplorerproxy::close()
             {
                 if(!_self)init();
                 socexplorerplugin* tmpPtr;
                 while(drivers->count()>0)
                 {
                     tmpPtr = drivers->last();
                     drivers->removeLast();
                     _self->closeSysDriver(tmpPtr);
                 }
                 if(root!=NULL)
                 {
                     _self->closeSysDriver(root);
                 }
             }
             socexplorerplugin* socexplorerproxy::getSysDriver(const QString instanceName)
             {
                 if(!_self)init();
                 for(int i=0;i<linearDriverList->count();i++)
                 {
-                    if(!linearDriverList->at(i)->instanceName.compare(instanceName))
+                    if(!linearDriverList->at(i)->instanceName().compare(instanceName))
                         return linearDriverList->at(i);
                 }
                 return NULL;
             }
             void socexplorerproxy::closeSysDriver(const QString instanceName)
             {
                 if(!_self)init();
                 closeSysDriver(getSysDriver(instanceName),false);
             }
             void socexplorerproxy::closeSysDriver(socexplorerplugin *driver, bool recursive)
             {
                 if(!_self)init();
                 if(driver!=NULL)
                 {
                     if(driver->parent==NULL)SocExplorerEngine::removeSOC(driver);
                     while(driver->childs.count()!=0)closeSysDriver(driver->childs.first());
                     linearDriverList->removeOne(driver);
                     if(driver->parent!= NULL)
                     {
                         driver->parent->childs.removeOne(driver);     //Have parent so it's a child
                         disconnectChildToParent(driver);
                         disconnectChildToProxy(driver);
                         delete driver;
                     }
                     else
                     {
                         drivers->removeOne(driver);
                         disconnectChildToProxy(driver);
                         delete driver;
                     }
                     if(!recursive)
                     {
                         emit _self->clearMenu();
                         emit _self->registermenu(mainWindow);
                         emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
                     }
                 }
             }
             void socexplorerproxy::geteplugintree()
             {
                 if(!_self)init();
                 emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
             }
             void socexplorerproxy::closeSysDriverFromDriver(socexplorerplugin *driver)
             {
                 if(!_self)init();
                 emit _self->closeSysDriverSig(driver);
             }
             void socexplorerproxy::updateText()
             {
                 if(!_self)init();
                 emit _self->clearMenu();
                 emit _self->registermenu(mainWindow);
             }
             void socexplorerproxy::makeMenu(QMenu* menu)
             {
                 if(!_self)init();
                 for(int i=0;i<drivers->count();i++)
                 {
                     drivers->at(i)->registermenu(menu);
                 }
             }

src/dockablepluginmanager.cpp +1 0

             #include "dockablepluginmanager.h"
             dockablePluginManager::dockablePluginManager(QWidget *parent) :
                 QDockWidget(parent)
             {
                 this->managerGui = new pluginmanagerWDGT;
                 connect(this->managerGui,SIGNAL(loadSysDrviver(QString)),this,SIGNAL(loadSysDrviver(QString)));
                 connect(this->managerGui,SIGNAL(loadSysDriverToParent(QString,QString)),this,SIGNAL(loadSysDriverToParent(QString,QString)));
                 connect(this->managerGui,SIGNAL(geteplugintree()),this,SIGNAL(geteplugintree()));
                 connect(this,SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->managerGui,SIGNAL(treeChanged(QList<socexplorerplugin*>)));
                 connect(this->managerGui,SIGNAL(changeSysDriverInstName(QString,QString)),this,SIGNAL(changeSysDriverInstName(QString,QString)));
                 connect(this->managerGui,SIGNAL(closeSysDriver(QString)),this,SIGNAL(closeSysDriver(QString)));
+                connect(this->managerGui,SIGNAL(pluginselected(QString)),this,SIGNAL(pluginselected(QString)));
                 this->setWidget(this->managerGui);
                 this->setWindowTitle(this->managerGui->windowTitle());
             }
             void dockablePluginManager::setRootLoadable(bool flag)
             {
                 this->managerGui->setRootLoadable(flag);
             }

src/dockablepluginmanager.h +1 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef DOCKABLEPLUGINMANAGER_H
             #define DOCKABLEPLUGINMANAGER_H
             #include <QDockWidget>
             #include "pluginmanagerWDGT.h"
             class dockablePluginManager : public QDockWidget
             {
                 Q_OBJECT
             public:
                 explicit dockablePluginManager(QWidget *parent = 0);
                 void  setRootLoadable(bool flag);
             signals:
                 void loadSysDrviver(const QString name);
                 void loadSysDriverToParent(const QString name, const QString instanceName);
                 void geteplugintree(void);
                 void treeChanged(const QList<socexplorerplugin*>& drivers);
                 void changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName);
                 void closeSysDriver(const QString instanceName);
+                void pluginselected(const QString& instanceName);
             public slots:
             private:
                 pluginmanagerWDGT* managerGui;
             };
             #endif // DOCKABLEPLUGINMANAGER_H

src/mainwindow.cpp +15 -4

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "mainwindow.h"
             #include <QDockWidget>
             LPMONMainWindow::LPMONMainWindow(QString ScriptToEval, QWidget *parent)
                 : QMainWindow(parent)
             {
                 QCoreApplication::setApplicationName("SocExplorer");
                 QCoreApplication::setOrganizationName("LPP");
                 QCoreApplication::setOrganizationDomain("lpp.fr");
                 this->makeObjects(ScriptToEval);
                 this->makeLayout();
                 this->makeMenu();
                 this->makeConnections();
                 this->setWindowIcon(QIcon(tr(":/images/logolppcutted.png")));
                 this->setAcceptDrops(true);
                 this->pluginManager->setRootLoadable(true);
                 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
-                QProgressBar* test = SocExplorerEngine::getProgressBar("test",10);
+            //    QProgressBar* test = SocExplorerEngine::getProgressBar("test",10);
-                statusBar()->setFixedHeight(statusBar()->height());
+            //    statusBar()->setFixedHeight(statusBar()->height());
-                SocExplorerEngine::deleteProgressBar(test);
+            //    SocExplorerEngine::deleteProgressBar(test);
             }
             void LPMONMainWindow::makeObjects(QString ScriptToEval)
             {
                 Q_UNUSED(ScriptToEval)
                 pluginsDockContainer = new QMainWindow;
                 pluginsDockContainer->setWindowFlags(Qt::Widget);
                 pluginsDockContainer->setDockNestingEnabled(true);
                 this->mainWidget = new QSplitter(Qt::Vertical);
                 this->appTranslator = new QTranslator;
                 this->Quit = new QAction(tr("&Quit"),this);
                 this->Quit->setShortcut(tr("CTRL+Q"));
                 this->ManagePlugins = new QAction(tr("&Manage Plugins"),this);
                 this->ManagePlugins->setShortcut(tr("CTRL+P"));
                 this->regsManager = new QAction(tr("&Manage registers"),this);
                 this->exploreRegs = new QAction(tr("&Explore registers"),this);
                 this->help = new QAction(tr("&Help"),this);
                 this->help->setShortcut(tr("CTRL+H"));
                 this->about = new QAction(tr("&About"),this);
                 socexplorerproxy::setMainWindow(this);
                 SocExplorerEngine::setMainWindow(this);
                 SocExplorerEngine::xmlModel()->scanXmlFiles();
                 this->regExplorer = new regsExplorer();
                 this->regExplorer->setAllowedAreas(Qt::AllDockWidgetAreas);
-                this->pluginsDockContainer->addDockWidget(Qt::TopDockWidgetArea,this->regExplorer);
+            //    this->pluginsDockContainer->addDockWidget(Qt::TopDockWidgetArea,this->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->p_about = new aboutsocexplorer();
             }
             void LPMONMainWindow::makeLayout()
             {
                 this->mainWidget->addWidget(pluginsDockContainer);
                 this->mainWidget->addWidget(this->PythonConsoleInst);
                 this->toolpane->setAllowedAreas(Qt::RightDockWidgetArea|Qt::LeftDockWidgetArea);
                 this->addDockWidget(Qt::LeftDockWidgetArea,this->toolpane);
                 this->toolpane->addTool(this->pluginManager);
                 this->setCentralWidget(this->mainWidget);
             }
             void LPMONMainWindow::makeConnections()
             {
                 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(this->ManagePlugins,SIGNAL(triggered()),this,SLOT(launchPluginManager()));
                 connect(this->Quit,SIGNAL(triggered()),qApp,SLOT(quit()));
                 connect(this,SIGNAL(registerObject(QObject*,QString)),this->PythonConsoleInst,SLOT(registerObject(QObject*,QString)));
                 connect(socexplorerproxy::self(),SIGNAL(registerObject(QObject*,QString)),this,SIGNAL(registerObject(QObject*,QString)));
                 connect(this->pluginManager,SIGNAL(geteplugintree()),socexplorerproxy::self(),SLOT(geteplugintree()));
                 connect(socexplorerproxy::self(),SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->pluginManager,SIGNAL(treeChanged(QList<socexplorerplugin*>)));
                 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),socexplorerproxy::self(),SLOT(changeSysDriverInstName(QString,QString)));
                 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),this->PythonConsoleInst,SLOT(changeSysDriverInstName(QString,QString)));
                 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),socexplorerproxy::self(),SLOT(closeSysDriver(QString)));
                 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),this->PythonConsoleInst,SLOT(removeDriver(QString)));
+                connect(this->pluginManager,SIGNAL(pluginselected(QString)),this,SLOT(pluginselected(QString)));
                 connect(this->about,SIGNAL(triggered()),this,SLOT(showAboutBox()));
                 connect(this->exploreRegs,SIGNAL(triggered()),this->regExplorer,SLOT(show()));
                 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDrviver(QString)),socexplorerproxy::self(),SLOT(loadSysDriver(QString)));
                 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDriverToParent(QString,QString)),socexplorerproxy::self(),SLOT(loadSysDriverToParent(QString,QString)));
             }
             void LPMONMainWindow::launchPluginManager()
             {
                 if(this->pluginManager->isHidden())
                 {
                     this->pluginManager->setHidden(false);
                 }
             }
             void LPMONMainWindow::addPluginInterface(QDockWidget *plugin)
             {
                 static QDockWidget* last=NULL;
                 plugin->setAllowedAreas(Qt::AllDockWidgetAreas);
                 this->pluginsDockContainer->addDockWidget(Qt::TopDockWidgetArea,plugin);
                 if(last!=NULL)
                     this->pluginsDockContainer->tabifyDockWidget(last,plugin);
                 last = plugin;
             }
             void LPMONMainWindow::clearMenu()
             {
                 this->menuBar()->clear();
                 this->makeMenu();
             }
             void LPMONMainWindow::makeMenu()
             {
                 this->FileMenu = menuBar()->addMenu(tr("&File"));
                 this->PluginsMenu = menuBar()->addMenu(tr("&Plugins"));
                 this->ToolsMenu = menuBar()->addMenu(tr("&Tools"));
                 this->ToolsMenu->addAction(this->exploreRegs);
                 this->FileMenu->addAction(this->Quit);
                 socexplorerproxy::self()->makeMenu(this->PluginsMenu);
                 this->PluginsMenu->addAction(this->ManagePlugins);
                 this->helpMenu = menuBar()->addMenu(tr("Help"));
                 this->helpMenu->addAction(this->help);
                 this->helpMenu->addAction(this->about);
             }
             LPMONMainWindow::~LPMONMainWindow()
             {
                 delete this->p_about;
             }
             void LPMONMainWindow::setLangage(QAction *action)
             {
                 QString local = action->data().toString();
                 QString qmPath = QDir(QString("translations")).absolutePath();
                 appTranslator->load(qmPath+"/socexplorer_"+local+".qm");
                 qApp->installTranslator(appTranslator);
                 emit this->translateSig();
             }
             void LPMONMainWindow::createLangMenu()
             {
                 this->langMenu = menuBar()->addMenu(tr("&Langue"));
                 this->langActionGrp = new QActionGroup(this);
                 connect(this->langActionGrp,SIGNAL(triggered(QAction*)),this,SLOT(setLangage(QAction*)));
                 QDir* qmDir = new QDir(QString("translations"));
                 QStringList LangFiles = qmDir->entryList(QStringList("socexplorer_*.qm"));
                 for(int i=0;i<LangFiles.size();++i)
                 {
                     QString Local = LangFiles[i];
                     Local.remove(0,Local.indexOf('_')+1);
                     Local.chop(3);
                     QTranslator translator;
                     translator.load(LangFiles[i],qmDir->absolutePath());
                     QString langage = translator.translate("MainWindow","English");
                     QAction *action = new QAction(tr("&%1 %2").arg(i+1).arg(langage),this);
                     action->setCheckable(true);
                     action->setData(Local);
                     langMenu->addAction(action);
                     langActionGrp->addAction(action);
                     if(langage==tr("English"))
                         action->setChecked(true);
                 }
             }
             void LPMONMainWindow::updateText()
             {
                 emit this->translateSig();
             }
             void LPMONMainWindow::showAboutBox()
             {
                 p_about->show();
             }
+            void LPMONMainWindow::pluginselected(const QString &instanceName)
+            {
+                socexplorerplugin* drv=socexplorerproxy::self()->getSysDriver(instanceName);
+            //    if(drv)
+            //        drv->activate(true);
+            // TODO add plugin widget auto focus
+            }
             void LPMONMainWindow::closeEvent(QCloseEvent *event)
             {
                 socexplorerproxy::self()->close();
                 qApp->closeAllWindows();
                 event->accept();
             }

src/mainwindow.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef MAINWINDOW_H
             #define MAINWINDOW_H
             #include <QMainWindow>
             #include <QApplication>
             #include <QVBoxLayout>
             #include <QIcon>
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QDockWidget>
             #include <QTranslator>
             #include <QSplitter>
             #include "dockablepluginmanager.h"
             #include <socexplorerproxy.h>
             #include "PyWdgt/pythonconsole.h"
             #include "aboutsocexplorer.h"
             #include "toolbar.h"
             #include "regsExplorer/regsexplorer.h"
             class LPMONMainWindow : public QMainWindow
             {
                 Q_OBJECT
             public:
                 LPMONMainWindow(QString ScriptToEval,QWidget *parent = 0);
                 ~LPMONMainWindow();
                 QAction* Quit,*LoadPlugin,*ManagePlugins,*help,*regsManager,*exploreRegs,*about,*translateAction;
                 QActionGroup*langActionGrp;
                 QMenu* FileMenu,*PluginsMenu,*ToolsMenu,*langMenu,*helpMenu;
                 QTranslator* appTranslator;
                 void createLangMenu();
                 void closeEvent(QCloseEvent *event);
                 toolBar* toolpane;
             public slots:
                 void launchPluginManager();
                 void addPluginInterface(QDockWidget* plugin);
                 void clearMenu();
                 void updateText();
                 void setLangage(QAction* action);
                 void showAboutBox();
+                void pluginselected(const QString& instanceName);
             signals:
                 void translateSig();
                 void registerObject(QObject* object,const QString& instanceName);
             private:
                 void makeObjects(QString ScriptToEval);
                 void makeLayout();
                 void makeConnections();
                 void makeMenu();
                 QMainWindow* pluginsDockContainer;
                 QSplitter* mainWidget;
                 PythonConsole* PythonConsoleInst;
                 dockablePluginManager* pluginManager;
                 regsExplorer* regExplorer;
                 aboutsocexplorer* p_about;
             };
             #endif // MAINWINDOW_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