command_stream_t
make_command_stream (int (*get_next_byte) (void *),
void *get_next_byte_argument)
{
/* FIXME: Replace this with your implementation. You may need to
add auxiliary functions and otherwise modify the source code.
You can also use external functions defined in the GNU C Library. */
// get_next_byte(get_next_byte_argument);
command_t *res = checked_malloc(sizeof(command_t) * 128);
memset(res, 0, 128);
make_commands(get_next_byte_argument, get_next_byte, res);
commandNode_t node = checked_malloc(sizeof(struct commandNode));
node->next = NULL;
commandNode_t cursor = node;
int i = 0;
while (res[i] != NULL)
{
commandNode_t tmp_node = checked_malloc(sizeof(struct commandNode));
cursor->next = tmp_node;
cursor = cursor->next;
cursor->command = res[i];
i++;
}
cursor->next = NULL;
command_stream_t stream = checked_malloc(sizeof(struct command_stream));
stream->head = node->next;
stream->cursor = node->next;
stream->tail = cursor;
// error (1, 0, "command reading not yet implemented");
return stream;
}
void PluginLoader::loadPlugins(
iscore::ApplicationRegistrar& registrar,
const iscore::ApplicationContext& context)
{
auto folders = pluginsDir();
// Here, the plug-ins that are effectively loaded.
std::vector<iscore::Plugin_QtInterface*> availablePlugins;
// Load static plug-ins
for(QObject* plugin : QPluginLoader::staticInstances())
{
if(auto iscore_plug = dynamic_cast<iscore::Plugin_QtInterface*>(plugin))
availablePlugins.push_back(iscore_plug);
}
QSet<QString> pluginFiles;
#if !defined(ISCORE_STATIC_QT)
// Load dynamic plug-ins
for(const QString& pluginsFolder : folders)
{
QDir pluginsDir(pluginsFolder);
for(const QString& fileName : pluginsDir.entryList(QDir::Files))
{
auto plug = loadPlugin(pluginsDir.absoluteFilePath(fileName), availablePlugins);
if(!plug.first.isEmpty())
{
pluginFiles.insert(plug.first);
}
if(plug.second)
{
availablePlugins.push_back(plug.second);
}
}
}
#endif
// First bring in the plugin objects
registrar.registerPlugins(
pluginFiles.toList(),
availablePlugins);
// Here, it is important not to collapse all the for-loops
// because for instance a ApplicationPlugin from plugin B might require the factory
// from plugin A to be loaded prior.
// Load all the factories.
for(iscore::Plugin_QtInterface* plugin : availablePlugins)
{
auto facfam_interface = dynamic_cast<FactoryList_QtInterface*> (plugin);
if(facfam_interface)
{
for(auto&& elt : facfam_interface->factoryFamilies())
{
registrar.registerFactory(std::move(elt));
}
}
}
// Load all the application context plugins.
// We have to order them according to their dependencies
PluginDependencyGraph graph;
for(auto plugin : availablePlugins)
{
graph.addNode(dynamic_cast<QObject*>(plugin));
}
graph.visit([&] (QObject* plugin) {
auto ctrl_plugin = dynamic_cast<GUIApplicationContextPlugin_QtInterface*> (plugin);
if(ctrl_plugin)
{
auto plug = ctrl_plugin->make_applicationPlugin(context);
registrar.registerApplicationContextPlugin(plug);
}
});
// Load what the plug-ins have to offer.
for(auto plugin : availablePlugins)
{
auto panel_plugin = dynamic_cast<PanelFactory_QtInterface*> (plugin);
if(panel_plugin)
{
auto panels = panel_plugin->panels();
for(auto panel : panels)
{
registrar.registerPanel(panel);
}
}
auto commands_plugin = dynamic_cast<CommandFactory_QtInterface*> (plugin);
if(commands_plugin)
{
registrar.registerCommands(commands_plugin->make_commands());
}
auto factories_plugin = dynamic_cast<FactoryInterface_QtInterface*> (plugin);
if(factories_plugin)
{
for(auto& factory_family : registrar.components().factories)
{
for(auto&& new_factory : factories_plugin->factories(context, factory_family.first))
{
factory_family.second->insert(std::move(new_factory));
}
}
}
}
}
