INotificator *PluginLoader::load(QString lib)
{
QPluginLoader pluginLoader(lib); // linux_libnotifyPxNotifyPlugin
QGenericPlugin* plugin = (QGenericPlugin*)pluginLoader.instance();
if (!pluginLoader.isLoaded()) {
qWarning() << "Plugin" << lib << "not loaded!" << pluginLoader.errorString();
return nullptr;
}
if (!checkNames(plugin->objectName(), lib)) {
qWarning() << "Loaded plugin have name" << plugin->objectName()
<< ", but trying loaded" << lib
<< ". Aborted! Plugin not loaded!";
return nullptr;
}
INotificator* inotiticator = (INotificator*)plugin->create("", "");
if (!inotiticator) {
qWarning() << "Plugin" << lib << "cannot instance INotificator. Aborted! Plugin not loaded!";
return nullptr;
}
qDebug() << "Plugin" << lib << "loaded!";
return load(lib, inotiticator);
}
void ServiceHelperPrivate::loadPlugin()
{
QString libPath = getenv("ACCOUNTS_UI_PLUGIN_DIR");
if (!libPath.isEmpty()) {
libPath = QDir::cleanPath(libPath) + QDir::separator();
} else {
libPath = "/usr/lib/AccountsUI/";
}
QString libName("lib%1plugin.so");
//use the xml element plugin to get the plugin name
QDomElement root = domDocument.documentElement();
QDomElement pluginElement = root.firstChildElement("plugin");
QString path;
path = libPath + libName.arg(pluginElement.text());
//fallback use id as a plugin name
if (!QFile::exists(path)) {
QString serviceId = root.attribute("id");
path = libPath + libName.arg(serviceId);
}
QObject *plugin = 0;
qDebug() << "Loading plugin " << path;
QPluginLoader pluginLoader(path);
if (QFile::exists(path)) {
plugin = pluginLoader.instance();
}
this->plugin = qobject_cast<ServicePluginInterface *>(plugin);
}
void QtTrader::createGUI ()
{
QMenuBar *menuBar = new QMenuBar();
setMenuBar(menuBar);
QMenu *menu = new QMenu("&Help");
QAction* a = new QAction(QIcon(":icons/info"), tr("&About"), this);
a->setIconVisibleInMenu(true);
connect(a, SIGNAL(activated()), this, SLOT(about()));
menu->addAction(a);
menuBar->addMenu(menu);
statusBar()->showMessage(tr("Ready"), 2000);
QSettings settings(g_settings);
settings.beginGroup("plugins");
QStringList value = settings.value("gui").toStringList();
settings.endGroup();
QToolBar* toolbar = new QToolBar();
for(int i = 0; i<value.size(); i++){
toolbar->addAction(value.at(i), this, SLOT(pluginLoader()));
}
toolbar->show();
toolbar->setObjectName("MainToolbar");
addToolBar(toolbar);
setUnifiedTitleAndToolBarOnMac(true);
}
int main(int argc, char *argv[])
{
if(argc < 2)
{ qDebug() << "Error! Pass in Plugin File Name!"; return -1; }
QApplication app(argc,argv);
QString pluginFilePath = QString(argv[1]);
QPluginPloader pluginLoader(pluginFilePath);
return app.exec();
}
bool Slave::init(void)
{
// Check on which hardware we are running based on the info in /proc/cpuinfo.
// Defaulting to Generic X86
QString hardwarePlugin("plugins/GenericX86/libgeneric_x86.so");
QFile cpuinfo("/proc/cpuinfo");
if (cpuinfo.open(QIODevice::ReadOnly | QIODevice::Text)) {
qDebug() << "Reading cpuinfo";
QByteArray content = cpuinfo.readAll();
// Check for Gumstix Overo
if (content.contains("Gumstix Overo")) {
qDebug() << "Detected Gumstix Overo";
hardwarePlugin = "plugins/GumstixOvero/libgumstix_overo.so";
}
cpuinfo.close();
}
qDebug() << "Loading hardware plugin:" << hardwarePlugin;
// FIXME: add proper application specific plugin installation prefix.
// For now we just seach so that the plugins in source code directories work.
// FIXME: these doesn't affect pluginLoader?
this->addLibraryPath("./plugins/GenericX86");
this->addLibraryPath("./plugins/GumstixOvero");
QPluginLoader pluginLoader(hardwarePlugin);
QObject *plugin = pluginLoader.instance();
if (plugin) {
hardware = qobject_cast<Hardware*>(plugin);
if (!hardware) {
qCritical("Failed cast Hardware");
}
} else {
qCritical("Failed to load plugin: %s", pluginLoader.errorString().toUtf8().data());
qCritical("Search path: %s", this->libraryPaths().join(",").toUtf8().data());
}
// FIXME: get serial device path from hardware plugin?
cb = new ControlBoard("/dev/ttyUSB0");
if (!cb->init()) {
qCritical("Failed to initialize ControlBoard");
// CHECKME: to return false or not to return false (and do clean up)?
} else {
// Set ControlBoard frequency to 50Hz to match standard servos
cb->setPWMFreq(50);
}
return true;
}
//---------------------------------------------------------------------
// PosSettingsPluginsLoader::loadPlugins
//
//---------------------------------------------------------------------
QList<PosSettingsAdvInterface*> PosSettingsPluginsLoader::loadPlugins()
{
qDebug() << "+ PosSettingsPluginsLoader::loadPlugins()";
// parse the default cen rep key value which is used to determine
// the order of loading the default positioning settings plugins
ParseCenRepKey();
// List containing the plugins implementing the PositioningSettingsAdvancedInterface
QList<PosSettingsAdvInterface*> pluginsList;
// Check for the files under the positioningsettings directory
QDir pluginsDir(PLUGIN_PATH + QDir::separator());
QFileInfoList fileInfoList = pluginsDir.entryInfoList();
// check each file in this directory,only if its a dll give it to the
// plugin loader
foreach ( const QFileInfo &fileInfo, fileInfoList )
{
QString fileName = fileInfo.absoluteFilePath();
qDebug() << "Filename: " << fileName;
if (!QLibrary::isLibrary(fileName))
{
continue;
}
// load the dlls using QPluginLoader
QPluginLoader pluginLoader(pluginsDir.absoluteFilePath(fileName));
qDebug() << "Plugin Filename: " << pluginsDir.absoluteFilePath(fileName);
QObject *plugin = pluginLoader.instance();
// Check if the plugin found is an implementation of the
// PosSettingsAdvInterface,if yes add it to the plugins list
if (plugin)
{
PosSettingsAdvInterface* advancedInterface = qobject_cast<
PosSettingsAdvInterface *> (plugin);
if (advancedInterface)
{
QString dllName = fileInfo.baseName();
// check the position into which the plugin needs to be
// inserted if it is one of the default plugins
for (int i = 0; i < mDllNameList.count(); i++)
{
if (dllName.compare(mDllNameList[i],Qt::CaseInsensitive) == KErrNone)
{
pluginsList.insert(i, advancedInterface);
break;
}
}
}
}
}
void ActionFactory::loadActionPack(const QString &filename, const QString &locale)
{
QPluginLoader pluginLoader(filename);
QObject *actionPackObject = pluginLoader.instance();
QString shortFilename = QFileInfo(filename).baseName();
if(!actionPackObject)
{
emit actionPackLoadError(tr("%1: \"%2\"").arg(shortFilename).arg(pluginLoader.errorString()));
return;
}
ActionPack *actionPack = qobject_cast<ActionPack *>(actionPackObject);
if(!actionPack)
{
emit actionPackLoadError(tr("%1: invalid definition version").arg(shortFilename));
return;
}
Tools::installTranslator(QString("actionpack%1").arg(actionPack->id()), locale);
actionPack->createDefinitions();
for(ActionDefinition *definition: actionPack->actionsDefinitions())
{
if(actionDefinition(definition->id()))
{
emit actionPackLoadError(tr("%1: <b>%2</b> already loaded").arg(shortFilename).arg(definition->id()));
continue;
}
if(definition->worksUnderThisOS())
{
QStringList missingFeatures;
if(!definition->requirementCheck(missingFeatures))
{
emit actionPackLoadError(tr("%1: <b>%2</b> cannot be loaded:<ul><li>%3</ul>")
.arg(shortFilename)
.arg(definition->id())
.arg(missingFeatures.join("<li>")));
continue;
}
}
mActionDefinitions << definition;
}
actionPack->setFilename(filename);
mActionPacks << actionPack;
}
void g19daemon::loadPlugins()
{
PluginInterface *pluginint;
QDir pluginsDir(qApp->applicationDirPath());
QString name;
name = settings->value("ActivePlugin").toString();
pluginsDir.cd(PLUGINS_DIR);
QDirIterator iterator(pluginsDir.absolutePath(), QStringList() << "*.so", QDir::Files, QDirIterator::NoIteratorFlags);
while (iterator.hasNext())
{
iterator.next();
QString filename = iterator.fileName();
QPluginLoader pluginLoader(iterator.filePath());
pluginLoader.setLoadHints(QLibrary::ResolveAllSymbolsHint);
QObject *plugin = pluginLoader.instance();
if (plugin)
{
pluginint = qobject_cast<PluginInterface *>(plugin);
if (pluginint)
{
QObject *signalsource = pluginint->getQObject();
connect(signalsource, SIGNAL(doAction(gAction, void *)), this, SLOT(doAction(gAction, void *)));
if (pluginint->isPopup())
{
PopupPlugins.append(pluginint);
}
else
{
plugins.append(pluginint);
if (pluginint->getName().compare(name) == 0)
{
activePlugin = plugins.indexOf(pluginint);
}
}
}
}
else
{
QErrorMessage err(this);
err.showMessage(pluginLoader.errorString());
qDebug() << "\tError: " << pluginLoader.errorString();
}
}
static KonqViewFactory tryLoadingService(KService::Ptr service)
{
KPluginLoader pluginLoader(*service);
pluginLoader.setLoadHints(QLibrary::ExportExternalSymbolsHint); // #110947
KPluginFactory* factory = pluginLoader.factory();
if (!factory) {
KMessageBox::error(0,
i18n("There was an error loading the module %1.\nThe diagnostics is:\n%2",
service->name(), pluginLoader.errorString()));
return KonqViewFactory();
}
else {
return KonqViewFactory(service->library(), factory);
}
}
void TCPServer::loadDriver()
{
QPluginLoader pluginLoader("libposjs.so");
pluginLoader.load();
QObject *plugin = pluginLoader.instance();
posdriver = qobject_cast<POSDriverInterface*>(plugin);
if(posdriver)
{
qDebug() << "libposjs OK...!!!";
}
else
{
qDebug() << "libposjs not found...!!!";
}
}
/** Load a plugin by its location on the hard drive. */
bool PluginManager::loadPlugin(const QString &pluginAbsPath)
{
QPluginLoader pluginLoader(pluginAbsPath, this);
QObject *plugin = pluginLoader.instance();
if (plugin) {
BasicPlugin *basic = dynamic_cast<BasicPlugin*>(plugin);
basic->setParent(this);
SettingsPrivate *settings = SettingsPrivate::instance();
if (basic) {
PluginInfo pluginInfo;
pluginInfo.setAbsFilePath(pluginAbsPath);
pluginInfo.setPluginName(basic->name());
pluginInfo.setVersion(basic->version());
pluginInfo.setConfigPage(basic->isConfigurable());
pluginInfo.setEnabled(true);
settings->addPlugin(pluginInfo);
if (basic->isConfigurable()) {
QString pluginLang(":/translations/" + basic->name() + "_" + settings->language());
if (basic->translator.load(pluginLang)) {
QApplication::installTranslator(&basic->translator);
}
}
// Keep references of loaded plugins, to be able to unload them later
_loadedPlugins.insert(pluginAbsPath, basic);
} else {
return false;
}
basic->init();
if (MediaPlayerPlugin *mediaPlayerPlugin = qobject_cast<MediaPlayerPlugin*>(plugin)) {
this->loadMediaPlayerPlugin(mediaPlayerPlugin);
} else if (ItemViewPlugin *itemViewPlugin = qobject_cast<ItemViewPlugin*>(plugin)) {
this->loadItemViewPlugin(itemViewPlugin);
} else if (RemoteMediaPlayerPlugin *remoteMediaPlayerPlugin = qobject_cast<RemoteMediaPlayerPlugin*>(plugin)) {
this->loadRemoteMediaPlayerPlugin(remoteMediaPlayerPlugin);
} else if (TagEditorPlugin *tagEditorPlugin = qobject_cast<TagEditorPlugin*>(plugin)) {
this->loadTagEditorPlugin(tagEditorPlugin);
}
}
return plugin != nullptr;
}
bool FactoryPrivate::createBackend()
{
Q_ASSERT(m_backendObject == 0);
#ifndef QT_NO_PHONON_PLATFORMPLUGIN
PlatformPlugin *f = globalFactory->platformPlugin();
if (f) {
m_backendObject = f->createBackend();
}
#endif //QT_NO_PHONON_PLATFORMPLUGIN
if (!m_backendObject) {
ensureLibraryPathSet();
// could not load a backend through the platform plugin. Falling back to the default
// (finding the first loadable backend).
const QLatin1String suffix("/phonon_backend/");
foreach (QString libPath, QCoreApplication::libraryPaths()) {
libPath += suffix;
const QDir dir(libPath);
if (!dir.exists()) {
pDebug() << Q_FUNC_INFO << dir.absolutePath() << "does not exist";
continue;
}
foreach (const QString &pluginName, dir.entryList(QDir::Files)) {
QPluginLoader pluginLoader(libPath + pluginName);
if (!pluginLoader.load()) {
pDebug() << Q_FUNC_INFO << " load failed:"
<< pluginLoader.errorString();
continue;
}
pDebug() << pluginLoader.instance();
m_backendObject = pluginLoader.instance();
if (m_backendObject) {
break;
}
// no backend found, don't leave an unused plugin in memory
pluginLoader.unload();
}
if (m_backendObject) {
break;
}
}
/**
* @param filename File where to load plugin from
*
*/
void PluginManager::loadPlugin(const QString & filename) {
QPluginLoader pluginLoader(filename);
QObject * plugin = pluginLoader.instance();
if (plugin == 0) {
// FIXME - inform about invalid plugin format
return;
}
DictionaryShelfPluginInterface * shelf =
qobject_cast<DictionaryShelfPluginInterface *>(plugin);
if (shelf == 0) {
// FIXME - inform about invalid plugin interface
return;
}
// everythings seems fine, let's add the dictionaries to the
// local list
DictionaryList dicts = shelf->getDictionaries();
DictionaryList::iterator e = dicts.end();
for (DictionaryList::iterator i = dicts.begin(); i != e; ++i) {
addDictionary(*i);
}
}
bool PluginLoader::findPlugin(const QDir& pluginsDir)
{
bool foundFlag = false;
for (const QString& fileName : pluginsDir.entryList({PLUGIN_PREFIX + QLatin1String("*")}, QDir::Files))
{
QPluginLoader pluginLoader(pluginsDir.absoluteFilePath(fileName));
IPlugin *iplugin = qobject_cast<IPlugin *>(pluginLoader.instance());
if (iplugin)
{
foundFlag = true;
qDebug() << "Loading the plugin:" << iplugin->name();
m_pluginMap.insert(iplugin->name(), iplugin);
m_availablePlugins.insert(iplugin->name());
}
else
{
qWarning() << pluginLoader.errorString();
qWarning() << "Cannot load the plugin " << fileName;
}
}
return foundFlag;
}
PlatformPlugin *FactoryPrivate::platformPlugin()
{
if (m_platformPlugin) {
return m_platformPlugin;
}
if (m_noPlatformPlugin) {
return 0;
}
#ifndef QT_NO_DBUS
if (!QCoreApplication::instance() || QCoreApplication::applicationName().isEmpty()) {
pWarning() << "Phonon needs QCoreApplication::applicationName to be set to export audio output names through the DBUS interface";
}
#endif
Q_ASSERT(QCoreApplication::instance());
const QByteArray platform_plugin_env = qgetenv("PHONON_PLATFORMPLUGIN");
if (!platform_plugin_env.isEmpty()) {
QPluginLoader pluginLoader(QString::fromLocal8Bit(platform_plugin_env.constData()));
if (pluginLoader.load()) {
m_platformPlugin = qobject_cast<PlatformPlugin *>(pluginLoader.instance());
if (m_platformPlugin) {
return m_platformPlugin;
}
}
}
const QString suffix(QLatin1String("/phonon_platform/"));
ensureLibraryPathSet();
QDir dir;
dir.setNameFilters(
!qgetenv("KDE_FULL_SESSION").isEmpty() ? QStringList(QLatin1String("kde.*")) :
(!qgetenv("GNOME_DESKTOP_SESSION_ID").isEmpty() ? QStringList(QLatin1String("gnome.*")) :
QStringList())
);
dir.setFilter(QDir::Files);
const QStringList libPaths = QCoreApplication::libraryPaths();
forever {
for (int i = 0; i < libPaths.count(); ++i) {
const QString libPath = libPaths.at(i) + suffix;
dir.setPath(libPath);
if (!dir.exists()) {
continue;
}
const QStringList files = dir.entryList(QDir::Files);
for (int i = 0; i < files.count(); ++i) {
QPluginLoader pluginLoader(libPath + files.at(i));
if (!pluginLoader.load()) {
pDebug() << Q_FUNC_INFO << " platform plugin load failed:"
<< pluginLoader.errorString();
continue;
}
pDebug() << pluginLoader.instance();
QObject *qobj = pluginLoader.instance();
m_platformPlugin = qobject_cast<PlatformPlugin *>(qobj);
pDebug() << m_platformPlugin;
if (m_platformPlugin) {
connect(qobj, SIGNAL(objectDescriptionChanged(ObjectDescriptionType)),
SLOT(objectDescriptionChanged(ObjectDescriptionType)));
return m_platformPlugin;
} else {
delete qobj;
pDebug() << Q_FUNC_INFO << dir.absolutePath() << "exists but the platform plugin was not loadable:" << pluginLoader.errorString();
pluginLoader.unload();
}
}
}
if (dir.nameFilters().isEmpty()) {
break;
}
dir.setNameFilters(QStringList());
}
pDebug() << Q_FUNC_INFO << "platform plugin could not be loaded";
m_noPlatformPlugin = true;
return 0;
}
bool FactoryPrivate::createBackend()
{
#ifndef QT_NO_LIBRARY
Q_ASSERT(m_backendObject == 0);
#ifndef QT_NO_PHONON_PLATFORMPLUGIN
PlatformPlugin *f = globalFactory->platformPlugin();
if (f) {
m_backendObject = f->createBackend();
}
#endif //QT_NO_PHONON_PLATFORMPLUGIN
if (!m_backendObject) {
ensureLibraryPathSet();
// could not load a backend through the platform plugin. Falling back to the default
// (finding the first loadable backend).
const QLatin1String suffix("/phonon_backend/");
const QStringList paths = QCoreApplication::libraryPaths();
for (int i = 0; i < paths.count(); ++i) {
const QString libPath = paths.at(i) + suffix;
const QDir dir(libPath);
if (!dir.exists()) {
pDebug() << Q_FUNC_INFO << dir.absolutePath() << "does not exist";
continue;
}
QStringList plugins(dir.entryList(QDir::Files));
#ifdef Q_OS_SYMBIAN
/* On Symbian OS we might have two plugins, one which uses Symbian
* MMF framework("mmf"), and one which uses Real Networks's
* Helix("hxphonon"). We prefer the latter because it's more
* sophisticated, so we make sure the Helix backend is attempted
* to be loaded first, and the MMF backend is used for backup. */
{
const int helix = plugins.indexOf(QLatin1String("hxphonon"));
if (helix != -1)
plugins.move(helix, 0);
}
#endif
const QStringList files = dir.entryList(QDir::Files);
for (int i = 0; i < files.count(); ++i) {
QPluginLoader pluginLoader(libPath + files.at(i));
if (!pluginLoader.load()) {
pDebug() << Q_FUNC_INFO << " load failed:"
<< pluginLoader.errorString();
continue;
}
pDebug() << pluginLoader.instance();
m_backendObject = pluginLoader.instance();
if (m_backendObject) {
break;
}
// no backend found, don't leave an unused plugin in memory
pluginLoader.unload();
}
if (m_backendObject) {
break;
}
}
if (!m_backendObject) {
pWarning() << Q_FUNC_INFO << "phonon backend plugin could not be loaded";
return false;
}
}
connect(m_backendObject, SIGNAL(objectDescriptionChanged(ObjectDescriptionType)),
SLOT(objectDescriptionChanged(ObjectDescriptionType)));
return true;
#else //QT_NO_LIBRARY
pWarning() << Q_FUNC_INFO << "Trying to use Phonon with QT_NO_LIBRARY defined. "
"That is currently not supported";
return false;
#endif
}
//FIXME: keep loaded plugins in own plugin manager and
//unload plugins to let load new version without
//the need to restart the application
void RackWindow::loadPlugin(QWidget *pluginHost)
{
QDir pluginsDir(qApp->applicationDirPath());
#if defined(Q_OS_WIN)
if (pluginsDir.dirName().toLower() == "debug" || pluginsDir.dirName().toLower() == "release")
pluginsDir.cdUp();
#elif defined(Q_OS_MAC)
if (pluginsDir.dirName() == "MacOS") {
pluginsDir.cdUp();
pluginsDir.cdUp();
pluginsDir.cdUp();
}
#endif
if (!pluginsDir.cd("plugins"))
{
QMessageBox::information(this, "Error", "No plugin folder found");
return;
}
QStringList pluginList = pluginsDir.entryList(QDir::Files);
RSelectPluginDialog pluginDialog(this);
pluginDialog.pluginListWidget->addItems(pluginList);
pluginDialog.pluginListWidget->setCurrentRow(0);
if (pluginDialog.exec())
{
// bool ok;
// int newPluginIndex = RSelectPluginDialog::getIndex(this, pluginList, &ok);
// if (ok) {
//QString fileName = pluginsDir.entryList(QDir::Files).at(newPluginIndex);
QString fileName = pluginsDir.entryList(QDir::Files).at(pluginDialog.pluginListWidget->currentRow());
QPluginLoader pluginLoader(pluginsDir.absoluteFilePath(fileName));
QObject *plugin = pluginLoader.instance();
///test
// QList<QPluginLoader *> loadedPlugins = findChildren<QPluginLoader *>();
// QObject *plugin = 0;
// for (int i = 0; i < loadedPlugins.size(); ++i) {
// if (loadedPlugins.at(i)->fileName() == pluginsDir.absoluteFilePath(fileName)) {
// plugin = loadedPlugins.at(i)->instance();
// break;
// }
// }
// if (!plugin) {
// QPluginLoader *pluginLoader = new QPluginLoader(pluginsDir.absoluteFilePath(fileName), this);
// plugin = pluginLoader->instance();
// }
//debug code
qDebug() << "we have the following plugins loaded:";
QList<QPluginLoader *> debugPlugins = findChildren<QPluginLoader *>();
for (int i = 0; i < debugPlugins.size(); ++i) {
qDebug() << debugPlugins.at(i)->fileName();
}
//////////
// m_pluginLoader = new QPluginLoader(pluginsDir.absoluteFilePath(fileName), this);
// QObject *plugin = m_pluginLoader->instance();
/////////////////
if (plugin)
{
IWidgetPlugin *widgetPlugin = qobject_cast<IWidgetPlugin *>(plugin);
if (widgetPlugin)
{
QWidget *newWidget = widgetPlugin->createRWidget(m_coreImpl, this);
//get pointers from pluginhost:
QStackedWidget *pluginStack = pluginHost->findChild<QStackedWidget *>("rackPluginStack");
QToolBar *pluginHostToolBar = pluginHost->findChild<QToolBar *>("rackPluginHostToolBar");
QToolBar *pluginToolBar = pluginHost->property("pluginToolBar").value<QToolBar *>();
QSignalMapper *sm = pluginHost->findChild<QSignalMapper *>("rackPluginSwitchMapper");
QActionGroup *ag = pluginHostToolBar->findChild<QActionGroup *>();
//add plugin widget to the widget stack:
pluginStack->setCurrentIndex(pluginStack->addWidget(newWidget));
//create action for the toolbars:
QAction *act = new QAction(widgetPlugin->name(), ag);
act->setCheckable(true);
act->setChecked(true);
//qt bugfix: set transparent dummy icon to move button text down or right
act->setIcon(QIcon(":/images/transparent-icon.png"));
//create button for pluginhost toolbar:
QToolButton *tb = new QToolButton;
tb->setObjectName(QLatin1String(newWidget->metaObject()->className()) + "ToolButton");
tb->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
tb->setFocusPolicy(Qt::NoFocus);
tb->setDefaultAction(act);
RPushButton *settingsButton = new RPushButton;
settingsButton->setObjectName("rackPluginHostToolBarSettingsButton");
RPushButton *deleteButton = new RPushButton;
deleteButton->setObjectName("rackPluginHostToolBarDeleteButton");
QHBoxLayout *hl = new QHBoxLayout(tb);
hl->setSpacing(0);
hl->setContentsMargins(0,0,1,0);
hl->addStretch();
hl->addWidget(settingsButton);
hl->addWidget(deleteButton);
pluginHostToolBar->addWidget(tb);
//create button for plugin toolbar:
QToolButton *tb1 = new QToolButton;
tb1->setObjectName(QLatin1String(newWidget->metaObject()->className()) + "ToolButton");
tb1->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
tb1->setFocusPolicy(Qt::NoFocus);
tb1->setDefaultAction(act);
pluginToolBar->addWidget(tb1);
//connect action trigger to PluginSwitchMapper;
QObject::connect(act, SIGNAL(triggered()), sm, SLOT(map()));
sm->setMapping(act, newWidget);
//connect delete signal
//remove act from actiongroup and delete it:
QObject::connect(deleteButton, SIGNAL(clicked()), m_mapperClosePlugin, SLOT(map()));
m_mapperClosePlugin->setMapping(deleteButton, act);
QObject::connect(deleteButton, SIGNAL(clicked()), newWidget, SLOT(deleteLater()));
QObject::connect(deleteButton, SIGNAL(clicked()), tb1, SLOT(deleteLater()));
QObject::connect(deleteButton, SIGNAL(clicked()), tb, SLOT(deleteLater()));
//connect settings signal
//if (plugin has settings) ...
//QObject::connect(settingsButton, SIGNAL(clicked()),
}
}
else
{
QMessageBox::information(this, "Error", "Could not load the plugin");
qDebug() << pluginLoader.errorString();
}
}
}
void
DrishtiImport::registerPlugins()
{
m_pluginFileTypes.clear();
m_pluginFileDLib.clear();
m_pluginDirTypes.clear();
m_pluginDirDLib.clear();
QString plugindir = qApp->applicationDirPath() + QDir::separator() + "importplugins";
QStringList filters;
#if defined(Q_OS_WIN32)
filters << "*.dll";
#endif
#ifdef Q_OS_MACX
// look in drishti.app/importplugins
QString sep = QDir::separator();
plugindir = qApp->applicationDirPath()+sep+".."+sep+".."+sep+"importplugins";
filters << "*.dylib";
#endif
#if defined(Q_OS_LINUX)
filters << "*.so";
#endif
QDir dir(plugindir);
dir.setFilter(QDir::Files);
dir.setNameFilters(filters);
QFileInfoList list = dir.entryInfoList();
if (list.size() == 0)
{
QMessageBox::information(0, "Error", QString("No plugins found in %1").arg(plugindir));
close();
}
for (int i=0; i<list.size(); i++)
{
QString pluginflnm = list.at(i).absoluteFilePath();
QPluginLoader pluginLoader(pluginflnm);
QObject *plugin = pluginLoader.instance();
if (plugin)
{
VolInterface *vi = qobject_cast<VolInterface *>(plugin);
if (vi)
{
QStringList rs = vi->registerPlugin();
int idx = rs.indexOf("file");
if (idx == -1) idx = rs.indexOf("files");
if (idx >= 0)
{
if (rs.size() >= idx+1)
{
m_pluginFileTypes << rs[idx+1];
m_pluginFileDLib << pluginflnm;
}
else
QMessageBox::information(0, "Error",
QString("Received illegal files register string [%1] for plugin [%2]").\
arg(rs.join(" ")).arg(pluginflnm));
}
idx = rs.indexOf("dir");
if (idx == -1) idx = rs.indexOf("directory");
if (idx >= 0)
{
QPair<QString, QStringList> ft;
if (rs.size() >= idx+1)
{
m_pluginDirTypes << rs[idx+1];
m_pluginDirDLib << pluginflnm;
}
else
QMessageBox::information(0, "Error",
QString("Received illegal directory register string [%1] for plugin [%2]").\
arg(rs.join(" ")).arg(pluginflnm));
}
}
}
else
{
QMessageBox::information(0, "Error", QString("Cannot load %1").arg(pluginflnm));
}
}
QMenu *loadDirMenu;
QMenu *loadFileMenu;
if (m_pluginDirTypes.size() > 0)
loadDirMenu = ui.menuLoad->addMenu("Directory");
if (m_pluginFileTypes.size() > 0)
loadFileMenu = ui.menuLoad->addMenu("Files");
for (int i=0; i<m_pluginDirTypes.size(); i++)
{
QAction *action = new QAction(this);
action->setText(m_pluginDirTypes[i]);
action->setData(m_pluginDirTypes[i]);
action->setVisible(true);
connect(action, SIGNAL(triggered()),
this, SLOT(loadDirectory()));
loadDirMenu->addAction(action);
}
for (int i=0; i<m_pluginFileTypes.size(); i++)
{
QAction *action = new QAction(this);
action->setText(m_pluginFileTypes[i]);
action->setData(m_pluginFileTypes[i]);
action->setVisible(true);
connect(action, SIGNAL(triggered()),
this, SLOT(loadFiles()));
loadFileMenu->addAction(action);
}
}
