HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r34:a265fede2b19

Added qint32 SocExplorerEngine::getEnumDeviceCount(socexplorerplugin *plugin, int VID, int PID)...

jeandet -

r34:a265fede2b19 default

parent child

Context file:

r34:a265fede2b19

Collapse all files

src/SocExplorerEngine/SOC/socmodel.cpp +13 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2013, 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 "socmodel.h"
             #include <socexplorerenumdevice.h>
             SOCModel::SOCModel(socexplorerplugin *rootDev, QObject *parent):
                 QObject(parent)
             {
                     p_rootDev = rootDev;
             }
             qint32 SOCModel::getEnumDeviceBaseAddress(int VID, int PID, int count)
             {
                 for(int i=0;i<p_enumeratedDevices.count();i++)
                 {
                     if((p_enumeratedDevices.at(i)->VID()==VID) && (p_enumeratedDevices.at(i)->PID()==PID))
                     {
                         if(count==0)
                         {
                             return p_enumeratedDevices.at(i)->baseAddress();
                         }
                         count--;
                     }
                 }
                 return -1;
             }
+            qint32 SOCModel::getEnumDeviceCount(int VID, int PID)
+            {
+                qint32 count =0;
+                for(int i=0;i<p_enumeratedDevices.count();i++)
+                {
+                    if((p_enumeratedDevices.at(i)->VID()==VID) && (p_enumeratedDevices.at(i)->PID()==PID))
+                    {
+                        count++;
+                    }
+                }
+                return count;
+            }
             socExplorerEnumDevice *SOCModel::addEnumDevice( int VID, int PID, qint32 baseAddress, const QString &name)
             {
                 if(enumDeviceExists(baseAddress))
                     return getEnumDevice(baseAddress);
                 socExplorerEnumDevice* device= new socExplorerEnumDevice(this,VID,PID,baseAddress,name);
                 p_enumeratedDevices.append(device);
                 return device;
             }
             int SOCModel::addEnumDevice(socExplorerEnumDevice *device)
             {
                 if(enumDeviceExists(device->baseAddress()))
                     return 0;
                 p_enumeratedDevices.append(device);
                 return 1;
             }
             bool SOCModel::enumDeviceExists(qint32 baseAddress)
             {
                 for(int i=0;i<p_enumeratedDevices.count();i++)
                 {
                     if(p_enumeratedDevices.at(i)->baseAddress()==baseAddress)
                         return true;
                 }
                 return false;
             }
             socExplorerEnumDevice *SOCModel::getEnumDevice(qint32 baseAddress)
             {
                 for(int i=0;i<p_enumeratedDevices.count();i++)
                 {
                     if(p_enumeratedDevices.at(i)->baseAddress()==baseAddress)
                         return p_enumeratedDevices.at(i);
                 }
                 return NULL;
             }
             void SOCModel::writeReg(qint32 address, qint32 value)
             {
                 uint valueInt=value,addressInt=address;
                 p_rootDev->Write(&valueInt,1,addressInt);
             }
             qint32 SOCModel::readReg(qint32 address)
             {
                 uint valueInt=0,addressInt=address;
                 p_rootDev->Read(&valueInt,1,addressInt);
                 return (qint32)valueInt;
             }

src/SocExplorerEngine/SOC/socmodel.h +1 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2013, 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 REGISTERSMODEL_H
             #define REGISTERSMODEL_H
             #include <QString>
             #include <QList>
             #include <QObject>
             #include <QDomDocument>
             #include <QDomElement>
             #include "registerdata.h"
             #include <socclk.h>
             #include <socexplorerplugin.h>
             //#include <socexplorerenumdevice.h>
             class socExplorerEnumDevice;
             class registerBitFieldModel
             {
             public:
                 registerBitFieldModel(const QString& name,const QString& description,
                                       int size, int offset, bool rw)
                 {
                     this->name = name;
                     this->description = description;
                     this->size = size;
                     this->offset = offset;
                     this->rw = rw;
                 }
                 QString name;
                 QString description;
                 int size;
                 int offset;
                 bool rw;
             };
             class registerModel
             {
             public:
                 registerModel(const QString& name,qint32 offset)
                 {
                     this->name = name;
                     this->offset = offset;
                 }
                 QString name;
                 qint32 offset;
                 QList<registerBitFieldModel> bitfields;
             };
             class peripheralModel
             {
             public:
                 peripheralModel(const QString& name)
                 {
                     this->name = name;
                 }
                 QString name;
                 QList<registerModel> registers;
             };
             class SOCEXPLORER_EXPORT SOCModel :public QObject
             {
                 Q_OBJECT
             public:
                 SOCModel(socexplorerplugin* rootDev,QObject* parent=0);
                // qint32 getRegValue(qint32 baseAddress);
                 bool isRootDev(socexplorerplugin* rootDev)
                 {
                     return rootDev==p_rootDev;
                 }
                 bool enumDeviceExists(qint32 baseAddress);
                 socExplorerEnumDevice *getEnumDevice(qint32 baseAddress);
             public slots:
                 //void setRegValue(qint32 baseAddress,qint32 value);
                 qint32 getEnumDeviceBaseAddress(int VID,int PID,int count=0);
+                qint32 getEnumDeviceCount(int VID,int PID);
                 socExplorerEnumDevice* addEnumDevice(int VID, int PID, qint32 baseAddress, const QString& name);
                 int addEnumDevice(socExplorerEnumDevice* device);
                 void writeReg(qint32 address,qint32 value);
                 qint32 readReg(qint32 address);
             private:
                 socexplorerplugin* p_rootDev;
                 QList<socExplorerEnumDevice*> p_enumeratedDevices;
                 QList<SOCclk*> clktree;
             };
             #endif // REGISTERSMODEL_H

src/SocExplorerEngine/engine/socexplorerengine.cpp +19 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
             ----------------------------------------------------------------------------*/
             #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);
             }
+            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;
             }
             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;
             }
             void SocExplorerEngine::setLogLevel(int level)
             {
                 if(!_self)
                     init();
                 printf("Set log level to %d\n",level);
                 loglvl = level;
             }

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>
             #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;
                 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 QString pluginFolder(){return QString(SOCEXPLORER_PLUGINS_INSTALL_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 setLogLevel(int level);
             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);
             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/plugins/socexplorerplugin.prf +1 -1

             win32 {
                 DEFINES += WIN32
                 DEFINES += WINTRANSLATIONPATH
                 DEFINES += SOCEXPLORER_TRANSLATION_PATH="\"\\\"./translations"\\\"\"
                 SOCEXPLORER_TRANSLATION_INSTALL_PATH = translations
                 SOCEXPLORER_INSTALL_PATH =
                 SOCEXPLORER_PLUGINS_INSTALL_PATH = $$SOCEXPLORER_PLUGIN_PATH
             }
             unix {
                 DEFINES += UNIX
                 DEFINES += UNIXTRANSLATIONPATH
                 DEFINES += SOCEXPLORER_TRANSLATION_PATH="\"\\\"/etc/SocExplorer/translations"\\\"\"
                 SOCEXPLORER_TRANSLATION_INSTALL_PATH = /etc/SocExplorer/translations
                 SOCEXPLORER_INSTALL_PATH = /usr/local/SocExplorer
                 SOCEXPLORER_ROOT_PLUGINS_INSTALL_PATH = $$system(echo $HOME)
                 SOCEXPLORER_PLUGINS_INSTALL_PATH = $${SOCEXPLORER_ROOT_PLUGINS_INSTALL_PATH}"/.SocExplorer/plugins"
             }
-            isEmpty(SOCEXPLORER_SDK_BUILD){
+            isEmpty( SOCEXPLORER_SDK_BUILD ){
                 message( "building a plugin" )
                 QT += core gui xml
                 contains(QT_MAJOR_VERSION, 5) {
                     QT += widgets
                 }
                 CONFIG += pythonqt
                 TEMPLATE = lib
                 win32:CONFIG += dll
                 win32:CONFIG -= static
                 OBJECTS_DIR = obj
                 MOC_DIR = moc
                 DESTDIR = bin
                 CONFIG(debug, debug|release) {
                   DEBUG_EXT = _d
                 } else {
                   DEBUG_EXT =
                 }
                 unix{
                     target.path    = $${SOCEXPLORER_PLUGINS_INSTALL_PATH}
                     INSTALLS += target
                     LIBS+= -lsocexplorerengine$${DEBUG_EXT} -lsocexplorercommon$${DEBUG_EXT}
                 }
                 win32{
                     INCLUDEPATH += $$[QT_INSTALL_HEADERS]/SocExplorer/common/libelf
                     LIBS+=$$[QT_INSTALL_LIBS]/socexplorerengine$${DEBUG_EXT}.dll $$[QT_INSTALL_LIBS]/socexplorercommon$${DEBUG_EXT}.dll
                 }
                 DEFINES += SOCEXPLORER_LIBRARY
                 SOURCES += \
                     $$[QT_INSTALL_HEADERS]/SocExplorer/pluginsInterface/socexplorerplugininterface.cpp
                 HEADERS += \
                     $$[QT_INSTALL_HEADERS]/SocExplorer/genericPySysdriver.h \
                     $$[QT_INSTALL_HEADERS]/SocExplorer/socexplorerplugin.h
                 INCLUDEPATH += $$[QT_INSTALL_HEADERS]/SocExplorer/common \
                                  $$[QT_INSTALL_HEADERS]/SocExplorer \
                                 $$[QT_INSTALL_HEADERS]/SocExplorer/pluginsInterface
             }else{
                 message( "building SocExplorer" )
                 HEADERS += \
                     $$[QT_INSTALL_HEADERS]/SocExplorer/genericPySysdriver.h \
                     $$[QT_INSTALL_HEADERS]/SocExplorer/socexplorerplugin.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