void GetSupportedFileFormats(QList<QByteArray> &g_supportedFormats)
{
// Assemble list of supported Image Formats from our plugin
int numPlugins = g_pluginManager.getNumPlugins();
for (int i = 0; i< numPlugins; i++)
{
if (strcmp(g_pluginManager.getPluginType(i), "IMAGE") == 0)
{
QByteArray bArray = g_pluginManager.getPluginName(i);
QByteArray fformat = bArray.toUpper();
if (!g_supportedFormats.contains(fformat))
g_supportedFormats.append(fformat);
}
}
// Get a list of all Supported file formats from Qt Plugins
QList<QByteArray> QtFormats = QImageReader::supportedImageFormats();
// Upppercase List
QList<QByteArray>::Iterator i;
for (i = QtFormats.begin(); i != QtFormats.end(); ++i)
{
QByteArray fformat = (*i);
fformat = fformat.toUpper();
if (!g_supportedFormats.contains(fformat))
g_supportedFormats.append(fformat);
}
// Sort the list to alphabetical order
std::sort(g_supportedFormats.begin(), g_supportedFormats.end());
}
void KstApp::showPluginManager() {
PluginManager *pm = new PluginManager(this, "Plugin Manager");
pm->exec();
delete pm;
KstPluginDialogI::globalInstance()->updatePluginList();
}
void CscopePlugin::BuildModuleMenu(const ModuleType type, wxMenu* menu, const FileTreeData* /*data*/)
{
if ( !IsAttached() || m_pProcess) return;
if(type != mtEditorManager || !menu ) return;
EditorManager* emngr = Manager::Get()->GetEditorManager();
if ( !emngr ) return;
EditorBase *edb = emngr->GetActiveEditor();
if ( !edb || !edb->IsBuiltinEditor() ) return;
cbStyledTextCtrl* stc = ((cbEditor*)edb)->GetControl();
if ( !stc ) return;
if ( stc->GetLexer() != wxSCI_LEX_CPP) return;
wxString word = GetWordAtCaret();
if ( word.IsEmpty() ) return;
PluginManager *pluginManager = Manager::Get()->GetPluginManager();
int idximp = pluginManager->GetFindMenuItemFirst() + pluginManager->GetFindMenuItemCount();
menu->Insert(idximp++, idOnFindFunctionsCalledByThisFuncion, _("Find functions called by '") + word + _T("'"));
menu->Insert(idximp++, idOnFindFunctionsCallingThisFunction, _("Find functions calling '") + word + _T("'"));
pluginManager->RegisterFindMenuItems(false, 2);
}
void Preferences::setPluginEnabled(const QString &fileName, bool enabled)
{
PluginManager::instance()->setPluginState(fileName, enabled ? PluginEnabled : PluginDisabled);
QStringList disabledPlugins;
QStringList enabledPlugins;
PluginManager *pluginManager = PluginManager::instance();
auto &states = pluginManager->pluginStates();
for (auto it = states.begin(), it_end = states.end(); it != it_end; ++it) {
const QString &fileName = it.key();
PluginState state = it.value();
switch (state) {
case PluginEnabled:
enabledPlugins.append(fileName);
break;
case PluginDisabled:
disabledPlugins.append(fileName);
break;
case PluginDefault:
case PluginStatic:
break;
}
}
mSettings->setValue(QLatin1String("Plugins/Disabled"), disabledPlugins);
mSettings->setValue(QLatin1String("Plugins/Enabled"), enabledPlugins);
}
bool MapDocument::save(const QString &fileName, QString *error)
{
PluginManager *pm = PluginManager::instance();
MapWriterInterface *chosenWriter = 0;
if (const Plugin *plugin = pm->pluginByFileName(mWriterPluginFileName))
chosenWriter = qobject_cast<MapWriterInterface*>(plugin->instance);
TmxMapWriter mapWriter;
if (!chosenWriter)
chosenWriter = &mapWriter;
if (!chosenWriter->write(map(), fileName)) {
if (error)
*error = chosenWriter->errorString();
return false;
}
undoStack()->setClean();
setFileName(fileName);
mLastSaved = QFileInfo(fileName).lastModified();
emit saved();
return true;
}
//=================================================================================
// It's important to note that we can't just unload the plugin here and now,
// because the plugin code is still running the call-stack.
/*virtual*/ bool PluginManager::PluginAssistant::UnloadPlugin( const wxString& libraryPath )
{
PluginManager* pluginManager = wxGetApp().GetPluginManager();
Cornucopia::Path path( ( const char* )libraryPath.c_str() );
if( pluginManager && pluginManager->UnloadPluginLater( path ) )
return true;
return false;
}
int main()
{
PluginManager pluginManager;
pluginManager.loadAllPlugins();
pluginManager.destroyAllPlugins();
return 0;
}
void MainWindowBase::unloadPlugins(){
qDebug()<<"--MainWindowBase::unloadPlugins()";
PluginManager *pluginManager = PluginManager::instance();
pluginManager->unloadPlugins();
//delete pluginManager();
}
void ProjectManagerPlugin::onItemClicked(const QModelIndex &index)
{
FileItem* item = static_cast<FileItem*>(index.internalPointer());
if (item->isDirectory)
return;
PluginManager *pluginManager = dynamic_cast<PluginManager*>(mdiServer->mdiHost);
if (pluginManager)
pluginManager->openFile(item->fullPath);
}
/*!
\fn IPlugin::~IPlugin()
\internal
*/
IPlugin::~IPlugin()
{
PluginManager *pm = PluginManager::instance();
foreach (QObject *obj, d->addedObjectsInReverseOrder)
pm->removeObject(obj);
qDeleteAll(d->addedObjectsInReverseOrder);
d->addedObjectsInReverseOrder.clear();
delete d;
d = 0;
}
void MainWindowBase::loadPlugins(const QString &pluginsDirPath) {
qDebug() << "----MainWindowBase::loadPlugins(...)~~Plugins Path:"<< pluginsDirPath;
PluginManager *pluginManager = PluginManager::instance();
connect(pluginManager, SIGNAL(signalPluginLoaded(AbstractPluginInterface*)), this, SLOT(slotInitPlugin(AbstractPluginInterface*)));
pluginManager->loadPlugins(pluginsDirPath);
// plugins = PluginManager::instance()->pluginsList();
// for (int i = 0; i < plugins.size(); i++) {
// AbstractPluginInterface *plugin = plugins.value(i);
// HEHUI::GUIInterface *guiInterface =
// static_cast<HEHUI::GUIInterface *> (plugin);
// if (guiInterface) {
// guiPlugins.append(guiInterface);
// }
// }
//
// return;
/*
QDir pluginsDir(pluginsPath);
foreach(QString fileName, pluginsDir.entryList(QDir::Files))
{
qDebug() << QString("~~ Testing library %1").arg(
pluginsDir.absoluteFilePath(fileName));
QPluginLoader pluginLoader(pluginsDir.absoluteFilePath(fileName));
QObject *plugin = pluginLoader.instance();
if (plugin) {
HEHUI::AbstractInterface *coreInterface = qobject_cast<HEHUI::AbstractInterface *> (plugin);
if (coreInterface) {
corePlugins.append(coreInterface);
qDebug() << QString("~~ Loading Core Plugin %1").arg(fileName);
HEHUI::GUIInterface *guiInterface = qobject_cast<HEHUI::GUIInterface *> (plugin);
if (guiInterface) {
guiPlugins.append(guiInterface);
qDebug() << QString("~~ Loading GUI Plugin %1").arg(fileName);
}
} else {
qCritical() << QString("XX Unknown Plugin! ");
break;
}
} else {
qDebug() << QString("XX An error occurred while loading plugin : %1").arg(
pluginLoader.errorString());
}
}
*/
}
IPlugin::IPlugin(const QString& depInterfaces)
{
PluginManager *pluginManager = PluginManager::instance();
m_depModulList = depInterfaces.split(" ");
foreach (const QString &depPlugin, depModulList()) {
if (!depPlugin.isEmpty())
pluginManager->nextLoadPlugins(depPlugin);
}
if (pluginManager->settings())
setSettings(pluginManager->settings());
}
int main(int argc,const char**argv) {
using namespace Sirikata;
OptionSet::getOptions("")->parse(argc,argv);
PluginManager plugins;
plugins.load( DynamicLibrary::filename("tcpsst") );
plugins.load( DynamicLibrary::filename("prox") );
Network::IOService*io=Network::IOServiceFactory::makeIOService();
Proximity::ProximitySystemFactory::getSingleton().getDefaultConstructor()(io,"",&Sirikata::Proximity::ProximitySystem::defaultNoAddressProximityCallback);
io->run();
return 0;
}
int main(int argc,const char**argv) {
using namespace Sirikata;
OptionSet::getOptions("")->parse(argc,argv);
Network::IOService*io=Network::IOServiceFactory::makeIOService();
//FIXME
//Network::IOServiceFactory::runService(io);
PluginManager plugins;
const char* pluginNames[] = { "mono", NULL};
for(const char** plugin_name = pluginNames; *plugin_name != NULL; plugin_name++)
plugins.load( DynamicLibrary::filename(*plugin_name) );
return 0;
}
void
VisItDataServerPrivate::LoadPluginsNow(PluginManager &plugins)
{
// Enable all plugins
for(int i = 0; i < plugins.GetNAllPlugins(); ++i)
{
// Get a pointer to the GUI portion of the Operator plugin information.
plugins.EnablePlugin(plugins.GetAllID(i));
}
// Load the plugins
plugins.LoadPluginsNow();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void WriteWebServerJSON(const QString& filePath)
{
// Register all the filters including trying to load those from Plugins
FilterManager* fm = FilterManager::Instance();
DREAM3DPluginLoader::LoadPluginFilters(fm);
PluginManager* pm = PluginManager::Instance();
QVector<IDREAM3DPlugin*> plugins = pm->getPluginsVector();
// Send progress messages from PipelineBuilder to this object for display
QMetaObjectUtilities::RegisterMetaTypes();
// Write our File Version and DREAM3D Version strings
QJsonObject meta;
meta["Release Date"] = QDate::currentDate().toString();
meta["Release Type"] = DREAM3DProj_RELEASE_TYPE;
meta["Major"] = DREAM3DLib::Version::Major();
meta["Minor"] = DREAM3DLib::Version::Minor();
meta["Patch"] = DREAM3DLib::Version::Patch();
meta["Revision"] = DREAM3DLib::Version::Revision();
meta["Download WebSite"] = "http://dream3d.bluequartz.net/?page_id=32";
QJsonObject m_Root;
m_Root["DREAM3D"] = meta;
QJsonArray plugArray;
for(int i = 0; i < plugins.size(); i++)
{
IDREAM3DPlugin* plug = plugins[i];
QJsonObject jobj;
jobj["Plugin Name"] = plug->getPluginName();
jobj["Plugin Version"] = plug->getVersion();
jobj["Plugin Vendor"] = plug->getVendor();
plugArray.append(jobj);
}
m_Root["Plugins"] = plugArray;
QJsonDocument doc(m_Root);
QFile outputFile(filePath);
if (outputFile.open(QIODevice::WriteOnly))
{
outputFile.write(doc.toJson());
outputFile.close();
}
}
static int dfhack_open_plugin(lua_State *L)
{
luaL_checktype(L, 1, LUA_TTABLE);
luaL_checktype(L, 2, LUA_TSTRING);
const char *name = lua_tostring(L, 2);
PluginManager *pmgr = Core::getInstance().getPluginManager();
Plugin *plugin = pmgr->getPluginByName(name);
if (!plugin)
luaL_error(L, "plugin not found: '%s'", name);
plugin->open_lua(L, 1);
return 0;
}
void DebuggerMenuHandler::BuildContextMenu(wxMenu &menu, const wxString& word_at_caret, bool is_running)
{
cbDebuggerPlugin *plugin = Manager::Get()->GetDebuggerManager()->GetActiveDebugger();
if (!plugin)
return;
PluginManager *pluginManager = Manager::Get()->GetPluginManager();
int initialItem;
if (is_running)
{
// we want debugger menu items to be at the top when debugging
initialItem = pluginManager->GetFindMenuItemFirst();
}
else
initialItem = pluginManager->GetFindMenuItemFirst() + pluginManager->GetFindMenuItemCount();
int item = initialItem;
// Insert Run to Cursor
if (plugin->SupportsFeature(cbDebuggerFeature::RunToCursor))
menu.Insert(item++, idMenuRunToCursor, _("Run to cursor"));
if (is_running)
{
if (plugin->SupportsFeature(cbDebuggerFeature::SetNextStatement))
menu.Insert(item++, idMenuSetNextStatement, _("Set next statement"));
if (item > 0)
menu.InsertSeparator(item++);
if (!word_at_caret.empty())
{
if (plugin->SupportsFeature(cbDebuggerFeature::Watches))
menu.Insert(item++, idMenuDebuggerAddWatch, wxString::Format(_("Watch '%s'"), word_at_caret.c_str()));
// data breakpoint
if (plugin->SupportsFeature(cbDebuggerFeature::Breakpoints))
{
menu.Insert(item++, idMenuAddDataBreakpoint,
wxString::Format(_("Add data breakpoint for '%s'"), word_at_caret.c_str()));
}
}
}
// Insert toggle breakpoint
if (plugin->SupportsFeature(cbDebuggerFeature::Breakpoints))
menu.Insert(item++, idMenuToggleBreakpoint, _("Toggle breakpoint"));
if (item > 0)
menu.InsertSeparator(item++);
if (is_running)
pluginManager->RegisterFindMenuItems(true, item - initialItem);
}
void setUp() {
if (!_initialized) {
_initialized = 1;
_pmgr.load(_plugin);
}
// Storage is tied to the main event loop, which requires quite a bit of setup
ObjectHostID oh_id(1);
_trace = new Trace::Trace("dummy.trace");
_ios = new Network::IOService("StorageTest");
_mainStrand = _ios->createStrand("StorageTest");
_work = new Network::IOWork(*_ios, "StorageTest");
Time start_time = Timer::now(); // Just for stats in ObjectHostContext.
Duration duration = Duration::zero(); // Indicates to run forever.
_sstConnMgr = new ODPSST::ConnectionManager();
_ohSSTConnMgr = new OHDPSST::ConnectionManager();
_ctx = new ObjectHostContext("test", oh_id, _sstConnMgr, _ohSSTConnMgr, _ios, _mainStrand, _trace, start_time, duration);
_storage = OH::StorageFactory::getSingleton().getConstructor(_type)(_ctx, _args);
for(int i = 0; i < 2; i++)
_storage->leaseBucket(_buckets[i]);
_ctx->add(_ctx);
_ctx->add(_storage);
// Run the context, but we need to make sure it only lives in other
// threads, otherwise we'd block up this one. We include 4 threads to
// exercise support for multiple threads.
_ctx->run(4, Context::AllNew);
}
AccessControlDataBackendManager::AccessControlDataBackendManager( PluginManager& pluginManager ) :
m_backends(),
m_defaultBackend( nullptr ),
m_configuredBackend( nullptr )
{
for( auto pluginObject : pluginManager.pluginObjects() )
{
auto pluginInterface = qobject_cast<PluginInterface *>( pluginObject );
auto accessControlDataBackendInterface = qobject_cast<AccessControlDataBackendInterface *>( pluginObject );
if( pluginInterface && accessControlDataBackendInterface )
{
m_backends[pluginInterface->uid()] = accessControlDataBackendInterface;
if( pluginInterface->flags().testFlag( Plugin::ProvidesDefaultImplementation ) )
{
m_defaultBackend = accessControlDataBackendInterface;
}
}
}
if( m_defaultBackend == nullptr )
{
qCritical( "AccessControlDataBackendManager: no default plugin available!" );
}
reloadConfiguration();
}
int main(int argc, char** argv) {
using namespace Sirikata;
InitOptions();
Trace::Trace::InitOptions();
OHTrace::InitOptions();
InitSimOHOptions();
ParseOptions(argc, argv);
PluginManager plugins;
plugins.loadList( GetOptionValue<String>(OPT_PLUGINS) );
plugins.loadList( GetOptionValue<String>(OPT_OH_PLUGINS) );
String trace_file = GetPerServerFile(STATS_OH_TRACE_FILE, 1);
Trace::Trace* gTrace = new Trace::Trace(trace_file);
BoundingBox3f region = GetOptionValue<BoundingBox3f>("region");
Duration duration = GetOptionValue<Duration>("duration");
// Get the starting time
Time start_time = Timer::now();
srand( GetOptionValue<uint32>("rand-seed") );
Network::IOService* ios = Network::IOServiceFactory::makeIOService();
Network::IOStrand* mainStrand = ios->createStrand();
ObjectHostContext* ctx = new ObjectHostContext(ObjectHostID(1), ios, mainStrand, gTrace, start_time, duration);
ObjectFactory* obj_factory = new ObjectFactory(ctx, region, duration);
// Nothing actually runs here -- we only cared about getting the
// object factory setup so it could dump the object pack data.
gTrace->prepareShutdown();
delete obj_factory;
delete ctx;
gTrace->shutdown();
delete gTrace;
gTrace = NULL;
delete mainStrand;
Network::IOServiceFactory::destroyIOService(ios);
return 0;
}
void PCommandManager::Init(void)
{
commandMap = map<BString,PCommand *>();
undoList = new BList();
macroList = new BList();
undoStatus = 0;
recording = NULL;
PluginManager *pluginManager = (doc->BelongTo())->GetPluginManager();
BList *commands = pluginManager->GetPluginsByType(P_C_COMMANDO_PLUGIN_TYPE);
if (commands)
{
for (int32 i=0; i<commands->CountItems();i++)
{
RegisterPCommand((BasePlugin *)commands->ItemAt(i));
}
}
}
void pluginManagerTest() {
sout << "### PluginManager Test ###" << std::endl << std::endl;
PluginManager* man = new PluginManager(MODULE_DIR);
ParameterFile file;
// setup a dummy module that gets data from dynamic dummy module
file.set("dynamic.type", "dynamicdummymodule");
file.set("dummy.type", "dummymodule");
file.set("dynamic.input", 0);
file.set("dynamic.output", 1);
file.set("dynamic.out1", "dummy.in");
file.set("dummy.in", "dynamic.out1");
man->loadParameterFile(file);
sout << std::endl;
man->runWorkflow();
sout << std::endl;
sout << "~~~~~~~" << std::endl;
// add dynamic dummy module and connect it to first dynamic module
file.set("dynamic2.type", "dynamicdummymodule");
file.set("dynamic.input", 2);
file.set("dynamic2.input", 0);
file.set("dynamic2.output", 2);
file.set("dynamic2.parameters", 5);
file.set("dynamic2.param4", 999);
file.set("dynamic.in1", "dynamic2.out1");
file.set("dynamic2.out1", "dynamic.in1");
file.set("dynamic.in2", "dynamic2.out2");
file.set("dynamic2.out2", "dynamic.in2");
man->loadParameterFile(file);
sout << std::endl;
man->runWorkflow();
sout << std::endl;
delete man;
sout << std::endl << "### End of Test ###" << std::endl << std::endl;
}
PointCloudBase::PointCloudBase( const std::string& name, VisualizationManager* manager )
: Display( name, manager )
, spinner_(1, &cbqueue_)
, new_cloud_(false)
, new_xyz_transformer_(false)
, new_color_transformer_(false)
, needs_retransform_(false)
, style_( Billboards )
, billboard_size_( 0.01 )
, point_decay_time_(0.0f)
, selectable_(false)
, coll_handle_(0)
, messages_received_(0)
, total_point_count_(0)
{
cloud_ = new ogre_tools::PointCloud();
scene_node_ = scene_manager_->getRootSceneNode()->createChildSceneNode();
scene_node_->attachObject(cloud_);
coll_handler_ = PointCloudSelectionHandlerPtr(new PointCloudSelectionHandler(this));
setStyle( style_ );
setBillboardSize( billboard_size_ );
setAlpha(1.0f);
setSelectable(true);
PluginManager* pman = vis_manager_->getPluginManager();
const L_Plugin& plugins = pman->getPlugins();
L_Plugin::const_iterator it = plugins.begin();
L_Plugin::const_iterator end = plugins.end();
for (; it != end; ++it)
{
const PluginPtr& plugin = *it;
PluginConns pc;
pc.loaded = plugin->getLoadedSignal().connect(boost::bind(&PointCloudBase::onPluginLoaded, this, _1));
pc.unloading = plugin->getUnloadingSignal().connect(boost::bind(&PointCloudBase::onPluginUnloading, this, _1));
loadTransformers(plugin.get());
plugin_conns_[plugin.get()] = pc;
}
threaded_nh_.setCallbackQueue(&cbqueue_);
spinner_.start();
}
int main(int argc, char **argv) {
std::cerr << "Main begin " << std::endl;
Context *context = Context::GetContext();
context->setScreenWidth(800);
context->setScreenHeight(600);
context->setScreenXOffset(0);
context->setScreenYOffset(0);
xlibEnv::xlibEnv::GetXlibEnv(context);
PluginManager *pluginMgr = PluginManager::GetManager(
context);
context->setPluginManager(pluginMgr);
pluginMgr->start();
openGlPaintPlugin *openglpaintplugin =
new openGlPaintPlugin(context);
context->setOpenGlPaintPlugin(openglpaintplugin);
ParseEvent *parseEvent = ParseEvent::GetParseEvent(context);
context->setEventParse(parseEvent);
//parseEvent.parseFile2Event("/home/lnmcc/Documents/test.json");
//parseEvent.parseFile2Event("/home/lnmcc/Documents/test2.json");
//parseEvent.parseFile2Event("/home/lnmcc/Documents/test3.json");
//parseEvent.parseFile2Event("/home/lnmcc/Documents/test4.json");
//parseEvent->dump();
parseEvent->start();
Socket mysocket(context);
mysocket.start();
//openglpaintplugin->setThreadPriority(99);
openglpaintplugin->start();
pause();
return 0;
}
ClientToolModel::ClientToolModel(QObject* parent) : QSortFilterProxyModel(parent)
{
insertFactory(new ConnectionInspectorFactory);
insertFactory(new LocaleInspectorFactory);
insertFactory(new MessageHandlerFactory);
insertFactory(new MetaObjectBrowserFactory);
insertFactory(new MetaTypeBrowserFactory);
insertFactory(new MimeTypesFactory);
insertFactory(new ModelInspectorFactory);
insertFactory(new ObjectInspectorFactory);
insertFactory(new ResourceBrowserFactory);
insertFactory(new StandardPathsFactory);
insertFactory(new TextDocumentInspectorFactory);
PluginManager<ToolUiFactory, ProxyToolUiFactory> pm;
foreach(ToolUiFactory* factory, pm.plugins())
insertFactory(factory);
connect(this, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(updateToolInitialization(QModelIndex,QModelIndex)));
}
void ServerCore::Unload(void)
{
//TODO:
//1. Politely kick all players.
//2. Destroy all vehicles.
vmm.UnloadGameMode(); //3. Unload all virtual machines.
vmm.UnloadFilterScripts(); //3. Unload all virtual machines.
plugm.UnloadPlugins(); //4. Unload all plugins.
nm.Unload();
//5. Clean up all remaining data - destructors.
}
bool PluginThread::initPlugin()
{
PluginManager* manager = Carbon::get()->getPluginManager();
//For new plugins, executable denotes the executable plugin, class mainScript the plugin caption and secondary script the plugin type (as integer)
AbstractPlugin* plugin = manager->findPlugin(getTaskDefinition().getFirst(), getTaskDefinition().getSecond(),
getTaskDefinition().getThird().compare("") == 0 ? -1 : getTaskDefinition().getThird().toInt());
if (plugin == 0)
{
LOG_ERROR() << "Could not initialize PluginThread because plugin to start with was not found.";
mPlugin = 0;
return false;
}
if (plugin->getPluginType() == PT_FRAME)
{
LOG_ERROR() << "Could not initialize PluginThread because plugin is of type AttachableFrame. AttachableFrame plugins can only be started in the main thread.";
mPlugin = 0;
return false;
}
if (plugin->getExecutionType() == AbstractPlugin::ET_NEVER)
{
LOG_ERROR() << "Could not initialize PluginThread because the plugin is not executable. It has to have an execution type of ONCE, LOOP or ANY.";
mPlugin = 0;
return false;
}
mPlugin = plugin;
if (mPlugin->isQObject())
{
//Connect to plugin update functions
connect(mPlugin->getQObject(), SIGNAL(paused()), this, SLOT(pluginPaused()));
connect(mPlugin->getQObject(), SIGNAL(running()), this, SLOT(pluginRunning()));
connect(mPlugin->getQObject(), SIGNAL(finished()), this, SLOT(pluginFinished()));
}
return true;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
CommandLineParser parser;
Commands commands;
parser.registerDataSink( &commands );
if ( !parser.parse( true ) ) {
a.quit();
return -1;
}
Log::instance()->setMessageTypeEnabled( QtDebugMsg, commands.verbose );
PluginManager* pluginManager = PluginManager::instance();
pluginManager->loadPlugins();
if ( commands.listPlugins ) {
printf( "%s\n\n", printStringTable( pluginManager->importerPlugins(), 1, "Importer Plugins" ).toUtf8().constData() );
printf( "%s\n\n", printStringTable( pluginManager->routerPlugins(), 1, "Router Plugins" ).toUtf8().constData() );
printf( "%s\n\n", printStringTable( pluginManager->gpsLookupPlugins(), 1, "GPS Lookup Plugins" ).toUtf8().constData() );
printf( "%s\n\n", printStringTable( pluginManager->rendererPlugins(), 1, "Renderer Plugins" ).toUtf8().constData() );
printf( "%s\n\n", printStringTable( pluginManager->addressLookupPlugins(), 1, "Address Lookup Plugins" ).toUtf8().constData() );
a.quit();
return 0;
}
if ( !commands.settings.isEmpty() ) {
QSettings settings( commands.settings, QSettings::IniFormat );
pluginManager->loadSettings( &settings );
commands.importer = settings.value( "importer" ).toString();
commands.router = settings.value( "router" ).toString();
commands.gpsLookup = settings.value( "gpsLookup" ).toString();
commands.renderer = settings.value( "renderer" ).toString();
commands.addressLookup = settings.value( "addressLookup" ).toString();
}
// parse a second time including all plugins
// otherwise console settings would be overwritten by the settings file
QVector< QObject* > plugins = pluginManager->plugins();
foreach( QObject* plugin, plugins ) {
IConsoleSettings* settings = qobject_cast< IConsoleSettings* >( plugin );
if ( settings!= NULL ) {
parser.registerDataSink( settings );
}
}
void PluginClass::setPluginData(Plugin::PluginType type, int index)
{
PluginManager* pm = AccessClass::getPluginManager();
String name;
pluginType = type;
pluginIndex = index;
switch (type)
{
case Plugin::ProcessorPlugin:
{
Plugin::ProcessorInfo i = pm->getProcessorInfo(index);
name = i.name;
}
break;
case Plugin::RecordEnginePlugin:
{
Plugin::RecordEngineInfo i = pm->getRecordEngineInfo(index);
name = i.name;
}
break;
case Plugin::DatathreadPlugin:
{
Plugin::DataThreadInfo i = pm->getDataThreadInfo(index);
name = i.name;
}
break;
case Plugin::FileSourcePlugin:
{
Plugin::FileSourceInfo i = pm->getFileSourceInfo(index);
name = i.name;
}
break;
case Plugin::NotAPlugin:
{
String pName;
int pType;
ProcessorManager::getProcessorNameAndType(BuiltInProcessor, index, pName, pType);
name = pName;
}
default:
return;
}
pluginName = name;
libName = pm->getLibraryName(pm->getLibraryIndexFromPlugin(type, index));
libVersion = pm->getLibraryVersion(pm->getLibraryIndexFromPlugin(type, index));
}
