|
|
/*------------------------------------------------------------------------------
|
|
|
-- 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->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);
|
|
|
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(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,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);
|
|
|
}
|
|
|
|
|
|
bool socexplorerproxy::instanceNameIsValid(const QString& instanceName)
|
|
|
{
|
|
|
if(!_self)init();
|
|
|
for(int k=0;k<linearDriverList->count();k++)
|
|
|
{
|
|
|
if(!linearDriverList->at(k)->instanceName.compare(instanceName))
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
socexplorerplugin *socexplorerproxy::findPlugin(const QString &instanceName)
|
|
|
{
|
|
|
if(!_self)init();
|
|
|
for(int k=0;k<linearDriverList->count();k++)
|
|
|
{
|
|
|
if(linearDriverList->at(k)->instanceName.compare(instanceName))
|
|
|
return linearDriverList->at(k);
|
|
|
}
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
bool socexplorerproxy::instanceExists(const QString &instanceName)
|
|
|
{
|
|
|
return !socexplorerproxy::instanceNameIsValid(instanceName);
|
|
|
}
|
|
|
|
|
|
void socexplorerproxy::close()
|
|
|
{
|
|
|
if(!_self)init();
|
|
|
socexplorerplugin* tmpPtr;
|
|
|
while(drivers->count()>0)
|
|
|
{
|
|
|
tmpPtr = drivers->last();
|
|
|
drivers->removeLast();
|
|
|
_self->closeSysDriver(tmpPtr);
|
|
|
}
|
|
|
if(root!=NULL)
|
|
|
{
|
|
|
_self->closeSysDriver(root);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
socexplorerplugin* socexplorerproxy::getSysDriver(const QString instanceName)
|
|
|
{
|
|
|
if(!_self)init();
|
|
|
for(int i=0;i<linearDriverList->count();i++)
|
|
|
{
|
|
|
if(!linearDriverList->at(i)->instanceName.compare(instanceName))
|
|
|
return linearDriverList->at(i);
|
|
|
}
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
|
|
|
void socexplorerproxy::closeSysDriver(const QString instanceName)
|
|
|
{
|
|
|
if(!_self)init();
|
|
|
closeSysDriver(getSysDriver(instanceName),false);
|
|
|
}
|
|
|
|
|
|
void socexplorerproxy::closeSysDriver(socexplorerplugin *driver, bool recursive)
|
|
|
{
|
|
|
if(!_self)init();
|
|
|
if(driver!=NULL)
|
|
|
{
|
|
|
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);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
|
