HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r100:11a895cff789

Some more cleaning....

Jeandet Alexis -

r100:11a895cff789 pre-0.7

parent child

Context file:

r100:11a895cff789

Collapse all files

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2012, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "socexplorerengine.h"
             #include <proxy/socexplorerproxy.h>
             #include <socexplorersettings.h>
             #include <socexplorercoresettingsgui.h>
             #include <socexplorerconfigkeys.h>
             SocExplorerEngine* SocExplorerEngine::_self = NULL;
             socExplorerXmlModel* SocExplorerEngine::p_xmlmodel=NULL;
             QMainWindow* SocExplorerEngine::mainWindow=NULL;
             QList<SOCModel*>* SocExplorerEngine::SOCs=NULL;
             QSettings* SocExplorerEngine::m_settings=NULL;
             int SocExplorerEngine::loglvl=1;
             SocExplorerEngine::SocExplorerEngine(QObject *parent) :
                 QObject(parent)
             {
                 if(SOCs==NULL)
                 {
                     SOCs = new QList<SOCModel*>;
                 }
                 m_settings = new QSettings();
                 SocExplorerCoreSettingsGUI* cfggui=new SocExplorerCoreSettingsGUI();
                 SocExplorerSettings::registerConfigEntry(cfggui,QIcon(":/images/config.svg"),"SocExplorer Core");
             }
             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);
             }
             QStringList SocExplorerEngine::pluginFolders()
             {
                 if(!_self)
                     init();
                 QStringList folders;
                 QDir pluginFolders(QString(SOCEXPLORER_CONFIG_PATH)+"/plugin.conf.d");
                 if(pluginFolders.exists())
                 {
                     pluginFolders.setFilter(QDir::Files | QDir::NoSymLinks);
                     QFileInfoList list = pluginFolders.entryInfoList();
                     for (int i = 0; i < list.size(); ++i)
                     {
                         QFileInfo fileInfo = list.at(i);
                         if(fileInfo.suffix()=="conf")
                         {
                             QFile confFile(fileInfo.absoluteFilePath());
                             if(confFile.open(QIODevice::ReadOnly))
                             {
                                 while (!confFile.atEnd())
                                 {
                                     QString line = confFile.readLine();
                                     QDir plugDir(line.remove("\n"));
                                     if(plugDir.exists() && !folders.contains(plugDir.absolutePath()))
                                     {
                                         folders.append(plugDir.absolutePath());
                                     }
                                 }
                             }
                         }
                     }
                 }
                 QStringList localCfg = SocExplorerSettings::value(SOCEXPLORERENGINE_SETTINGS_SCOPE,SOCEXPLORERENGINE_SETTINGS_PLUGINS_LOOKUP_PATH).toString().split(";");
                 QString dir;
                 foreach (dir, localCfg)
                 {
                     QDir plugDir(dir);
                     if(plugDir.exists())
                         folders.append(dir);
                 }
                 return folders;
             }
             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);
             }
             qint32 SocExplorerEngine::getEnumDeviceCount(socexplorerplugin *plugin, int VID, int PID)
             {
                 if(plugin==NULL)return 0;
                 SOCModel* soc = plugin2Soc(plugin);
                 if(soc==NULL)
                     return 0;
                 return soc->getEnumDeviceCount(VID,PID);
             }
             qint32 SocExplorerEngine::getEnumDeviceCount(const QString &rootPlugin, int VID, int PID)
             {
                 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
                 if(plugin==NULL)return 0;
                 SOCModel* soc = plugin2Soc(plugin);
                 if(soc==NULL)
                     return 0;
                 return soc->getEnumDeviceCount(VID,PID);
             }
             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;
             }
             unsigned int SocExplorerEngine::memMeasureSize(socexplorerplugin *plugin, unsigned int address, unsigned int maxSize)
             {
               return MemTester::measureMemSize(plugin,address,maxSize);
             }
             unsigned int SocExplorerEngine::memMeasureSize(const QString &plugin, unsigned int address, unsigned int maxSize)
             {
               return MemTester::measureMemSize(plugin,address,maxSize);
             }
             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)
             {
+                if(!_self)
+                    init();
+                 SocExplorerEngine::message(sender->instanceName(),message,debugLevel);
+            }
+            void SocExplorerEngine::message(QObject *sender, const QString &message, int debugLevel)
+            {
+                if(!_self)
+                    init();
+                 SocExplorerEngine::message(sender->objectName(),message,debugLevel);
+            }
+            void SocExplorerEngine::message(const QString &sender, const QString &message, int debugLevel)
+            {
                 // TODO add multi output message manager IE also log in files
+                static QTextStream SocExplorerEngineStdout(stdout);
                 if(!_self)
                     init();
                 if(loglvl>=debugLevel)
-                    qDebug()<< QTime::currentTime().toString()+" " + sender->instanceName()+":"+message;
+                    SocExplorerEngineStdout << QTime::currentTime().toString()+" " + sender+":"+message << endl;
             }
             void SocExplorerEngine::setLogLevel(int level)
             {
                 if(!_self)
                     init();
                 printf("Set log level to %d\n",level);
                 loglvl = level;
             }
             bool SocExplorerEngine::isSocLitleEndian(socexplorerplugin *plugin)
             {
               return plugin2Soc(plugin)->isLitleEndian();
             }

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2012, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef SOCEXPLORERENGINE_H
             #define SOCEXPLORERENGINE_H
             #include <stdint.h>
             #include <QObject>
             #include <QtWidgets>
             #include <QStringList>
             #include <QDomDocument>
             #include <QDomElement>
             #include <QDomNodeList>
             #include <QFile>
             #include <QTextStream>
             #include <QDir>
             #include <QApplication>
             #include <QtCore/qglobal.h>
             #include <QFileDialog>
             #include <socexplorerxmlfile.h>
             #include <socexplorerenumdevice.h>
             #include <XMLmodel.h>
             #include <peripheralwidget.h>
             #include <registerwidget.h>
             #include <socmodel.h>
             #include <memtester.h>
             #include <QSettings>
             #if defined(SOCEXPLORER_SDK_BUILD)
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
             #else
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
             #endif
             class SOCEXPLORER_SDK_EXPORT SocExplorerAutoProgressBar
             {
             public:
                 SocExplorerAutoProgressBar(QProgressBar* progressBar=NULL)
                 {
                     this->p_progressbar=progressBar;
                 }
                  ~SocExplorerAutoProgressBar()
                 {
                     if(p_progressbar)
                     {
                         delete p_progressbar;
                     }
                 }
                 void setProgressBar(QProgressBar* progressBar)
                 {
                     this->p_progressbar=progressBar;
                 }
                 void setValue(int value)
                 {
                     p_progressbar->setValue(value);
                 }
             private:
                 QProgressBar* p_progressbar;
             };
             //! SocExplorerEngine is a pure static class which aims to provide services for both SocExplorer software and plugins.
             class SOCEXPLORER_SDK_EXPORT SocExplorerEngine : public QObject
             {
                 Q_OBJECT
             private:
                 static SocExplorerEngine* _self;
                 static QSettings* m_settings;
                 SocExplorerEngine(QObject *parent = 0);
                 static void init();
             public:
                 static SocExplorerEngine* self(){ if(!_self){_self= new SocExplorerEngine;}return _self;}
                 //! Return the configuration folder path, OS dependant.
                 SOCEXPLORER_SDK_EXPORT static QString configFolder();
                 //! Return the default plugin folder path, OS dependant.
                  static QStringList pluginFolders();
                  static QString configPath(){return QString(SOCEXPLORER_CONFIG_PATH);}
                  static QString sharePath(){return QString(SOCEXPLORER_SHARE_PATH);}
                  static int addEnumDevice(socexplorerplugin* rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
                  static QList<SOCModel*>* getSOCs();
                  static QString getDevName(int VID, int PID);
                  static QString SocExplorerVersion();
                  static QString SocExplorerChangeset();
                  static QString SocExplorerBranch();
                  static socExplorerXmlModel* xmlModel();
                  static void setMainWindow(QMainWindow* Mainwindow);
                  static QProgressBar* getProgressBar(const QString &format, int max);
                  static void deleteProgressBar(QProgressBar* progressBar);
                  static void addSOC(socexplorerplugin* rootPlugin);
                  static void removeSOC(socexplorerplugin* rootPlugin);
                  static void message(socexplorerplugin* sender,const QString& message,int debugLevel=0);
+                 static void message(QObject* sender,const QString& message,int debugLevel=0);
+                 static void message(const QString& sender,const QString& message,int debugLevel=0);
                  static void setLogLevel(int level);
                  static bool isSocLitleEndian(socexplorerplugin* plugin);
             signals:
                  void enumDeviceAdded(socExplorerEnumDevice* device);
             public slots:
                  QString getSocExplorerVersion(){return SocExplorerEngine::SocExplorerVersion();}
                  QString getSocExplorerChangeset(){return SocExplorerEngine::SocExplorerChangeset();}
                  QString getSocExplorerBranch(){return SocExplorerEngine::SocExplorerBranch();}
                  qint32 getEnumDeviceBaseAddress(const QString& rootPlugin,int VID,int PID,int count=0);
                  qint32 getEnumDeviceBaseAddress(socexplorerplugin* plugin,int VID,int PID,int count=0);
                  qint32 getEnumDeviceCount(socexplorerplugin* plugin,int VID,int PID);
                  qint32 getEnumDeviceCount(const QString& rootPlugin,int VID,int PID);
                  int addEnumDevice(const QString& rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
                  unsigned int memMeasureSize(socexplorerplugin* plugin, unsigned int address,unsigned int maxSize=0xFFFFFFFF);
                  unsigned int memMeasureSize(const QString& plugin, unsigned int address,unsigned int maxSize=0xFFFFFFFF);
             private:
                 static SOCModel* plugin2Soc(socexplorerplugin* plugin);
                 static socExplorerXmlModel* p_xmlmodel;
                 static QMainWindow* mainWindow;
                 static QList<SOCModel*>* SOCs;
                 static int loglvl;
             };
             #endif // SOCEXPLORERENGINE_H

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Plasma Physics Laboratory - CNRS
+            --  Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "socexplorersettings.h"
             SocExplorerSettings* SocExplorerSettings::_self=NULL;
             QSettings* SocExplorerSettings::m_settings=NULL;
             QSettings* SocExplorerSettings::m_sessionSettings=NULL;
             SocExplorerSettingsDialog* SocExplorerSettings::m_configDialog = NULL;
             #include <socexplorergui.h>
             #include <QFile>
             #include <QFileInfo>
             #include <QDir>
             #include <QDebug>
             #define INIT() \
                 if(Q_UNLIKELY(_self==NULL))\
             {\
                 init();\
                 }
             SocExplorerSettings::SocExplorerSettings(QObject *parent) : QObject(parent)
             {
                 m_settings = new QSettings();
                 m_configDialog = new SocExplorerSettingsDialog();
                 QAction* trigerGUI = new QAction(tr("Settings"),this);
                 connect(trigerGUI,SIGNAL(triggered()),this,SLOT(popConfigDialog()));
                 SocExplorerGUI::addSettingsAction(trigerGUI);
             }
             SocExplorerSettings::~SocExplorerSettings()
             {
                 if(m_settings)
                 {
                     m_settings->sync();
                     delete m_settings;
                 }
                 if(m_sessionSettings)
                 {
                     m_sessionSettings->sync();
                     delete m_sessionSettings;
                 }
             }
             void SocExplorerSettings::init()
             {
                 if(!_self)
                 {
                     _self= new SocExplorerSettings();
                 }
             }
             void SocExplorerSettings::setValue(QObject *object, const QString &key, const QVariant &value, SettingScope Sscope)
             {
                 INIT();
                 setValue(object->metaObject()->className(),key,value,Sscope);
             }
             QVariant SocExplorerSettings::value(QObject *object, const QString &key, const QVariant &defaultValue, SettingScope Sscope)
             {
                 INIT();
                 return value(object->metaObject()->className(),key,defaultValue,Sscope);
             }
             void SocExplorerSettings::setValue(const QString scope, const QString &key, const QVariant &value, SettingScope Sscope)
             {
                 INIT();
                 switch (Sscope)
                 {
                 case SystemWide:
                     if(m_settings)
                         m_settings->setValue(scope+"/"+key,value);
                     break;
                 case Session:
                     if(m_sessionSettings)
                         m_sessionSettings->setValue(scope+"/"+key,value);
                     break;
                 default:
                     break;
                 }
             }
             QVariant SocExplorerSettings::value(const QString scope, const QString &key, const QVariant &defaultValue, SettingScope Sscope)
             {
                 INIT();
                 switch (Sscope)
                 {
                 case SystemWide:
                     if(m_settings)
                         return m_settings->value(scope+"/"+key,defaultValue);
                     break;
                 case Session:
                     if(m_sessionSettings)
                         return m_sessionSettings->value(scope+"/"+key,defaultValue);
                     break;
                 default:
                     break;
                 }
                 return defaultValue;
             }
             QList<QList<QVariant> > SocExplorerSettings::arrays(const QString &prefix, QStringList keys, SocExplorerSettings::SettingScope Sscope)
             {
                 INIT();
                 QList<QList<QVariant> > defaultValue;
                 switch (Sscope)
                 {
                 case SystemWide:
                     if(m_settings)
                         return arrays(prefix,keys,m_settings);
                     break;
                 case Session:
                     if(m_sessionSettings)
                         return arrays(prefix,keys,m_sessionSettings);
                     break;
                 default:
                     break;
                 }
                 return defaultValue;
             }
             void SocExplorerSettings::setArrays(const QString &prefix, QStringList keys, QList<QList<QVariant> > values, SocExplorerSettings::SettingScope Sscope)
             {
                 INIT();
                 switch (Sscope)
                 {
                 case SystemWide:
                     if(m_settings)
                         return setArrays(prefix,keys,values,m_settings);
                     break;
                 case Session:
                     if(m_sessionSettings)
                         return setArrays(prefix,keys,values,m_sessionSettings);
                     break;
                 default:
                     break;
                 }
             }
             void SocExplorerSettings::sync()
             {
                 INIT();
                 if(m_settings)
                 {
                     m_settings->sync();
                 }
                 if(m_sessionSettings)
                 {
                     m_sessionSettings->sync();
                 }
             }
             bool SocExplorerSettings::registerConfigEntry(SocExplorerSettingsItem *configEntry, QIcon icon, QString text)
             {
                 INIT();
                 return m_configDialog->registerConfigEntry(configEntry,icon,text);
             }
             bool SocExplorerSettings::loadSession(const QString &session)
             {
                 INIT();
                 QFileInfo sessionInfo(m_settings->fileName());
                 QString fullpath=sessionInfo.absoluteDir().absolutePath() +"/"+session+".conf";
                 if(m_sessionSettings)
                 {
                     delete m_sessionSettings;
                     m_sessionSettings = NULL;
                 }
                 m_sessionSettings = new QSettings(fullpath,QSettings::NativeFormat,self());
                 qDebug()<< m_sessionSettings->fileName();
                 if(m_sessionSettings->status()==QSettings::NoError)
                 {
                     return true;
                 }
                 delete m_sessionSettings;
                 m_sessionSettings = NULL;
                 return false;
             }
             bool SocExplorerSettings::renameSession(const QString &session, const QString &newName)
             {
                 INIT();
                 sync();
                 QFileInfo sessionInfo(m_settings->fileName());
                 QString fullpath=sessionInfo.absoluteDir().absolutePath() +"/"+session+".conf";
                 QString newFullpath=sessionInfo.absoluteDir().absolutePath() +"/"+newName+".conf";
                 if(m_sessionSettings && m_sessionSettings->fileName()==fullpath)
                 {
                     delete m_sessionSettings;
                     QFile::rename(fullpath,newFullpath);
                     m_sessionSettings = new QSettings(newFullpath,QSettings::NativeFormat,self());
                 }
                 else
                 {
                     QFile::rename(fullpath,newFullpath);
                 }
                 return true;
             }
             bool SocExplorerSettings::deleteSession()
             {
                 INIT();
                 if(m_sessionSettings)
                 {
                     m_sessionSettings->clear();
                     QString filename= m_sessionSettings->fileName();
                     if(QFile::exists(filename))
                     {
                         delete m_sessionSettings;
                         QFile::remove(filename);
                     }
                     else
                         delete m_sessionSettings;
                     m_sessionSettings = NULL;
                     return true;
                 }
                 return false;
             }
             bool SocExplorerSettings::deleteSession(const QString &session)
             {
                 QFileInfo sessionInfo(m_settings->fileName());
                 QString fullpath=sessionInfo.absoluteDir().absolutePath() +"/"+session+".conf";
                 if(m_sessionSettings)
                 {
                     if(m_sessionSettings->fileName()==fullpath)
                     {
                         deleteSession();
                         return true;
                     }
                 }
                 QSettings* sessionSettings = new QSettings(fullpath,QSettings::NativeFormat,self());
                 if(sessionSettings)
                 {
                     if(sessionSettings->status()==QSettings::NoError)
                     {
                             sessionSettings->clear();
                             QString filename= m_sessionSettings->fileName();
                             if(QFile::exists(filename))
                             {
                                 delete sessionSettings;
                                 QFile::remove(filename);
                             }
                             else
                                 delete sessionSettings;
                             return true;
                     }
                     delete sessionSettings;
                 }
                 return false;
             }
             void SocExplorerSettings::popConfigDialog()
             {
                 m_configDialog->popConfigDialog(NULL);
             }
             QList<QList<QVariant> > SocExplorerSettings::arrays(const QString &prefix, QStringList keys, QSettings *settings)
             {
                 QList<QList<QVariant> > result;
                 if(settings)
                 {
                     int size = settings->beginReadArray(prefix);
                     for (int i = 0; i < size; ++i)
                     {
                         result.append(QList<QVariant>());
                         settings->setArrayIndex(i);
                         for(int l=0;l<keys.count();l++)
                         {
                             result[i].append(settings->value(keys.at(l)));
                         }
                     }
                     settings->endArray();
                 }
                 return result;
             }
             void SocExplorerSettings::setArrays(const QString &prefix, QStringList keys, QList<QList<QVariant> > values, QSettings *settings)
             {
                 if(settings)
                 {
                     QString key;
                     foreach (key, keys)
                     {
                         settings->remove(prefix+"/"+key);
                     }
                     settings->beginWriteArray(prefix);
                     for (int i = 0; i < values.size(); ++i)
                     {
                         settings->setArrayIndex(i);
                         for(int l=0;l<keys.count();l++)
                         {
                             settings->setValue(keys[l], values.at(i).at(l));
                         }
                     }
                     settings->endArray();
                 }
             }

src/SocExplorerEngine/pluginloader/pluginloader.cpp +4 -33

             #include "pluginloader.h"
             #include <QDir>
             #include <QFile>
             #include <QFileInfoList>
             #include <QFileInfo>
             #include <QString>
             #include <QStringList>
             #include <QLabel>
             #include <QSettings>
             #include <QApplication>
             #include <QCoreApplication>
             #include <socexplorerengine.h>
             #ifdef SOCEXPLORER_CUSTOM_PLUGIN_LOADER
             #include "unix/unixpluginloader.h"
             #endif
+            #include <socexplorerengine.h>
+            #include <socexplorersettings.h>
             pluginloader* pluginloader::_self = NULL;
             PluginsCache* pluginloader::_cache = NULL;
             QStringList* pluginloader::_folderList = NULL;
             pluginloader::pluginloader()
             {
                 _cache = new PluginsCache();
                 _folderList = new QStringList();
                 _folderList->append(SocExplorerEngine::pluginFolders());
                 scanFolders();
             }
-            QStringList pluginloader::readFoldersList(const QStringList confFiles)
-                QDir testDir;
-                QStringList folders;
-                QFile confFile;
-                for(int i=0;i<confFiles.count();i++)
-                    confFile.setFileName(confFiles.at(i));
-                    if(confFile.exists())
-                        if (confFile.open(QIODevice::ReadOnly | QIODevice::Text))
-                            QTextStream in(&confFile);
-                            QString line = in.readLine();
-                            while (!line.isNull())
-                                testDir.setPath(line);
-                                if(testDir.exists())
-                                    if(!folders.contains(line))
-                                        folders << line;
-                                line = in.readLine();
-                return folders;
             void pluginloader::scanFolders()
             {
                 QDir dir;
                 QStringList filters;
                 filters <<"*.so"<< "*.dll";
                 _cache->flush();
                 for(int d=0;d<_folderList->count();d++)
                 {
                     dir.setPath(_folderList->at(d));
                     dir.setFilter(QDir::Files);
                     dir.setNameFilters(filters);
                     QFileInfoList list = dir.entryInfoList();
                     for (int i = 0; i < list.size(); ++i)
                     {
                         QFileInfo fileInfo = list.at(i);
+                        SocExplorerEngine::message("pluginloader::scanFolders","Checking "+ fileInfo.filePath(),3);
                         if(checklibrary(fileInfo.filePath())!=0)
                         {
                             _cache->append(fileInfo.fileName(),fileInfo.path(),_getlibName(fileInfo.filePath()),_getlibPID(fileInfo.filePath()),_getlibPID(fileInfo.filePath()));
                         }
                     }
                 }
             }
             int pluginloader::p_checklibraryQlib(const QString fileName)
             {
                 QLibrary* lib = new QLibrary;
                 lib->setFileName(fileName);
                 lib->setLoadHints(QLibrary::PreventUnloadHint);
                 lib->load();
                 if(!lib->isLoaded())
                 {
-                    qDebug()<<lib->errorString();
+                    SocExplorerEngine::message("pluginloader::p_checklibraryQlib",lib->errorString(),3);
                     lib->~QLibrary();
                     lib = new QLibrary(fileName);
                     lib->load();
                 }
                 delete lib;
                 if(QLibrary::resolve(fileName,"socexplorerpluginCreateObject"))
                 {
                     if(QLibrary::resolve(fileName,"socexplorerpluginpid"))
                     {
                         if(QLibrary::resolve(fileName,"socexplorerpluginvid"))
                         {
                             if(QLibrary::resolve(fileName,"socexplorerpluginVersion"))
                             {
                                 if(QLibrary::resolve(fileName,"socexplorerpluginAuthor"))
                                 {
                                     if(QLibrary::resolve(fileName,"socexplorerpluginDescription"))
                                     {
                                         return 1;
                                     }
                                 }
                             }
                         }
                     }
                 }
                 return 0;
             }
             int pluginloader::p_checklibraryCustom(const QString fileName)
             {
             #ifdef SOCEXPLORER_CUSTOM_PLUGIN_LOADER
                 unixPluginLoader lib(fileName);
                 if(NULL!=lib.resolve("socexplorerpluginCreateObject"))
                 {
                     if(NULL!=lib.resolve("socexplorerpluginpid"))
                     {
                         if(NULL!=lib.resolve("socexplorerpluginvid"))
                         {
                             if(NULL!=lib.resolve("socexplorerpluginVersion"))
                             {
                                 if(NULL!=lib.resolve("socexplorerpluginAuthor"))
                                 {
                                     if(NULL!=lib.resolve("socexplorerpluginDescription"))
                                     {
                                         return 1;
                                     }
                                 }
                             }
                         }
                     }
                 }
             #endif
                 return 0;
             }
             socexplorerplugin *pluginloader::p_newsocexplorerpluginQlib(const QString Name)
             {
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 socexplorerpluginCreateObjectT newDrvr = NULL;
                 newDrvr=(socexplorerpluginCreateObjectT)lib->resolve("socexplorerpluginCreateObject");
                 if(newDrvr==NULL)
                 {
                     return NULL;
                 }
                 return (socexplorerplugin*) newDrvr();
             }
             socexplorerplugin *pluginloader::p_newsocexplorerpluginCustom(const QString Name)
             {
             #ifdef SOCEXPLORER_CUSTOM_PLUGIN_LOADER
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return NULL;
                 unixPluginLoader lib(*libfile);
                 delete libfile;
                 socexplorerpluginCreateObjectT newDrvr = NULL;
                 newDrvr=(socexplorerpluginCreateObjectT)lib.resolve("socexplorerpluginCreateObject");
                 if(newDrvr==NULL)
                 {
                     return NULL;
                 }
                 return (socexplorerplugin*) newDrvr();
             #endif
             }
             QList<PluginsCacheItem*> pluginloader::listAvailiables(bool rescan)
             {
                 if(_self==NULL)
                 {
                     init();
                     return _cache->listDrivers();
                 }
                 if(rescan)
                 {
                     scanFolders();
                 }
                 return _cache->listDrivers();
             }
             void pluginloader::init()
             {
                 if(_self==NULL)
                 {
                     _self=new pluginloader();
                 }
             }
             pluginloader* pluginloader::self()
             {
                 if(_self==NULL)
                 {
                     init();
                 }
                 return _self;
             }
             bool pluginloader::isvalid(QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return false;
                 else
                 {
                     delete libfile;
                     return true;
                 }
             }
             int pluginloader::checklibrary(const QString fileName)
             {
             #ifdef SOCEXPLORER_CUSTOM_PLUGIN_LOADER
                 return _self->p_checklibraryCustom(fileName);
             #else
                 return _self->p_checklibraryQlib(fileName);
             #endif
             }
             socexplorerplugin* pluginloader::newsocexplorerplugin(const QString Name)
             {
             #ifdef SOCEXPLORER_CUSTOM_PLUGIN_LOADER
                 return _self->p_newsocexplorerpluginCustom(Name);
             #else
                 return _self->p_newsocexplorerpluginQlib(Name);
             #endif
             }
             QString pluginloader::getlibTypeStr(QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginTypeT plugintype = (socexplorerpluginTypeT)lib->resolve("socexplorerpluginType");
                     if(plugintype!=NULL)
                     {
                         pluginT type = plugintype();
                         switch(type)
                         {
                         case ComDriverT:
                             ////lib->unload();
                             lib->~QLibrary();
                             return QObject::tr("Comunaication Driver Plugin.");
                             break;
                         case PerifDriverT:
                             ////lib->unload();
                             lib->~QLibrary();
                             return QObject::tr("Periferial Driver Plugin.");
                             break;
                         default:
                             ////lib->unload();
                             lib->~QLibrary();
                             return QObject::tr("Unknow Plugin.");
                             break;
                         }
                     }
                 }
                 lib->~QLibrary();
                 return QObject::tr("Can't load Plugin.");
             }
             pluginT pluginloader::getlibType(QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return (pluginT)NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginTypeT plugintype = (socexplorerpluginTypeT)lib->resolve("socexplorerpluginType");
                     if(plugintype!=NULL)
                     {
                         return plugintype();
                     }
                 }
                 lib->~QLibrary();
                 return -1;
             }
             QString pluginloader::getlibVersion(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginVersionT pluginversion = (socexplorerpluginVersionT)lib->resolve("socexplorerpluginVersion");
                     if(pluginversion!=NULL)
                     {
                         QString version = pluginversion();
                         ////lib->unload();
                         lib->~QLibrary();
                         return version;
                     }
                 }
                 lib->~QLibrary();
                 return QObject::tr("Can't load Plugin.");
             }
             QString pluginloader::getlibPIDstr(const QString Name)
             {
                 return QString("0x" + QString::number(pluginloader::getlibPID(Name) , 16));
             }
             QString pluginloader::getlibVIDstr(const QString Name)
             {
                 return QString("0x" + QString::number(pluginloader::getlibVID(Name) , 16));
             }
             int pluginloader::libcanbechild(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return (int)NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerplugincanbechildT canbechild = (socexplorerplugincanbechildT)lib->resolve("socexplorerplugincanbechild");
                     if(canbechild!=NULL)
                     {
                         int value = canbechild();
                         ////lib->unload();
                         //lib->~QLibrary();
                         return value;
                     }
                 }
                 //lib->~QLibrary();
                 return 0;
             }
             int pluginloader::libcanberoot(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return (int)NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerplugincanberootT canberoot = (socexplorerplugincanberootT)lib->resolve("socexplorerplugincanberoot");
                     if(canberoot!=NULL)
                     {
                         int value = canberoot();
                         ////lib->unload();
                         //lib->~QLibrary();
                         return value;
                     }
                 }
                 delete lib;
                 //lib->~QLibrary();
                 return 0;
             }
             int pluginloader::getlibVID(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return 0;
                 QString file(*libfile);
                 delete libfile;
                 return _getlibVID(file);
             }
             int pluginloader::getlibPID(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return 0;
                 QString file(*libfile);
                 delete libfile;
                 return _getlibPID(file);
             }
             QString pluginloader::getlibAuthor(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginAuthorT pluginauthor = (socexplorerpluginAuthorT)lib->resolve("socexplorerpluginAuthor");
                     if(pluginauthor!=NULL)
                     {
                         QString author = pluginauthor();
                         ////lib->unload();
                         lib->~QLibrary();
                         return author;
                     }
                 }
                 lib->~QLibrary();
                 return QObject::tr("Can't load Plugin.");
             }
             QString pluginloader::getlibName(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return QString("");
                 QString file(*libfile);
                 delete libfile;
                 return _getlibName(file);
             }
             QString pluginloader::getlibDescription(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginDescriptionT plugindescription = (socexplorerpluginDescriptionT)lib->resolve("socexplorerpluginDescription");
                     if(plugindescription!=NULL)
                     {
                         QString description = plugindescription();
                         ////lib->unload();
                         lib->~QLibrary();
                         return description;
                     }
                 }
                 lib->~QLibrary();
                 return QObject::tr("Can't load Plugin.");
             }
             QString pluginloader::getlibDir(const QString Name)
             {
                 if(_self==NULL)init();
                 return *_cacheLookup(Name);
             }
             QString pluginloader::_getlibName(const QString fileName)
             {
                 QLibrary* lib = new QLibrary(fileName);
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginNameT pluginName = (socexplorerpluginAuthorT)lib->resolve("socexplorerpluginName");
                     if(pluginName!=NULL)
                     {
                         QString name = pluginName();
                         //lib->unload();
                         lib->~QLibrary();
                         return name;
                     }
                 }
                 lib->~QLibrary();
                 return QObject::tr("Can't load Plugin.");
             }
             int pluginloader::_getlibPID(const QString fileName)
             {
                 QLibrary* lib = new QLibrary(fileName);
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginpidT pluginpid = (socexplorerpluginpidT)lib->resolve("socexplorerpluginpid");
                     if(pluginpid!=NULL)
                     {
                         int pid = pluginpid();
                         //lib->unload();
                         lib->~QLibrary();
                         return pid;
                     }
                 }
                 lib->~QLibrary();
                 return 0;
             }
             int pluginloader::_getlibVID(const QString fileName)
             {
                 QLibrary* lib = new QLibrary(fileName);
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginvidT pluginvid = (socexplorerpluginvidT)lib->resolve("socexplorerpluginvid");
                     if(pluginvid!=NULL)
                     {
                         int vid = pluginvid();
                         //lib->unload();
                         lib->~QLibrary();
                         return vid;
                     }
                 }
                 lib->~QLibrary();
                 return 0;
             }
             QString* pluginloader::_cacheLookup(const QString Name)
             {
                 QString* libfile= new QString(_cache->first(Name));
                 if(!QFile::exists(*libfile))
                 {
                     scanFolders();
                     *libfile = _cache->first(Name);
                     if(QFile::exists(*libfile))return libfile;
                 }
                 else
                 {
                     return libfile;
                 }
                 delete libfile;
                 return NULL;
             }
             /*QString findlib(QString name)
             {
             }*/

src/SocExplorerEngine/pluginloader/pluginloader.h 0 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PLUGINLOADER_H
             #define PLUGINLOADER_H
             #include <QString>
             #include <QLibrary>
             #include <QObject>
             #include <QStringList>
             #include <socexplorerplugininterface.h>
             #include <socexplorerplugin.h>
             #include <pluginscache.h>
             /*
               Debug
             */
             #include <stdio.h>
             #define loadlib(filename)   QLibrary* lib = new QLibrary((fileName));\
                                         lib->load();\
                                         if(!lib->isLoaded())\
                                         {\
                                             return 0;\
                                         }
             class pluginloader
             {
             private:
                 static pluginloader* _self;
                 static PluginsCache* _cache;
                 static QStringList* _folderList;
                 ~pluginloader();
                 pluginloader();
             public:
                 static void init();
                 static pluginloader* self();
                 static int checklibrary(const QString fileName);
                 static bool isvalid(QString Name);
                 static socexplorerplugin* newsocexplorerplugin(const QString Name);
                 static QString getlibTypeStr(QString Name);
                 static pluginT getlibType(QString Name);
                 static QString getlibVersion(const QString Name);
                 static QString getlibPIDstr(const QString Name);
                 static QString getlibVIDstr(const QString Name);
                 static int getlibPID(const QString Name);
                 static int getlibVID(const QString Name);
                 static int libcanbechild(const QString Name);
                 static int libcanberoot(const QString Name);
                 static QString getlibAuthor(const QString Name);
                 static QString getlibName(const QString Name);
                 static QString getlibDescription(const QString Name);
                 static QString getlibDir(const QString Name);
                 static QString findlib(QString name);
                 static QList<PluginsCacheItem *> listAvailiables(bool rescan=true);
                 static void scanFolders();
                 static void showCache(){_cache->show();}
             private:
                 int p_checklibraryQlib(const QString fileName);
                 int p_checklibraryCustom(const QString fileName);
                 socexplorerplugin* p_newsocexplorerpluginQlib(const QString Name);
                 socexplorerplugin* p_newsocexplorerpluginCustom(const QString Name);
-                static QStringList readFoldersList(const QStringList confFiles);
                 static QString* _cacheLookup(const QString Name);
                 static QString _getlibName(const QString fileName);
                 static int _getlibPID(const QString fileName);
                 static int _getlibVID(const QString fileName);
             };
             #endif

src/SocExplorerEngine/pluginloader/pluginscache.cpp +3 -2

             #include "pluginscache.h"
             #include <QDebug>
+            #include <socexplorerengine.h>
             PluginsCacheItem::PluginsCacheItem(const QString &fileName, const QString &path, const QString &pluginName, int VID, int PID)
             {
                 this->fileName = new QString(fileName);
                 this->path = new QString(path);
                 this->pluginName = new QString(pluginName);
                 this->VID = VID;
                 this->PID = PID;
             }
             bool PluginsCacheItem::comparePluginName(const QString& pluginName)
             {
                 return (!this->pluginName->compare(pluginName));
             }
             bool PluginsCacheItem::comparefileName(const QString &fileName)
             {
                 bool same=false;
                 same|=!(this->fileName->compare(fileName));
                 same|=!(this->fileName->compare(fileName+".so"));
                 same|=!(this->fileName->compare("lib"+fileName+".so"));
                 return same;
             }
             bool PluginsCacheItem::comparefilePath(const QString &filePath)
             {
                 return (!QString::compare(*this->path +"/"+*this->fileName,filePath));
             }
             bool PluginsCacheItem::compareIDs(int VID,int PID)
             {
                 return (VID==this->VID && PID==this->PID);
             }
             bool PluginsCacheItem::compare(PluginsCacheItem *item)
             {
                 return comparefilePath(item->getpath()+"/"+item->getfileName());
             }
             PluginsCache::PluginsCache(QObject* parent)
                 :QObject(parent)
             {
                 this->items = new QList<PluginsCacheItem*>;
                 this->__view =NULL;
             }
             void PluginsCache::append(const QString &fileName, const QString &path, const QString &pluginName, int VID, int PID)
             {
                 PluginsCacheItem* item=new PluginsCacheItem(fileName,path,pluginName,  VID,  PID);
                 for(int i=0;i<this->items->count();i++)
                 {
                     if(this->items->at(i)->compare(item))
                     {
-                        qDebug()<< fileName << "already in the cache";
+                        SocExplorerEngine::message("PluginsCache",fileName + " already in the cache",3);
                         delete item;
                         return;
                     }
                 }
-                qDebug()<< fileName << "added to cache";
+                SocExplorerEngine::message("PluginsCache",fileName + " added to cache",3);
                 this->items->append(item);
             }
             QString PluginsCache::first(const QString& pluginName)
             {
                 for(int i=0;i<this->items->count();i++)
                 {
                     if(this->items->at(i)->comparePluginName(pluginName))
                     {
                         return QString(this->items->at(i)->getpath()+"/"+this->items->at(i)->getfileName());
                     }
                     if(this->items->at(i)->comparefileName(pluginName))
                     {
                         return QString(this->items->at(i)->getpath()+"/"+this->items->at(i)->getfileName());
                     }
                     if(this->items->at(i)->comparefilePath(pluginName))
                     {
                         return QString(this->items->at(i)->getpath()+"/"+this->items->at(i)->getfileName());
                     }
                 }
                 return QString("");
             }
             QString PluginsCache::first(int VID,int PID)
             {
                 for(int i=0;i<this->items->count();i++)
                 {
                     if(this->items->at(i)->compareIDs(VID,PID))
                     {
                         return QString(this->items->at(i)->getpath()+"/"+this->items->at(i)->getfileName());
                     }
                 }
                 return QString("");
             }
             QList<PluginsCacheItem *> PluginsCache::listDrivers()
             {
                 return *items;
             }
             void PluginsCache::flush()
             {
                 PluginsCacheItem* ptr;
                 for(int i=0;i<this->items->count();i++)
                 {
                     ptr=this->items->at(i);
                     this->items->removeAt(i);
                     delete ptr;
                 }
             }
             void PluginsCache::show()
             {
                 if(this->__view==NULL)this->__view = new QTableWidget(0,5);
                 if(!this->__view->isVisible())
                 {
                     this->__view->clear();
                     this->__view->setHorizontalHeaderLabels(QStringList()<<"File Name"<<"Path"<<"PluginName"<<"VID"<<"PID");
                     QTableWidgetItem* item;
                     this->__view->setRowCount(this->items->count());
                     for(int i=0;i<this->items->count();i++)
                     {
                         item = new QTableWidgetItem(items->at(i)->getfileName());
                         item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable);
                         this->__view->setItem(i,0,item);
                         item = new QTableWidgetItem(items->at(i)->getpath());
                         item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable);
                         this->__view->setItem(i,1,item);
                         item = new QTableWidgetItem(items->at(i)->getpluginName());
                         item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable);
                         this->__view->setItem(i,2,item);
                         item = new QTableWidgetItem(QString::number(items->at(i)->getVID()));
                         item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable);
                         this->__view->setItem(i,3,item);
                         item = new QTableWidgetItem(QString::number(items->at(i)->getPID()));
                         item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable);
                         this->__view->setItem(i,4,item);
                     }
                     this->__view->resizeRowsToContents();
                     this->__view->resizeColumnsToContents();
                     this->__view->show();
                 }
             }

src/SocExplorerEngine/pluginloader/unix/unixpluginloader.cpp +8 -7

             #include "unixpluginloader.h"
             #include <stdio.h>
             #include <QDebug>
+            #include <socexplorerengine.h>
             unixPluginLoader::unixPluginLoader(const QString &libPath)
             {
-                qDebug()<<"try to open "+libPath;
+                SocExplorerEngine::message("unixPluginLoader::unixPluginLoader","try to open "+libPath,3);
                 dlHandle = dlopen(libPath.toStdString().c_str(),RTLD_LAZY|RTLD_GLOBAL);
                 if(dlHandle==NULL)
-                    qDebug() << "Failed"<< dlerror();
+                    SocExplorerEngine::message("unixPluginLoader::unixPluginLoader",QString("Failed ") + dlerror(),3);
                 else
-                    qDebug() << "Success";
+                    SocExplorerEngine::message("unixPluginLoader::unixPluginLoader","Success " ,3);
                 this->libPath = libPath;
             }
             void *unixPluginLoader::resolve(const QString &symbol)
             {
                 if(dlHandle!=NULL)
                 {
-                    qDebug()<<"try to resolve "+symbol+" in "+libPath;
+                    SocExplorerEngine::message("unixPluginLoader::resolve","try to resolve "+symbol+" in "+libPath ,3);
                     void* sym =  dlsym (dlHandle, symbol.toStdString().c_str());
                     if(sym==NULL)
-                        qDebug() << "Failed"<< dlerror();
+                        SocExplorerEngine::message("unixPluginLoader::resolve",QString("Failed")+ dlerror() ,3);
                     else
-                        qDebug() << "Success";
+                        SocExplorerEngine::message("unixPluginLoader::resolve","Success",3);
                     return sym;
                 }
                 return NULL;
             }
             void unixPluginLoader::close()
             {
                 if(dlHandle!=NULL)
                 {
                     dlclose(dlHandle);
-                    qDebug() << dlerror();
+                    SocExplorerEngine::message("unixPluginLoader::close",dlerror(),3);
                 }
             }

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