//----------------------------------------------------------------------------
QList<ctkPlugin*> ctkPlugins::getPlugins(const QString& name, const ctkVersionRange& range) const
{
if (!fwCtx)
{ // This plugins instance has been closed!
throw std::logic_error("ctkPlugins::getPlugins(name, versionRange) called on closed plugins object.");
}
QList<ctkPlugin*> pluginsWithName = getPlugins(name);
QList<ctkPlugin*> res;
QListIterator<ctkPlugin*> it(pluginsWithName);
while (it.hasNext()) {
ctkPlugin* plugin = it.next();
if (range.withinRange(plugin->getVersion()))
{
int j = res.size();
while (--j >= 0)
{
if (plugin->getVersion().compare(res.at(j)->getVersion()) <= 0)
{
break;
}
}
res.insert(j + 1, plugin);
}
}
return res;
}
void
NegotiatorPluginManager::Update(const ClassAd &ad)
{
NegotiatorPlugin *plugin;
SimpleList<NegotiatorPlugin *> plugins = getPlugins();
plugins.Rewind();
while (plugins.Next(plugin)) {
plugin->update(ad);
}
}
void
NegotiatorPluginManager::Shutdown()
{
NegotiatorPlugin *plugin;
SimpleList<NegotiatorPlugin *> plugins = getPlugins();
plugins.Rewind();
while (plugins.Next(plugin)) {
plugin->shutdown();
}
}
void
NegotiatorPluginManager::Initialize()
{
NegotiatorPlugin *plugin;
SimpleList<NegotiatorPlugin *> plugins = getPlugins();
plugins.Rewind();
while (plugins.Next(plugin)) {
plugin->initialize();
}
}
void
CollectorPluginManager::Invalidate(int command, const ClassAd &ad)
{
CollectorPlugin *plugin;
SimpleList<CollectorPlugin *> plugins = getPlugins();
plugins.Rewind();
while (plugins.Next(plugin)) {
plugin->invalidate(command, ad);
}
}
void
CollectorPluginManager::Shutdown()
{
CollectorPlugin *plugin;
SimpleList<CollectorPlugin *> plugins = getPlugins();
plugins.Rewind();
while (plugins.Next(plugin)) {
plugin->shutdown();
}
}
void serialize( Archive& ar, const unsigned int version )
{
ar& BOOST_SERIALIZATION_NVP( _filePath );
ar& BOOST_SERIALIZATION_NVP( _bundlePath );
ar& BOOST_SERIALIZATION_NVP( _plugins );
ar& BOOST_SERIALIZATION_NVP( _fileModificationTime );
ar& BOOST_SERIALIZATION_NVP( _fileSize );
if( typename Archive::is_loading() )
{
_binary.init( _filePath );
checkBinaryChanged();
for( PluginVector::iterator it = getPlugins().begin(), itEnd = getPlugins().end();
it != itEnd;
++it )
{
it->setBinary( *this );
}
}
}
static Bool
ccpReload (void *closure)
{
CompPlugin *p;
CCP_CORE (&core);
for (p = getPlugins (); p; p = p->next)
{
if (!p->vTable->getObjectOptions)
continue;
ccpReloadObjectTree (&core.base, (void *) p);
}
cc->reloadHandle = 0;
return FALSE;
}
static Bool
kconfigRcReload (void *closure)
{
CompPlugin *p;
KCONFIG_CORE (&core);
kc->config->reparseConfiguration ();
for (p = getPlugins (); p; p = p->next)
{
if (!p->vTable->getObjectOptions)
continue;
kconfigReloadObjectTree (&core.base, (void *) p);
}
kc->reloadHandle = 0;
return FALSE;
}
void PluginManager::disablePlugins()
{
std::vector<Plugin *> plugins = getPlugins();
for(int i = plugins.size() - 1; i >= 0; i--)
disablePlugin(plugins[i]);
}
static void
fuseUpdateInode(CompDisplay *d,
FuseInode *inode)
{
CompScreen *s;
CompPlugin *p;
CompOption *option;
char str[256];
if (inode->type & FUSE_INODE_TYPE_ROOT)
{
FuseInode *c;
for (c = inode->child; c; c = c->sibling)
{
if (!findActivePlugin(c->name))
fuseRemoveInode(inode, c);
}
for (p = getPlugins(); p; p = p->next)
if (!fuseLookupChild(inode, p->vTable->name))
fuseAddInode(inode, FUSE_INODE_TYPE_PLUGIN,
p->vTable->name);
}
else if (inode->type & FUSE_INODE_TYPE_PLUGIN)
{
int n;
if (fuseGetOptionsFromInode(&d->base, inode, &n))
fuseAddInode(inode, FUSE_INODE_TYPE_DISPLAY, "allscreens");
for (s = d->screens; s; s = s->next)
{
if (fuseGetOptionsFromInode(&s->base, inode, &n))
{
sprintf(str, "screen%d", s->screenNum);
fuseAddInode(inode, FUSE_INODE_TYPE_SCREEN, str);
}
}
}
else if (inode->type & (FUSE_INODE_TYPE_DISPLAY | FUSE_INODE_TYPE_SCREEN))
{
CompObject *object;
object = fuseGetObjectFromInode(inode);
if (object)
{
int nOption;
option = fuseGetOptionsFromInode(object, inode->parent, &nOption);
if (option)
{
while (nOption--)
{
fuseAddInode(inode, FUSE_INODE_TYPE_OPTION, option->name);
option++;
}
}
}
}
else if (inode->type & FUSE_INODE_TYPE_OPTION)
{
option = fuseGetOptionFromInode(inode);
if (option)
{
fuseAddInode(inode, FUSE_INODE_TYPE_TYPE, "type");
switch (option->type)
{
case CompOptionTypeFloat:
fuseAddInode(inode, FUSE_INODE_TYPE_PRECISION, "precision");
/* fall-through */
case CompOptionTypeInt:
fuseAddInode(inode, FUSE_INODE_TYPE_MIN, "min");
fuseAddInode(inode, FUSE_INODE_TYPE_MAX, "max");
/* fall-through */
case CompOptionTypeBool:
case CompOptionTypeString:
case CompOptionTypeColor:
case CompOptionTypeKey:
case CompOptionTypeButton:
case CompOptionTypeEdge:
case CompOptionTypeBell:
case CompOptionTypeMatch:
fuseAddInode(inode, FUSE_INODE_TYPE_VALUE, "value");
break;
case CompOptionTypeList:
fuseAddInode(inode, FUSE_INODE_TYPE_ITEMS, "items");
fuseAddInode(inode, FUSE_INODE_TYPE_ITEM_COUNT,
"number_of_items");
fuseAddInode(inode, FUSE_INODE_TYPE_ITEM_TYPE, "item_type");
default:
break;
}
}
}
else if (inode->type & FUSE_INODE_TYPE_ITEMS)
{
option = fuseGetOptionFromInode(inode->parent);
if (option && option->type == CompOptionTypeList)
{
FuseInode *c, *next;
int i, nValue = option->value.list.nValue;
for (i = 0; i < option->value.list.nValue; i++)
{
sprintf(str, "value%d", i);
if (!fuseLookupChild(inode, str))
fuseAddInode(inode, FUSE_INODE_TYPE_ITEM_VALUE, str);
}
for (c = inode->child; c; c = next)
{
next = c->sibling;
if (sscanf(c->name, "value%d", &i) == 0 || i >= nValue)
fuseRemoveInode(inode, c);
}
}
}
}
