bool CAddonsDirectory::GetScriptsAndPlugins(const CStdString &content, CFileItemList &items)
{
items.Clear();
VECADDONS addons;
if (!GetScriptsAndPlugins(content, addons))
return false;
for (unsigned i=0; i<addons.size(); i++)
{
CFileItemPtr item(FileItemFromAddon(addons[i],
addons[i]->Type()==ADDON_PLUGIN?"plugin://":"script://",
addons[i]->Type() == ADDON_PLUGIN));
PluginPtr plugin = boost::dynamic_pointer_cast<CPluginSource>(addons[i]);
if (plugin->ProvidesSeveral())
{
CURL url = item->GetAsUrl();
CStdString opt;
opt.Format("?content_type=%s",content.c_str());
url.SetOptions(opt);
item->SetPath(url.Get());
}
items.Add(item);
}
items.Add(GetMoreItem(content));
items.SetContent("addons");
items.SetLabel(g_localizeStrings.Get(24001)); // Add-ons
return items.Size() > 0;
}
PluginPtr
RotoShapeRenderNode::createPlugin()
{
std::vector<std::string> grouping;
grouping.push_back(PLUGIN_GROUP_PAINT);
PluginPtr ret = Plugin::create(RotoShapeRenderNode::create, RotoShapeRenderNode::createRenderClone, PLUGINID_NATRON_ROTOSHAPE, "RotoShape", 1, 0, grouping);
ret->setProperty<bool>(kNatronPluginPropIsInternalOnly, true);
EffectDescriptionPtr effectDesc = ret->getEffectDescriptor();
effectDesc->setProperty<RenderSafetyEnum>(kEffectPropRenderThreadSafety, eRenderSafetyFullySafe);
#ifdef ROTO_SHAPE_RENDER_CPU_USES_CAIRO
effectDesc->setProperty<PluginOpenGLRenderSupport>(kEffectPropSupportsOpenGLRendering, ePluginOpenGLRenderSupportYes);
#else
effectDesc->setProperty<PluginOpenGLRenderSupport>(kEffectPropSupportsOpenGLRendering, ePluginOpenGLRenderSupportNeeded);
#endif
effectDesc->setProperty<bool>(kEffectPropSupportsTiles, false);
effectDesc->setProperty<bool>(kEffectPropSupportsMultiResolution, true);
effectDesc->setProperty<bool>(kEffectPropTemporalImageAccess, true);
ret->setProperty<bool>(kNatronPluginPropMultiPlanar, true);
ret->setProperty<ImageBitDepthEnum>(kNatronPluginPropOutputSupportedBitDepths, eImageBitDepthFloat, 0);
ret->setProperty<std::bitset<4> >(kNatronPluginPropOutputSupportedComponents, std::bitset<4>(std::string("1111")));
{
InputDescriptionPtr input = InputDescription::create("Source", "Source", "", true, false, std::bitset<4>(std::string("1111")));
ret->addInputDescription(input);
}
return ret;
}
CGUIViewStateFromItems::CGUIViewStateFromItems(const CFileItemList &items) : CGUIViewState(items)
{
const std::vector<GUIViewSortDetails> &details = items.GetSortDetails();
for (unsigned int i = 0; i < details.size(); i++)
{
const GUIViewSortDetails sort = details[i];
AddSortMethod(sort.m_sortDescription, sort.m_buttonLabel, sort.m_labelMasks);
}
//! @todo Should default sort/view mode be specified?
m_currentSortMethod = 0;
SetViewAsControl(DEFAULT_VIEW_LIST);
if (items.IsPlugin())
{
CURL url(items.GetPath());
AddonPtr addon;
if (CServiceBroker::GetAddonMgr().GetAddon(url.GetHostName(), addon, ADDON_PLUGIN))
{
PluginPtr plugin = std::static_pointer_cast<CPluginSource>(addon);
if (plugin->Provides(CPluginSource::AUDIO))
m_playlist = PLAYLIST_MUSIC;
if (plugin->Provides(CPluginSource::VIDEO))
m_playlist = PLAYLIST_VIDEO;
}
}
LoadViewState(items.GetPath(), g_windowManager.GetActiveWindow());
}
NATRON_NAMESPACE_ENTER
PluginPtr
JoinViewsNode::createPlugin()
{
std::vector<std::string> grouping;
grouping.push_back(PLUGIN_GROUP_MULTIVIEW);
PluginPtr ret = Plugin::create(JoinViewsNode::create, JoinViewsNode::createRenderClone, PLUGINID_NATRON_JOINVIEWS, "JoinViews", 1, 0, grouping);
QString desc = tr("Take in input separate views to make a multiple view stream output. "
"The first view from each input is copied to one of the view of the output.");
ret->setProperty<std::string>(kNatronPluginPropDescription, desc.toStdString());
EffectDescriptionPtr effectDesc = ret->getEffectDescriptor();
effectDesc->setProperty<RenderSafetyEnum>(kEffectPropRenderThreadSafety, eRenderSafetyFullySafe);
effectDesc->setProperty<bool>(kEffectPropSupportsTiles, true);
ret->setProperty<bool>(kNatronPluginPropViewAware, true);
ret->setProperty<std::string>(kNatronPluginPropIconFilePath, "Images/joinViewsNode.png");
ret->setProperty<ImageBitDepthEnum>(kNatronPluginPropOutputSupportedBitDepths, eImageBitDepthFloat, 0);
ret->setProperty<ImageBitDepthEnum>(kNatronPluginPropOutputSupportedBitDepths, eImageBitDepthByte, 1);
ret->setProperty<ImageBitDepthEnum>(kNatronPluginPropOutputSupportedBitDepths, eImageBitDepthShort, 2);
ret->setProperty<std::bitset<4> >(kNatronPluginPropOutputSupportedComponents, std::bitset<4>(std::string("1111")));
return ret;
}
void Application::Initialize()
{
BOOST_ASSERT( m_IsInitialized == false );
Super::Initialize();
// Initialize loaded plug-ins
PluginList::iterator pluginIter = m_Plugins.begin();
while ( pluginIter != m_Plugins.end() )
{
PluginPtr plugin = (*pluginIter);
plugin->Initialize();
++pluginIter;
}
// Initialize registered subsystems
SubsystemList::iterator subsystemIter = m_Subsystems.begin();
while ( subsystemIter != m_Subsystems.end() )
{
SubsystemPtr subsystem = (*subsystemIter);
subsystem->Initialize();
++subsystemIter;
}
m_IsInitialized = true;
OnInitialized( EventArgs( *this ) );
}
CGUIViewStateFromItems::CGUIViewStateFromItems(const CFileItemList &items) : CGUIViewState(items)
{
const vector<SORT_METHOD_DETAILS> &details = items.GetSortDetails();
for (unsigned int i = 0; i < details.size(); i++)
{
const SORT_METHOD_DETAILS sort = details[i];
AddSortMethod(sort.m_sortMethod, sort.m_buttonLabel, sort.m_labelMasks);
}
// TODO: Should default sort/view mode be specified?
m_currentSortMethod = 0;
SetViewAsControl(DEFAULT_VIEW_LIST);
SetSortOrder(SORT_ORDER_ASC);
if (items.IsPlugin())
{
CURL url(items.m_strPath);
AddonPtr addon;
if (CAddonMgr::Get().GetAddon(url.GetHostName(),addon) && addon)
{
PluginPtr plugin = boost::static_pointer_cast<CPluginSource>(addon);
if (plugin->Provides(CPluginSource::AUDIO))
m_playlist = PLAYLIST_MUSIC;
if (plugin->Provides(CPluginSource::VIDEO))
m_playlist = PLAYLIST_VIDEO;
}
}
LoadViewState(items.m_strPath, g_windowManager.GetActiveWindow());
}
PluginPtr
DiskCacheNode::createPlugin()
{
std::vector<std::string> grouping;
grouping.push_back(PLUGIN_GROUP_OTHER);
PluginPtr ret = Plugin::create(DiskCacheNode::create, DiskCacheNode::createRenderClone, PLUGINID_NATRON_DISKCACHE, "DiskCache", 1, 0, grouping);
QString desc = tr("This node caches all images of the connected input node onto the disk with full 32bit floating point raw data. "
"When an image is found in the cache, %1 will then not request the input branch to render out that image. "
"The DiskCache node only caches full images and does not split up the images in chunks. "
"The DiskCache node is useful if working with a large and complex node tree: this allows to break the tree into smaller "
"branches and cache any branch that one is no longer working on. The cached images are saved by default in the same directory that is used "
"for the viewer cache but you can set its location and size in the preferences. A solid state drive disk is recommended for efficiency of this node. "
"By default all images that pass into the node are cached but they depend on the zoom-level of the viewer. For convenience you can cache "
"a specific frame range at scale 100% much like a writer node would do.\n"
"WARNING: The DiskCache node must be part of the tree when you want to read cached data from it.").arg( QString::fromUtf8(NATRON_APPLICATION_NAME) );
ret->setProperty<std::string>(kNatronPluginPropDescription, desc.toStdString());
EffectDescriptionPtr effectDesc = ret->getEffectDescriptor();
effectDesc->setProperty<RenderSafetyEnum>(kEffectPropRenderThreadSafety, eRenderSafetyFullySafe);
effectDesc->setProperty<bool>(kEffectPropSupportsTiles, false);
effectDesc->setProperty<bool>(kEffectPropSupportsMultiResolution, true);
ret->setProperty<std::string>(kNatronPluginPropIconFilePath, "Images/diskcache_icon.png");
ret->setProperty<ImageBitDepthEnum>(kNatronPluginPropOutputSupportedBitDepths, eImageBitDepthFloat);
ret->setProperty<std::bitset<4> >(kNatronPluginPropOutputSupportedComponents, std::bitset<4>(std::string("1111")));
ret->setProperty<ImageBitDepthEnum>(kNatronPluginPropOutputSupportedBitDepths, eImageBitDepthFloat, 0);
ret->setProperty<std::bitset<4> >(kNatronPluginPropOutputSupportedComponents, std::bitset<4>(std::string("1111")));
{
InputDescriptionPtr input = InputDescription::create("Source", "", "", false, false, std::bitset<4>(std::string("1111")));
ret->addInputDescription(input);
}
return ret;
}
ClientPtr LoginDialog::loadClient(const QString &name, Buffer *cfg)
{
if (name.isEmpty())
return ClientPtr();
QString clientName = name;
QString pluginName = getToken(clientName, '/');
if (pluginName.isEmpty() || clientName.length() == 0)
return ClientPtr();
if(!getPluginManager()->isPluginProtocol(pluginName))
{
log(L_DEBUG, "Plugin %s is not a protocol plugin", qPrintable(pluginName));
return ClientPtr();
}
PluginPtr plugin = getPluginManager()->plugin(pluginName);
if(plugin.isNull())
{
log(L_WARN, "Plugin %s not found", qPrintable(pluginName));
return ClientPtr();
}
m_protocolPlugins.append(plugin);
ProfileManager::instance()->currentProfile()->enablePlugin(pluginName);
ProtocolPtr protocol;
ProtocolIterator it;
while ((protocol = ++it) != NULL)
if (protocol->description()->text == clientName)
return protocol->createClient(cfg);
log(L_DEBUG, "Protocol %s not found", qPrintable(clientName));
return ClientPtr();
}
QString
PluginGroupNode::getTreeNodeID() const
{
PluginPtr plugin = getPlugin();
if (plugin) {
return QString::fromUtf8(plugin->getPluginID().c_str());
} else {
return _name;
}
}
PluginDatabase::func_t ModulesPluginDatabase::getSymbol (PluginSpec const & spec, std::string const & which) const
{
try
{
PluginPtr plugin = impl->modules.load (spec.getName (), spec.getConfig ());
return plugin->getSymbol (which);
}
catch (...)
{
return NULL;
}
}
void PluginContainer::load(PluginPtr plugin, system::Library library) throw(PluginLoadException) {
if (plugin->getCompilerInfo() != BFT_COMPILER_INFO) {
// TODO more information in the exception.
throw PluginLoadException("Compiler mis-match.");
}
if (!common::isCompatible(application.getVersion(), plugin->getEngineVersion())) {
// TODO more information in the exception.
throw PluginLoadException("Version mis-match.");
}
plugins.emplace_back(std::move(library), std::move(plugin));
}
std::string ModulesPluginDatabase::lookupInfo (PluginSpec const & spec, std::string const & which) const
{
PluginPtr plugin;
try
{
plugin = impl->modules.load (spec.getName (), spec.getConfig ());
}
catch (...)
{
throw;
}
return plugin->lookupInfo (which);
}
SoundUserConfig::SoundUserConfig(QWidget *parent, SIM::PropertyHubPtr data, SoundPlugin *plugin)
: QWidget(parent)
, m_plugin(plugin)
{
setupUi(this);
setProperty("override", data->value("sound/override").toBool());
int row = 0;
addRow(lstSound, row, Icon("SIM"), i18n("Online alert"), ONLINE_ALERT, data->value("sound/Alert").toString());
// Well, basically, this mess means that core plugin shouldn't keep messageTypes
PluginPtr coreplugin = getPluginManager()->plugin("_core");
CorePlugin* core = static_cast<CorePlugin*>(coreplugin.data());
CommandDef *cmd;
CommandsMapIterator it(core->messageTypes);
while((cmd = ++it) != NULL)
{
MessageDef *def = (MessageDef*)(cmd->param);
if ((def == NULL) || (cmd->icon.isEmpty()) ||
(def->flags & (MESSAGE_HIDDEN | MESSAGE_SENDONLY | MESSAGE_CHILD)))
{
continue;
}
if ((def->singular == NULL) || (def->plural == NULL) ||
(*def->singular == 0) || (*def->plural == 0))
{
continue;
}
QString type = i18n(def->singular, def->plural, 1);
int pos = type.indexOf("1 ");
if (pos == 0){
type = type.mid(2);
}else if (pos > 0){
type = type.left(pos);
}
type = type.left(1).toUpper() + type.mid(1);
row++;
addRow(lstSound, row, Icon(cmd->icon), type, cmd->id, m_plugin->messageSound(cmd->id, data->value("id").toUInt()));
}
chkActive->setChecked(data->value("sound/NoSoundIfActive").toBool());
chkDisable->setChecked(data->value("sound/Disable").toBool());
connect(chkDisable, SIGNAL(toggled(bool)), this, SLOT(toggled(bool)));
toggled(data->value("sound/Disable").toBool());
lstSound->resizeColumnsToContents();
lstSound->setItemDelegate(new EditSoundDelegate(1, lstSound));
lstSound->sortByColumn(0, Qt::AscendingOrder);
}
void Backend::tryPlugin (PluginSpec const & spec)
{
PluginPtr plugin = modules.load (spec);
errorplugins.tryPlugin (*plugin.get ());
getplugins.tryPlugin (*plugin.get ());
setplugins.tryPlugin (*plugin.get ());
for (auto & elem : plugins)
{
if (plugin->getFullName () == elem->getFullName ()) throw PluginAlreadyInserted (plugin->getFullName ());
}
plugins.push_back (std::move (plugin));
}
PluginPtr Application::LoadPlugin( const std::wstring& filename )
{
fs::wpath filePath( filename );
fs::wpath pluginName = filePath.stem();
PluginPtr pluginPtr = GetPluginByName( pluginName.wstring() );
if ( !pluginPtr )
{
// Try to load the dynamic lib from the provided filename.
DynamicLibPtr pluginLib = m_DynamicLibSubsystem->Load( filename );
if ( pluginLib )
{
CreatePluginFP createPluginFunc = (CreatePluginFP)pluginLib->GetSymbol( "CreatePlugin" );
if ( createPluginFunc != NULL )
{
pluginPtr = createPluginFunc();
if ( pluginPtr != NULL )
{
pluginPtr->FileName = filePath.wstring();
pluginPtr->PluginName = filePath.stem().wstring();
if ( m_IsInitialized )
{
pluginPtr->Initialize();
}
AddPlugin( pluginPtr );
}
else
{
std::cerr << "Application::LoadPlugin: Plug-in creation failed in library \"";
std::wcerr << filename;
std::wcerr << "\"" << std::endl;
}
}
else
{
std::cerr << "Application::LoadPlugin: Could not find symbol \"CreatePlugin\" in library \"";
std::wcerr << filename;
std::cerr << "\"" << std::endl;
}
}
}
return pluginPtr;
}
void TreeViewModel::importConfiguration(const QString& name, const QString& format, QString& file, const QVariantList &mergeStrategies)
{
Key root(name.toStdString(), KEY_END);
KeySet originalKeys = collectCurrentKeySet();
KeySet base = originalKeys.cut(root);
printWarnings (cerr, root);
KeySet importedKeys;
string formatString = format.toStdString();
string fileString = file.remove("file://").toStdString();
Modules modules;
PluginPtr plugin = modules.load(formatString);
Key errorKey (root);
errorKey.setString (fileString);
plugin->get(importedKeys, errorKey);
stringstream ws;
stringstream es;
QString warnings;
QString errors;
printWarnings(ws, errorKey);
warnings = QString::fromStdString(ws.str());
printError(es, errorKey);
errors = QString::fromStdString(es.str());
if(!errors.isEmpty())
{
emit showMessage(tr("Error"), tr("Failed to import configuration from %1 to %2.").arg(file, QString::fromStdString(root.getName())), errors);
return;
}
ThreeWayMerge merger;
foreach(QVariant s, mergeStrategies)
{
MergeConflictStrategy* strategy = getMergeStrategy(s.toString());
if(strategy)
merger.addConflictStrategy(strategy);
}
PluginCfg::PluginCfg(QWidget *parent, const QString& pluginname) : QWidget(parent)
{
setupUi(this);
m_pluginName = pluginname;
if(ProfileManager::instance()->currentProfile()->enabledPlugins().contains(m_pluginName) ||
getPluginManager()->isPluginAlwaysEnabled(m_pluginName))
{
PluginPtr plugin = getPluginManager()->plugin(pluginname);
QWidget *w = plugin->createConfigWindow(addWnd);
if (w){
QVBoxLayout *lay = new QVBoxLayout(addWnd);
lay->addWidget(w);
QObject::connect(parent->topLevelWidget(), SIGNAL(applyChanges()), w, SLOT(apply()));
// adjust plugin widget
w->setMinimumSize(w->sizeHint());
w->adjustSize();
// adjust addWnd widget
addWnd->setMinimumSize(addWnd->sizeHint());
addWnd->adjustSize();
}
}
// adjust description
if(!getPluginManager()->pluginDescription(pluginname).isNull())
{
lblDescription->setText(i18n(getPluginManager()->pluginDescription(pluginname)));
}
else
{
lblDescription->setText("");
}
// adjust tab
tabWnd->setCurrentIndex(0);
tabWnd->setTabText(0, i18n(getPluginManager()->pluginTitle(pluginname)));
tabWnd->setMinimumSize(tabWnd->sizeHint());
tabWnd->adjustSize();
// adjust complete widget
setMinimumSize(sizeHint());
adjustSize();
if (getPluginManager()->isPluginAlwaysEnabled(pluginname)) {
chkEnable->hide();
} else {
chkEnable->setEnabled(true);
chkEnable->setChecked(ProfileManager::instance()->currentProfile()->enabledPlugins().contains(pluginname));
}
}
int ExportCommand::execute (Cmdline const & cl)
{
size_t argc = cl.arguments.size ();
if (argc != 1 && argc != 2 && argc != 3)
{
throw invalid_argument ("need 1 to 3 arguments");
}
Key root = cl.createKey (0);
kdb.get (ks, root);
printWarnings (cerr, root);
KeySet part (ks.cut (root));
if (cl.withoutElektra)
{
Key systemElektra ("system/elektra", KEY_END);
part.cut (systemElektra);
}
string format = cl.format;
if (argc > 1) format = cl.arguments[1];
#ifdef _WIN32
string file = "CON";
#else
string file = "/dev/stdout";
#endif
if (argc > 2 && cl.arguments[2] != "-") file = cl.arguments[2];
Modules modules;
PluginPtr plugin = modules.load (format, cl.getPluginsConfig ());
Key errorKey (root);
errorKey.setString (file);
plugin->set (part, errorKey);
printWarnings (cerr, errorKey);
printError (cerr, errorKey);
return 0;
}
void Application::Terminate()
{
BOOST_ASSERT( m_IsInitialized == true );
// Terminate the subsystems in the opposite order as they were registered.
SubsystemList::reverse_iterator iter = m_Subsystems.rbegin();
while ( iter != m_Subsystems.rend() )
{
SubsystemPtr subsystem = (*iter);
subsystem->Terminate();
++iter;
}
m_Subsystems.clear();
// Unload any previously loaded plug-ins
PluginList plugins = m_Plugins;
PluginList::iterator pluginIter = plugins.begin();
while ( pluginIter != plugins.end() )
{
PluginPtr plugin = (*pluginIter);
plugin->Terminate();
UnloadPlugin( plugin );
++pluginIter;
}
plugins.clear();
m_PluginsByName.clear();
m_PluginsByFileName.clear();
m_Plugins.clear();
// Flush all the libraries. At this point
// there should be no residual pointers to objects
// created in the library.
m_DynamicLibSubsystem->Flush();
m_IsInitialized = false;
OnTerminated( EventArgs( *this ) );
}
bool CAddonsDirectory::GetScriptsAndPlugins(const CStdString &content, CFileItemList &items)
{
items.Clear();
CPluginSource::Content type = CPluginSource::Translate(content);
if (type == CPluginSource::UNKNOWN)
return false;
VECADDONS addons;
CAddonMgr::Get().GetAddons(ADDON_PLUGIN, addons);
for (unsigned i=0; i<addons.size(); i++)
{
PluginPtr plugin = boost::dynamic_pointer_cast<CPluginSource>(addons[i]);
if (!plugin || !plugin->Provides(type))
continue;
items.Add(FileItemFromAddon(addons[i], "plugin://", true));
}
addons.clear();
CAddonMgr::Get().GetAddons(ADDON_SCRIPT, addons);
for (unsigned i=0; i<addons.size(); i++)
{
PluginPtr plugin = boost::dynamic_pointer_cast<CPluginSource>(addons[i]);
if (!plugin || !plugin->Provides(type))
continue;
items.Add(FileItemFromAddon(addons[i], "script://", false));
}
CFileItemPtr item(new CFileItem("addons://more/"+content,false));
item->SetLabelPreformated(true);
item->SetLabel(g_localizeStrings.Get(21452));
item->SetIconImage("DefaultAddon.png");
item->SetSpecialSort(SORT_ON_BOTTOM);
items.Add(item);
items.SetContent("addons");
return items.Size() > 0;
}
std::vector<PluginSpec> PluginVariantDatabase::getPluginVariants (PluginSpec const & whichplugin) const
{
PluginPtr plugin = this->impl->modules.load (whichplugin);
KeySet ksSysconf (this->variantImpl->pluginconf);
KeySet ksGenconf;
// read plugin variants via genconf
try
{
auto funcGenconf = reinterpret_cast<void (*) (ckdb::KeySet *, ckdb::Key *)> (plugin->getSymbol ("genconf"));
funcGenconf (ksGenconf.getKeySet (), 0);
}
catch (kdb::tools::MissingSymbol & e)
{
// no genconf, but maybe sysconf variants
KeySet placeholder;
return this->getPluginVariantsFromSysconf (whichplugin, ksSysconf, placeholder);
}
// get plugin variants from genconf, but also consider sysconf for disable/override
return this->getPluginVariantsFromGenconf (whichplugin, ksGenconf, ksSysconf);
}
PluginPtr
NodeCreationDialog::getPlugin(QString* presetName) const
{
QString lineEditText = _imp->textEdit->text();
const CompleterLineEdit::PluginsNamesMap& names = _imp->textEdit->getPluginNamesMap();
for (CompleterLineEdit::PluginsNamesMap::const_iterator it = names.begin(); it!=names.end(); ++it) {
if (it->second.comboLabel == lineEditText) {
if (presetName) {
*presetName = it->second.presetName;
}
PluginPtr ret = it->second.plugin.lock();
if (ret) {
incrementPluginWeight(QString::fromUtf8(ret->getPluginID().c_str()),
it->second.presetName,
ret->getMajorVersion());
}
return ret;
}
}
return PluginPtr();
}
bool CAddonsDirectory::GetScriptsAndPlugins(const CStdString &content, VECADDONS &addons)
{
CPluginSource::Content type = CPluginSource::Translate(content);
if (type == CPluginSource::UNKNOWN)
return false;
VECADDONS tempAddons;
CAddonMgr::Get().GetAddons(ADDON_PLUGIN, tempAddons);
for (unsigned i=0; i<tempAddons.size(); i++)
{
PluginPtr plugin = boost::dynamic_pointer_cast<CPluginSource>(tempAddons[i]);
if (plugin && plugin->Provides(type))
addons.push_back(tempAddons[i]);
}
tempAddons.clear();
CAddonMgr::Get().GetAddons(ADDON_SCRIPT, tempAddons);
for (unsigned i=0; i<tempAddons.size(); i++)
{
PluginPtr plugin = boost::dynamic_pointer_cast<CPluginSource>(tempAddons[i]);
if (plugin && plugin->Provides(type))
addons.push_back(tempAddons[i]);
}
return true;
}
void Application::UnloadPlugin( PluginPtr plugin )
{
if ( plugin )
{
RemovePlugin( plugin );
plugin->Terminate();
// Unload the DLL the plugin was loaded from.
DynamicLibPtr ptrLib = m_DynamicLibSubsystem->GetLibrary( plugin->FileName );
if ( ptrLib )
{
DestroyPluginFP destroyPluginFunc = (DestroyPluginFP)ptrLib->GetSymbol( "DestroyPlugin" );
if ( destroyPluginFunc != NULL )
{
// Unload the plugin and all of the types that are associated with the plugin.
destroyPluginFunc();
}
else
{
std::cerr << "Application::UnloadPlugin: Could not find \"DestroyPlugin\" method in library \"";
std::wcerr << ptrLib->FileName.get();
std::cerr << "\"" << std::endl;
}
// Don't forget to call DynamicLibSubsystem::Flush to actually
// release the libraries from memory.
m_DynamicLibSubsystem->Unload( ptrLib );
}
else
{
std::cerr << "Application::UnloadPlugin: Could not find library with filename: \"";
std::wcerr << plugin->FileName.get();
std::cerr << "\"" << std::endl;
}
}
}
// \brief With this function you can react on a users click in the list/thumb panel.
// It returns true, if the click is handled.
// This function calls OnPlayMedia()
bool CGUIMediaWindow::OnClick(int iItem)
{
if ( iItem < 0 || iItem >= (int)m_vecItems->Size() ) return true;
CFileItemPtr pItem = m_vecItems->Get(iItem);
if (pItem->IsParentFolder())
{
GoParentFolder();
return true;
}
if (pItem->GetPath() == "add" || pItem->GetPath() == "sources://add/") // 'add source button' in empty root
{
OnContextButton(iItem, CONTEXT_BUTTON_ADD_SOURCE);
return true;
}
if (!pItem->m_bIsFolder && pItem->IsFileFolder())
{
XFILE::IFileDirectory *pFileDirectory = NULL;
pFileDirectory = XFILE::CFactoryFileDirectory::Create(pItem->GetPath(), pItem.get(), "");
if(pFileDirectory)
pItem->m_bIsFolder = true;
else if(pItem->m_bIsFolder)
pItem->m_bIsFolder = false;
delete pFileDirectory;
}
if (pItem->IsScript())
{
// execute the script
CURL url(pItem->GetPath());
AddonPtr addon;
if (CAddonMgr::Get().GetAddon(url.GetHostName(), addon))
{
#ifdef HAS_PYTHON
if (!g_pythonParser.StopScript(addon->LibPath()))
g_pythonParser.evalFile(addon->LibPath(),addon);
#endif
return true;
}
}
if (pItem->m_bIsFolder)
{
if ( pItem->m_bIsShareOrDrive )
{
const CStdString& strLockType=m_guiState->GetLockType();
if (g_settings.GetMasterProfile().getLockMode() != LOCK_MODE_EVERYONE)
if (!strLockType.IsEmpty() && !g_passwordManager.IsItemUnlocked(pItem.get(), strLockType))
return true;
if (!HaveDiscOrConnection(pItem->GetPath(), pItem->m_iDriveType))
return true;
}
// check for the partymode playlist items - they may not exist yet
if ((pItem->GetPath() == g_settings.GetUserDataItem("PartyMode.xsp")) ||
(pItem->GetPath() == g_settings.GetUserDataItem("PartyMode-Video.xsp")))
{
// party mode playlist item - if it doesn't exist, prompt for user to define it
if (!XFILE::CFile::Exists(pItem->GetPath()))
{
m_vecItems->RemoveDiscCache(GetID());
if (CGUIDialogSmartPlaylistEditor::EditPlaylist(pItem->GetPath()))
Update(m_vecItems->GetPath());
return true;
}
}
// remove the directory cache if the folder is not normally cached
CFileItemList items(pItem->GetPath());
if (!items.AlwaysCache())
items.RemoveDiscCache(GetID());
CFileItem directory(*pItem);
if (!Update(directory.GetPath()))
ShowShareErrorMessage(&directory);
return true;
}
else if (pItem->IsPlugin() && !pItem->GetProperty("isplayable").asBoolean())
{
return XFILE::CPluginDirectory::RunScriptWithParams(pItem->GetPath());
}
else
{
m_iSelectedItem = m_viewControl.GetSelectedItem();
if (pItem->GetPath() == "newplaylist://")
{
m_vecItems->RemoveDiscCache(GetID());
g_windowManager.ActivateWindow(WINDOW_MUSIC_PLAYLIST_EDITOR,"newplaylist://");
return true;
}
else if (pItem->GetPath().Left(19).Equals("newsmartplaylist://"))
{
m_vecItems->RemoveDiscCache(GetID());
if (CGUIDialogSmartPlaylistEditor::NewPlaylist(pItem->GetPath().Mid(19)))
Update(m_vecItems->GetPath());
return true;
}
else if (pItem->GetPath().Left(14).Equals("addons://more/"))
{
CBuiltins::Execute("ActivateWindow(AddonBrowser,addons://all/xbmc.addon." + pItem->GetPath().Mid(14) + ",return)");
return true;
}
// If karaoke song is being played AND popup autoselector is enabled, the playlist should not be added
bool do_not_add_karaoke = g_guiSettings.GetBool("karaoke.enabled") &&
g_guiSettings.GetBool("karaoke.autopopupselector") && pItem->IsKaraoke();
bool autoplay = m_guiState.get() && m_guiState->AutoPlayNextItem();
if (pItem->IsPlugin())
{
CURL url(pItem->GetPath());
AddonPtr addon;
if (CAddonMgr::Get().GetAddon(url.GetHostName(),addon))
{
PluginPtr plugin = boost::dynamic_pointer_cast<CPluginSource>(addon);
if (plugin && plugin->Provides(CPluginSource::AUDIO) && pItem->IsAudio())
{
autoplay = g_guiSettings.GetBool("musicplayer.autoplaynextitem");
}
}
}
if (autoplay && !g_partyModeManager.IsEnabled() &&
!pItem->IsPlayList() && !do_not_add_karaoke)
{
return OnPlayAndQueueMedia(pItem);
}
else
{
return OnPlayMedia(iItem);
}
}
return false;
}
int ImportCommand::execute (Cmdline const & cl)
{
size_t argc = cl.arguments.size ();
if (argc != 1 && argc != 2 && argc != 3)
{
throw invalid_argument ("need 1 to 3 arguments");
}
Key root = cl.createKey (0);
if (!root.isValid ())
{
throw invalid_argument ("root key \"" + cl.arguments[0] + "\" is not a valid key name");
}
KeySet originalKeys;
kdb.get (originalKeys, root);
KeySet base = originalKeys.cut (root);
printWarnings (cerr, root);
string format = cl.format;
if (argc > 1) format = cl.arguments[1];
string file = "/dev/stdin";
if (argc > 2 && cl.arguments[2] != "-") file = cl.arguments[2];
Modules modules;
PluginPtr plugin = modules.load (format, cl.getPluginsConfig ());
Key errorKey (root);
errorKey.setString (file);
KeySet importedKeys;
plugin->get (importedKeys, errorKey);
importedKeys = importedKeys.cut (root);
printWarnings (cerr, errorKey);
printError (cerr, errorKey);
ThreeWayMerge merger;
MergeHelper helper;
helper.configureMerger (cl, merger);
MergeResult result = merger.mergeKeySet (
MergeTask (BaseMergeKeys (base, root), OurMergeKeys (base, root), TheirMergeKeys (importedKeys, root), root));
helper.reportResult (cl, result, cout, cerr);
int ret = -1;
if (!result.hasConflicts ())
{
if (cl.verbose)
{
cout << "The merged keyset with strategy " << cl.strategy << " is:" << endl;
cout << result.getMergedKeys ();
}
KeySet resultKeys = result.getMergedKeys ();
originalKeys.append (resultKeys);
kdb.set (originalKeys, root);
ret = 0;
}
return ret;
}
NATRON_NAMESPACE_ENTER
// those parameters should be ignored (they are always secret in Natron)
#define kOCIOParamInputSpace "ocioInputSpace"
#define kOCIOParamOutputSpace "ocioOutputSpace"
// those parameters should not have their options in the help file if generating markdown,
// because the options are dinamlically constructed at run-time from the OCIO config.
#define kOCIOParamInputSpaceChoice "ocioInputSpaceIndex"
#define kOCIOParamOutputSpaceChoice "ocioOutputSpaceIndex"
#define kOCIODisplayPluginIdentifier "fr.inria.openfx.OCIODisplay"
#define kOCIODisplayParamDisplay "display"
#define kOCIODisplayParamDisplayChoice "displayIndex"
#define kOCIODisplayParamView "view"
#define kOCIODisplayParamViewChoice "viewIndex"
// not yet implemented (see OCIOCDLTransform.cpp)
//#define kOCIOCDLTransformPluginIdentifier "fr.inria.openfx.OCIOCDLTransform"
//#define kOCIOCDLTransformParamCCCID "cccId"
//#define kOCIOCDLTransformParamCCCIDChoice "cccIdIndex"
#define kOCIOFileTransformPluginIdentifier "fr.inria.openfx.OCIOFileTransform"
#define kOCIOFileTransformParamCCCID "cccId"
#define kOCIOFileTransformParamCCCIDChoice "cccIdIndex"
// genHTML: true for live HTML output for the internal web-server, false for markdown output
QString
Node::makeDocumentation(bool genHTML) const
{
QString ret;
QString markdown;
QTextStream ts(&ret);
QTextStream ms(&markdown);
QString pluginID, pluginLabel, pluginDescription, pluginIcon;
int majorVersion = getMajorVersion();
int minorVersion = getMinorVersion();
std::vector<std::string> pluginGroup;
bool pluginDescriptionIsMarkdown = false;
QVector<QStringList> inputs;
QVector<QStringList> items;
{
PluginPtr plugin = getPlugin();
assert(plugin);
pluginID = QString::fromUtf8(plugin->getPluginID().c_str());
pluginLabel = QString::fromUtf8( Plugin::makeLabelWithoutSuffix( plugin->getPluginLabel() ).c_str());
pluginDescription = QString::fromUtf8( plugin->getPropertyUnsafe<std::string>(kNatronPluginPropDescription).c_str() );
pluginIcon = QString::fromUtf8(plugin->getPropertyUnsafe<std::string>(kNatronPluginPropIconFilePath).c_str());
pluginGroup = plugin->getPropertyNUnsafe<std::string>(kNatronPluginPropGrouping);
pluginDescriptionIsMarkdown = plugin->getPropertyUnsafe<bool>(kNatronPluginPropDescriptionIsMarkdown);
for (int i = 0; i < _imp->effect->getNInputs(); ++i) {
QStringList input;
input << convertFromPlainTextToMarkdown( QString::fromStdString( getInputLabel(i) ), genHTML, true );
input << convertFromPlainTextToMarkdown( QString::fromStdString( getInputHint(i) ), genHTML, true );
input << ( isInputOptional(i) ? tr("Yes") : tr("No") );
inputs.push_back(input);
// Don't show more than doc for 4 inputs otherwise it will just clutter the page
if (i == 3) {
break;
}
}
}
// check for plugin icon
QString pluginIconUrl;
if ( !pluginIcon.isEmpty() ) {
QFile iconFile(pluginIcon);
if ( iconFile.exists() ) {
if (genHTML) {
pluginIconUrl.append( QString::fromUtf8("/LOCAL_FILE/") );
pluginIconUrl.append(pluginIcon);
pluginIconUrl.replace( QString::fromUtf8("\\"), QString::fromUtf8("/") );
} else {
pluginIconUrl.append(pluginID);
pluginIconUrl.append(QString::fromUtf8(".png"));
}
}
}
// check for extra markdown file
QString extraMarkdown;
QString pluginMD = pluginIcon;
pluginMD.replace( QString::fromUtf8(".png"), QString::fromUtf8(".md") );
QFile pluginMarkdownFile(pluginMD);
if ( pluginMarkdownFile.exists() ) {
if ( pluginMarkdownFile.open(QIODevice::ReadOnly | QIODevice::Text) ) {
extraMarkdown = QString::fromUtf8( pluginMarkdownFile.readAll() );
pluginMarkdownFile.close();
}
}
// generate knobs info
KnobsVec knobs = getEffectInstance()->getKnobs_mt_safe();
for (KnobsVec::const_iterator it = knobs.begin(); it != knobs.end(); ++it) {
#pragma message WARN("TODO: restore getDefaultIsSecret from RB-2.2")
//if ( (*it)->getDefaultIsSecret() ) {
if ( (*it)->getIsSecret() ) {
continue;
}
if ((*it)->getKnobDeclarationType() != KnobI::eKnobDeclarationTypePlugin) {
continue;
}
// do not escape characters in the scriptName, since it will be put between backquotes
QString knobScriptName = /*NATRON_NAMESPACE::convertFromPlainTextToMarkdown(*/ QString::fromUtf8( (*it)->getName().c_str() )/*, genHTML, true)*/;
QString knobLabel = NATRON_NAMESPACE::convertFromPlainTextToMarkdown( QString::fromUtf8( (*it)->getLabel().c_str() ), genHTML, true);
QString knobHint = NATRON_NAMESPACE::convertFromPlainTextToMarkdown( QString::fromUtf8( (*it)->getHintToolTip().c_str() ), genHTML, true);
// totally ignore the documentation for these parameters (which are always secret in Natron)
if ( knobScriptName.startsWith( QString::fromUtf8("NatronOfxParam") ) ||
knobScriptName == QString::fromUtf8("exportAsPyPlug") ||
knobScriptName == QString::fromUtf8(kOCIOParamInputSpace) ||
knobScriptName == QString::fromUtf8(kOCIOParamOutputSpace) ||
( ( pluginID == QString::fromUtf8(kOCIODisplayPluginIdentifier) ) &&
( knobScriptName == QString::fromUtf8(kOCIODisplayParamDisplay) ) ) ||
( ( pluginID == QString::fromUtf8(kOCIODisplayPluginIdentifier) ) &&
( knobScriptName == QString::fromUtf8(kOCIODisplayParamView) ) ) ||
//( ( pluginID == QString::fromUtf8(kOCIOCDLTransformPluginIdentifier) ) &&
// ( knobScriptName == QString::fromUtf8(kOCIOCDLTransformParamCCCID) ) ) ||
( ( pluginID == QString::fromUtf8(kOCIOFileTransformPluginIdentifier) ) &&
( knobScriptName == QString::fromUtf8(kOCIOFileTransformParamCCCID) ) ) ||
false) {
continue;
}
QString defValuesStr, knobType;
std::vector<std::pair<QString, QString> > dimsDefaultValueStr;
KnobIntPtr isInt = toKnobInt(*it);
KnobChoicePtr isChoice = toKnobChoice(*it);
KnobBoolPtr isBool = toKnobBool(*it);
KnobDoublePtr isDbl = toKnobDouble(*it);
KnobStringPtr isString = toKnobString(*it);
bool isLabel = isString && isString->isLabel();
KnobSeparatorPtr isSep = toKnobSeparator(*it);
KnobButtonPtr isBtn = toKnobButton(*it);
KnobParametricPtr isParametric = toKnobParametric(*it);
KnobGroupPtr isGroup = toKnobGroup(*it);
KnobPagePtr isPage = toKnobPage(*it);
KnobColorPtr isColor = toKnobColor(*it);
if (isInt) {
knobType = tr("Integer");
} else if (isChoice) {
knobType = tr("Choice");
} else if (isBool) {
knobType = tr("Boolean");
} else if (isDbl) {
knobType = tr("Double");
} else if (isString) {
if (isLabel) {
knobType = tr("Label");
} else {
knobType = tr("String");
}
} else if (isSep) {
knobType = tr("Separator");
} else if (isBtn) {
knobType = tr("Button");
} else if (isParametric) {
knobType = tr("Parametric");
} else if (isGroup) {
knobType = tr("Group");
} else if (isPage) {
knobType = tr("Page");
} else if (isColor) {
knobType = tr("Color");
} else {
knobType = tr("N/A");
}
if (!isGroup && !isPage) {
for (int i = 0; i < (*it)->getNDimensions(); ++i) {
QString valueStr;
if (!isBtn && !isSep && !isParametric) {
// If this is a ChoiceParam and we are not generating live HTML doc,
// only add the list of entries and their halp if this node should not be
// ignored (eg. OCIO colorspace knobs).
if ( isChoice &&
(genHTML || !( knobScriptName == QString::fromUtf8(kOCIOParamInputSpaceChoice) ||
knobScriptName == QString::fromUtf8(kOCIOParamOutputSpaceChoice) ||
( ( pluginID == QString::fromUtf8(kOCIODisplayPluginIdentifier) ) &&
( knobScriptName == QString::fromUtf8(kOCIODisplayParamDisplayChoice) ) ) ||
( ( pluginID == QString::fromUtf8(kOCIODisplayPluginIdentifier) ) &&
( knobScriptName == QString::fromUtf8(kOCIODisplayParamViewChoice) ) ) ||
//( ( pluginID == QString::fromUtf8(kOCIOCDLTransformPluginIdentifier) ) &&
// ( knobScriptName == QString::fromUtf8(kOCIOCDLTransformParamCCCIDChoice) ) ) ||
( ( pluginID == QString::fromUtf8(kOCIOFileTransformPluginIdentifier) ) &&
( knobScriptName == QString::fromUtf8(kOCIOFileTransformParamCCCIDChoice) ) ) ||
( ( pluginID == QString::fromUtf8("net.fxarena.openfx.Text") ) &&
( knobScriptName == QString::fromUtf8("name") ) ) || // font family from Text plugin
( ( pluginID == QString::fromUtf8("net.fxarena.openfx.Polaroid") ) &&
( knobScriptName == QString::fromUtf8("font") ) ) || // font family from Polaroid plugin
( ( pluginID == QString::fromUtf8(PLUGINID_NATRON_PRECOMP) ) &&
( knobScriptName == QString::fromUtf8("writeNode") ) ) ||
( ( pluginID == QString::fromUtf8(PLUGINID_NATRON_ONEVIEW) ) &&
( knobScriptName == QString::fromUtf8("view") ) ) ) ) ) {
// see also KnobChoice::getHintToolTipFull()
int index = isChoice->getDefaultValue(DimIdx(i));
std::vector<ChoiceOption> entries = isChoice->getEntries();
if ( (index >= 0) && ( index < (int)entries.size() ) ) {
valueStr = QString::fromUtf8( entries[index].id.c_str() );
}
bool first = true;
for (size_t i = 0; i < entries.size(); i++) {
QString entryHelp = QString::fromUtf8( entries[i].tooltip.c_str() );
QString entry;
if (entries[i].id != entries[i].label) {
entry = QString::fromUtf8( "%1 (%2)" ).arg(QString::fromUtf8( entries[i].label.c_str() )).arg(QString::fromUtf8( entries[i].id.c_str() ));
} else {
entry = QString::fromUtf8( entries[i].label.c_str() );
}
if (!entry.isEmpty()) {
if (first) {
// empty line before the option descriptions
if (genHTML) {
if ( !knobHint.isEmpty() ) {
knobHint.append( QString::fromUtf8("<br />") );
}
knobHint.append( tr("Possible values:") + QString::fromUtf8("<br />") );
} else {
// we do a hack for multiline elements, because the markdown->rst conversion by pandoc doesn't use the line block syntax.
// what we do here is put a supplementary dot at the beginning of each line, which is then converted to a pipe '|' in the
// genStaticDocs.sh script by a simple sed command after converting to RsT
if ( !knobHint.isEmpty() ) {
if (!knobHint.startsWith( QString::fromUtf8(". ") )) {
knobHint.prepend( QString::fromUtf8(". ") );
}
knobHint.append( QString::fromUtf8("\\\n") );
}
knobHint.append( QString::fromUtf8(". ") + tr("Possible values:") + QString::fromUtf8("\\\n") );
}
first = false;
}
if (genHTML) {
knobHint.append( QString::fromUtf8("<br />") );
} else {
knobHint.append( QString::fromUtf8("\\\n") );
// we do a hack for multiline elements, because the markdown->rst conversion by pandoc doesn't use the line block syntax.
// what we do here is put a supplementary dot at the beginning of each line, which is then converted to a pipe '|' in the
// genStaticDocs.sh script by a simple sed command after converting to RsT
knobHint.append( QString::fromUtf8(". ") );
}
if (entryHelp.isEmpty()) {
knobHint.append( QString::fromUtf8("**%1**").arg( convertFromPlainTextToMarkdown(entry, genHTML, true) ) );
} else {
knobHint.append( QString::fromUtf8("**%1**: %2").arg( convertFromPlainTextToMarkdown(entry, genHTML, true) ).arg( convertFromPlainTextToMarkdown(entryHelp, genHTML, true) ) );
}
}
}
} else if (isInt) {
valueStr = QString::number( isInt->getDefaultValue( DimIdx(i) ) );
} else if (isDbl) {
valueStr = QString::number( isDbl->getDefaultValue( DimIdx(i) ) );
} else if (isBool) {
valueStr = isBool->getDefaultValue( DimIdx(i) ) ? tr("On") : tr("Off");
} else if (isString) {
valueStr = QString::fromUtf8( isString->getDefaultValue( DimIdx(i) ).c_str() );
} else if (isColor) {
valueStr = QString::number( isColor->getDefaultValue( DimIdx(i) ) );
}
}
dimsDefaultValueStr.push_back( std::make_pair(convertFromPlainTextToMarkdown( QString::fromUtf8( (*it)->getDimensionName( DimIdx(i) ).c_str() ), genHTML, true ),
convertFromPlainTextToMarkdown(valueStr, genHTML, true)) );
}
for (std::size_t i = 0; i < dimsDefaultValueStr.size(); ++i) {
if ( !dimsDefaultValueStr[i].second.isEmpty() ) {
if (dimsDefaultValueStr.size() > 1) {
defValuesStr.append(dimsDefaultValueStr[i].first);
defValuesStr.append( QString::fromUtf8(": ") );
}
defValuesStr.append(dimsDefaultValueStr[i].second);
if (i < dimsDefaultValueStr.size() - 1) {
defValuesStr.append( QString::fromUtf8(" ") );
}
}
}
if ( defValuesStr.isEmpty() ) {
defValuesStr = tr("N/A");
}
}
if (!isPage && !isSep && !isGroup && !isLabel) {
QStringList row;
row << knobLabel << knobScriptName << knobType << defValuesStr << knobHint;
items.append(row);
}
} // for (KnobsVec::const_iterator it = knobs.begin(); it!=knobs.end(); ++it) {
// generate plugin info
ms << tr("%1 node").arg(pluginLabel) << "\n==========\n\n";
// a hack to avoid repeating the documentation for the various merge plugins
if ( pluginID.startsWith( QString::fromUtf8("net.sf.openfx.Merge") ) ) {
std::string id = pluginID.toStdString();
std::string op;
if (id == PLUGINID_OFX_MERGE) {
// do nothing
} else if (id == "net.sf.openfx.MergeDifference") {
op = "difference (a.k.a. absminus)";
} else if (id == "net.sf.openfx.MergeIn") {
op = "in";
} else if (id == "net.sf.openfx.MergeMatte") {
op = "matte";
} else if (id == "net.sf.openfx.MergeMax") {
op = "max";
} else if (id == "net.sf.openfx.MergeMin") {
op = "min";
} else if (id == "net.sf.openfx.MergeMultiply") {
op = "multiply";
} else if (id == "net.sf.openfx.MergeOut") {
op = "out";
} else if (id == "net.sf.openfx.MergePlus") {
op = "plus";
} else if (id == "net.sf.openfx.MergeScreen") {
op = "screen";
}
if ( !op.empty() ) {
// we should use the custom link "[Merge node](|http::/plugins/" PLUGINID_OFX_MERGE ".html||rst::net.sf.openfx.MergePlugin|)"
// but pandoc borks it
ms << tr("The *%1* node is a convenience node identical to the %2, except that the operator is set to *%3* by default.")
.arg(pluginLabel)
.arg(genHTML ? QString::fromUtf8("<a href=\"" PLUGINID_OFX_MERGE ".html\">Merge node</a>") :
QString::fromUtf8(":ref:`" PLUGINID_OFX_MERGE "`")
//QString::fromUtf8("[Merge node](http::/plugins/" PLUGINID_OFX_MERGE ".html)")
)
.arg( QString::fromUtf8( op.c_str() ) );
goto OUTPUT;
}
}
if (!pluginIconUrl.isEmpty()) {
// add a nonbreaking space so that pandoc doesn't use the alt-text as a caption
// http://pandoc.org/MANUAL.html#images
ms << "![pluginIcon](" << pluginIconUrl << ")";
if (!genHTML) {
// specify image width for pandoc-generated printed doc
// (for hoedown-generated HTML, this handled by the CSS using the alt=pluginIcon attribute)
// see http://pandoc.org/MANUAL.html#images
// note that only % units are understood both by pandox and sphinx
ms << "{ width=10% }";
}
ms << " \n\n"; // required so that there is no legend when converted to rst by pandoc
}
ms << tr("*This documentation is for version %2.%3 of %1.*").arg(pluginLabel).arg(majorVersion).arg(minorVersion) << "\n\n";
ms << "\n" << tr("Description") << "\n--------------------------------------------------------------------------------\n\n";
if (!pluginDescriptionIsMarkdown) {
if (genHTML) {
pluginDescription = NATRON_NAMESPACE::convertFromPlainText(pluginDescription, NATRON_NAMESPACE::WhiteSpaceNormal);
// replace URLs with links
QRegExp re( QString::fromUtf8("((http|ftp|https)://([\\w_-]+(?:(?:\\.[\\w_-]+)+))([\\w.,@?^=%&:/~+#-]*[\\w@?^=%&/~+#-])?)") );
pluginDescription.replace( re, QString::fromUtf8("<a href=\"\\1\">\\1</a>") );
} else {
pluginDescription = convertFromPlainTextToMarkdown(pluginDescription, genHTML, false);
}
}
ms << pluginDescription << "\n";
// create markdown table
ms << "\n" << tr("Inputs") << "\n--------------------------------------------------------------------------------\n\n";
ms << tr("Input") << " | " << tr("Description") << " | " << tr("Optional") << "\n";
ms << "--- | --- | ---\n";
if (inputs.size() > 0) {
Q_FOREACH(const QStringList &input, inputs) {
QString inputName = input.at(0);
QString inputDesc = input.at(1);
QString inputOpt = input.at(2);
ms << inputName << " | " << inputDesc << " | " << inputOpt << "\n";
}
/*! \brief Run a script or plugin add-on.
* \param params The parameters.
* \details params[0] = add-on id.
* params[1] is blank for no add-on parameters
* or
* params[1] = add-on parameters in url format
* or
* params[1,...] = additional parameters in format param=value.
*/
static int RunAddon(const std::vector<std::string>& params)
{
if (params.size())
{
const std::string& addonid = params[0];
AddonPtr addon;
if (CAddonMgr::GetInstance().GetAddon(addonid, addon, ADDON_PLUGIN))
{
PluginPtr plugin = std::dynamic_pointer_cast<CPluginSource>(addon);
std::string urlParameters;
std::vector<std::string> parameters;
if (params.size() == 2 &&
(StringUtils::StartsWith(params[1], "/") || StringUtils::StartsWith(params[1], "?")))
urlParameters = params[1];
else if (params.size() > 1)
{
parameters.insert(parameters.begin(), params.begin() + 1, params.end());
urlParameters = "?" + StringUtils::Join(parameters, "&");
}
else
{
// Add '/' if addon is run without params (will be removed later so it's safe)
// Otherwise there are 2 entries for the same plugin in ViewModesX.db
urlParameters = "/";
}
std::string cmd;
if (plugin->Provides(CPluginSource::VIDEO))
cmd = StringUtils::Format("ActivateWindow(Videos,plugin://%s%s,return)", addonid.c_str(), urlParameters.c_str());
else if (plugin->Provides(CPluginSource::AUDIO))
cmd = StringUtils::Format("ActivateWindow(Music,plugin://%s%s,return)", addonid.c_str(), urlParameters.c_str());
else if (plugin->Provides(CPluginSource::EXECUTABLE))
cmd = StringUtils::Format("ActivateWindow(Programs,plugin://%s%s,return)", addonid.c_str(), urlParameters.c_str());
else if (plugin->Provides(CPluginSource::IMAGE))
cmd = StringUtils::Format("ActivateWindow(Pictures,plugin://%s%s,return)", addonid.c_str(), urlParameters.c_str());
else
// Pass the script name (addonid) and all the parameters
// (params[1] ... params[x]) separated by a comma to RunPlugin
cmd = StringUtils::Format("RunPlugin(%s)", StringUtils::Join(params, ",").c_str());
CBuiltins::GetInstance().Execute(cmd);
}
else if (CAddonMgr::GetInstance().GetAddon(addonid, addon, ADDON_SCRIPT) ||
CAddonMgr::GetInstance().GetAddon(addonid, addon, ADDON_SCRIPT_WEATHER) ||
CAddonMgr::GetInstance().GetAddon(addonid, addon, ADDON_SCRIPT_LYRICS) ||
CAddonMgr::GetInstance().GetAddon(addonid, addon, ADDON_SCRIPT_LIBRARY))
{
// Pass the script name (addonid) and all the parameters
// (params[1] ... params[x]) separated by a comma to RunScript
CBuiltins::GetInstance().Execute(StringUtils::Format("RunScript(%s)", StringUtils::Join(params, ",").c_str()));
}
else
CLog::Log(LOGERROR, "RunAddon: unknown add-on id '%s', or unexpected add-on type (not a script or plugin).", addonid.c_str());
}
else
{
CLog::Log(LOGERROR, "RunAddon called with no arguments.");
}
return 0;
}
JSONRPC_STATUS CAddonsOperations::GetAddons(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
std::vector<TYPE> addonTypes;
TYPE addonType = CAddonInfo::TranslateType(parameterObject["type"].asString());
CPluginSource::Content content = CPluginSource::Translate(parameterObject["content"].asString());
CVariant enabled = parameterObject["enabled"];
CVariant installed = parameterObject["installed"];
// ignore the "content" parameter if the type is specified but not a plugin or script
if (addonType != ADDON_UNKNOWN && addonType != ADDON_PLUGIN && addonType != ADDON_SCRIPT)
content = CPluginSource::UNKNOWN;
if (addonType >= ADDON_VIDEO && addonType <= ADDON_EXECUTABLE)
{
addonTypes.push_back(ADDON_PLUGIN);
addonTypes.push_back(ADDON_SCRIPT);
switch (addonType)
{
case ADDON_VIDEO:
content = CPluginSource::VIDEO;
break;
case ADDON_AUDIO:
content = CPluginSource::AUDIO;
break;
case ADDON_IMAGE:
content = CPluginSource::IMAGE;
break;
case ADDON_GAME:
content = CPluginSource::GAME;
break;
case ADDON_EXECUTABLE:
content = CPluginSource::EXECUTABLE;
break;
default:
break;
}
}
else
addonTypes.push_back(addonType);
VECADDONS addons;
for (std::vector<TYPE>::const_iterator typeIt = addonTypes.begin(); typeIt != addonTypes.end(); ++typeIt)
{
VECADDONS typeAddons;
if (*typeIt == ADDON_UNKNOWN)
{
if (!enabled.isBoolean()) //All
{
if (!installed.isBoolean() || installed.asBoolean())
CServiceBroker::GetAddonMgr().GetInstalledAddons(typeAddons);
if (!installed.isBoolean() || (installed.isBoolean() && !installed.asBoolean()))
CServiceBroker::GetAddonMgr().GetInstallableAddons(typeAddons);
}
else if (enabled.asBoolean() && (!installed.isBoolean() || installed.asBoolean())) //Enabled
CServiceBroker::GetAddonMgr().GetAddons(typeAddons);
else if (!installed.isBoolean() || installed.asBoolean())
CServiceBroker::GetAddonMgr().GetDisabledAddons(typeAddons);
}
else
{
if (!enabled.isBoolean()) //All
{
if (!installed.isBoolean() || installed.asBoolean())
CServiceBroker::GetAddonMgr().GetInstalledAddons(typeAddons, *typeIt);
if (!installed.isBoolean() || (installed.isBoolean() && !installed.asBoolean()))
CServiceBroker::GetAddonMgr().GetInstallableAddons(typeAddons, *typeIt);
}
else if (enabled.asBoolean() && (!installed.isBoolean() || installed.asBoolean())) //Enabled
CServiceBroker::GetAddonMgr().GetAddons(typeAddons, *typeIt);
else if (!installed.isBoolean() || installed.asBoolean())
CServiceBroker::GetAddonMgr().GetDisabledAddons(typeAddons, *typeIt);
}
addons.insert(addons.end(), typeAddons.begin(), typeAddons.end());
}
// remove library addons
for (int index = 0; index < (int)addons.size(); index++)
{
PluginPtr plugin;
if (content != CPluginSource::UNKNOWN)
plugin = std::dynamic_pointer_cast<CPluginSource>(addons.at(index));
if ((addons.at(index)->Type() <= ADDON_UNKNOWN || addons.at(index)->Type() >= ADDON_MAX) ||
((content != CPluginSource::UNKNOWN && plugin == NULL) || (plugin != NULL && !plugin->Provides(content))))
{
addons.erase(addons.begin() + index);
index--;
}
}
int start, end;
HandleLimits(parameterObject, result, addons.size(), start, end);
CAddonDatabase addondb;
for (int index = start; index < end; index++)
FillDetails(addons.at(index), parameterObject["properties"], result["addons"], addondb, true);
return OK;
}
NATRON_NAMESPACE_ENTER
PluginPtr
ViewerNode::createPlugin()
{
std::vector<std::string> grouping;
grouping.push_back(PLUGIN_GROUP_IMAGE);
PluginPtr ret = Plugin::create(ViewerNode::create, ViewerNode::createRenderClone, PLUGINID_NATRON_VIEWER_GROUP, "Viewer", 1, 0, grouping);
ret->setProperty<std::string>(kNatronPluginPropIconFilePath, "Images/viewer_icon.png");
QString desc = tr("The Viewer node can display the output of a node graph. Shift + double click on the viewer node to customize the viewer display process with a custom node tree");
ret->setProperty<ImageBitDepthEnum>(kNatronPluginPropOutputSupportedBitDepths, eImageBitDepthFloat, 0);
ret->setProperty<ImageBitDepthEnum>(kNatronPluginPropOutputSupportedBitDepths, eImageBitDepthShort, 1);
ret->setProperty<ImageBitDepthEnum>(kNatronPluginPropOutputSupportedBitDepths, eImageBitDepthByte, 2);
ret->setProperty<std::bitset<4> >(kNatronPluginPropOutputSupportedComponents, std::bitset<4>(std::string("1111")));
EffectDescriptionPtr effectDesc = ret->getEffectDescriptor();
effectDesc->setProperty<RenderSafetyEnum>(kEffectPropRenderThreadSafety, eRenderSafetyFullySafe);
effectDesc->setProperty<bool>(kEffectPropSupportsTiles, true);
ret->setProperty<std::string>(kNatronPluginPropDescription, desc.toStdString());
ret->setProperty<int>(kNatronPluginPropShortcut, (int)Key_I, 0);
ret->setProperty<int>(kNatronPluginPropShortcut, (int)eKeyboardModifierControl, 1
);
ret->addActionShortcut( PluginActionShortcut(kViewerInstanceParamClipToFormat, kViewerInstanceParamClipToFormatLabel, kViewerInstanceParamClipToFormatHint, Key_C, eKeyboardModifierShift) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamFullFrame, kViewerNodeParamFullFrameLabel, kViewerNodeParamFullFrameHint) );
ret->addActionShortcut( PluginActionShortcut(kViewerInstanceParamEnableUserRoI, kViewerInstanceParamEnableUserRoILabel, kViewerInstanceParamEnableUserRoIHint, Key_W, eKeyboardModifierShift) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamPauseRender, kViewerNodeParamPauseRenderLabel, kViewerNodeParamPauseRenderHint, Key_P) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamEnableGain, kViewerNodeParamEnableGainLabel, kViewerNodeParamEnableGainHint) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamEnableAutoContrast, kViewerNodeParamEnableAutoContrastLabel, kViewerNodeParamEnableAutoContrastHint) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamEnableGamma, kViewerNodeParamEnableGammaLabel, kViewerNodeParamEnableGammaHint) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRefreshViewport, kViewerNodeParamRefreshViewportLabel, kViewerNodeParamRefreshViewportHint, Key_U) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamFitViewport, kViewerNodeParamFitViewportLabel, kViewerNodeParamFitViewportHint, Key_F) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamSyncViewports, kViewerNodeParamSyncViewportsLabel, kViewerNodeParamSyncViewportsHint) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamCheckerBoard, kViewerNodeParamCheckerBoardLabel, kViewerNodeParamCheckerBoardHint) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamEnableColorPicker, kViewerNodeParamEnableColorPickerLabel, kViewerNodeParamEnableColorPickerHint) );
// Right-click actions
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuToggleWipe, kViewerNodeParamRightClickMenuToggleWipeLabel, "", Key_W) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuCenterWipe, kViewerNodeParamRightClickMenuCenterWipeLabel, "", Key_F, eKeyboardModifierShift) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuPreviousLayer, kViewerNodeParamRightClickMenuPreviousLayerLabel, "", Key_Page_Up) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuNextLayer, kViewerNodeParamRightClickMenuNextLayerLabel, "", Key_Page_Down) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuSwitchAB, kViewerNodeParamRightClickMenuSwitchABLabel, "", Key_Return) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuPreviousView, kViewerNodeParamRightClickMenuPreviousViewLabel, "", Key_Page_Up, eKeyboardModifierShift) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuNextView, kViewerNodeParamRightClickMenuNextViewLabel, "", Key_Page_Down, eKeyboardModifierShift) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuShowHideOverlays, kViewerNodeParamRightClickMenuShowHideOverlaysLabel, "", Key_O) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuHideAll, kViewerNodeParamRightClickMenuHideAllLabel, "", Key_space, KeyboardModifiers(eKeyboardModifierShift | eKeyboardModifierAlt) ));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuHideAllTop, kViewerNodeParamRightClickMenuHideAllTopLabel, "", Key_space, eKeyboardModifierShift ));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuHideAllBottom, kViewerNodeParamRightClickMenuHideAllBottomLabel, "", Key_space, eKeyboardModifierAlt ));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuShowHidePlayer, kViewerNodeParamRightClickMenuShowHidePlayerLabel, "") );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuShowHideTimeline, kViewerNodeParamRightClickMenuShowHideTimelineLabel, "") );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuShowHideLeftToolbar, kViewerNodeParamRightClickMenuShowHideLeftToolbarLabel, "") );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuShowHideTopToolbar, kViewerNodeParamRightClickMenuShowHideTopToolbarLabel, "") );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamRightClickMenuShowHideTabHeader, kViewerNodeParamRightClickMenuShowHideTabHeaderLabel, "") );
// Viewer actions
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionLuminance, kViewerNodeParamActionLuminanceLabel, "", Key_Y) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionRed, kViewerNodeParamActionRedLabel, "", Key_R) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionRedA, kViewerNodeParamActionRedALabel, "", Key_R, eKeyboardModifierShift) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionGreen, kViewerNodeParamActionGreenLabel, "", Key_G) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionGreenA, kViewerNodeParamActionGreenALabel, "", Key_G, eKeyboardModifierShift) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionBlue, kViewerNodeParamActionBlueLabel, "", Key_B) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionBlueA, kViewerNodeParamActionBlueALabel, "", Key_B, eKeyboardModifierShift) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionAlpha, kViewerNodeParamActionAlphaLabel, "", Key_A) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionAlphaA, kViewerNodeParamActionAlphaALabel, "", Key_A, eKeyboardModifierShift) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionMatte, kViewerNodeParamActionMatteLabel, "", Key_M) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionMatteA, kViewerNodeParamActionMatteALabel, "", Key_M, eKeyboardModifierShift) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionZoomIn, kViewerNodeParamActionZoomInLabel,"", Key_plus) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionZoomOut, kViewerNodeParamActionZoomOutLabel, "", Key_minus) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionScaleOne, kViewerNodeParamActionScaleOneLabel, "", Key_1, eKeyboardModifierControl) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionProxy2, kViewerNodeParamActionProxy2Label, "", Key_1, eKeyboardModifierAlt) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionProxy4, kViewerNodeParamActionProxy4Label, "", Key_2, eKeyboardModifierAlt) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionProxy8, kViewerNodeParamActionProxy8Label, "", Key_3, eKeyboardModifierAlt) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionProxy16, kViewerNodeParamActionProxy16Label, "", Key_4, eKeyboardModifierAlt) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionProxy32, kViewerNodeParamActionProxy32Label, "", Key_5, eKeyboardModifierAlt) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionLeftView, kViewerNodeParamActionLeftViewLabel, "", Key_Left, eKeyboardModifierAlt) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionRightView, kViewerNodeParamActionRightViewLabel, "", Key_Right, eKeyboardModifierAlt) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionCreateNewRoI, kViewerNodeParamActionCreateNewRoILabel, "", Key_W, eKeyboardModifierAlt) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionPauseAB, kViewerNodeParamActionPauseABLabel, "", Key_P, eKeyboardModifierShift) );
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionRefreshWithStats, kViewerNodeParamActionRefreshWithStatsLabel, "", Key_U, KeyboardModifiers(eKeyboardModifierShift | eKeyboardModifierControl)) );
// Player
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamPreviousFrame, kViewerNodeParamPreviousFrameLabel, kViewerNodeParamPreviousFrameHint, Key_Left, eKeyboardModifierNone));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamNextFrame, kViewerNodeParamNextFrameLabel, kViewerNodeParamNextFrameHint, Key_Right, eKeyboardModifierNone));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamPlayBackward, kViewerNodeParamPlayBackwardLabel, kViewerNodeParamPlayBackwardHint, Key_J, eKeyboardModifierNone));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamPlayForward, kViewerNodeParamPlayForwardLabel, kViewerNodeParamPlayForwardHint, Key_L, eKeyboardModifierNone));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamActionAbortRender, kViewerNodeParamActionAbortRenderLabel, kViewerNodeParamActionAbortRenderHint, Key_K, eKeyboardModifierNone));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamPreviousIncr, kViewerNodeParamPreviousIncrLabel, kViewerNodeParamPreviousIncrHint, Key_Left, eKeyboardModifierShift));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamNextIncr, kViewerNodeParamNextIncrLabel, kViewerNodeParamNextIncrHint, Key_Right, eKeyboardModifierShift));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamPreviousKeyFrame, kViewerNodeParamPreviousKeyFrameLabel, kViewerNodeParamPreviousKeyFrameHint, Key_Left, KeyboardModifiers(eKeyboardModifierShift | eKeyboardModifierControl)));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamNextKeyFrame, kViewerNodeParamNextKeyFrameLabel, kViewerNodeParamNextKeyFrameHint, Key_Right, KeyboardModifiers(eKeyboardModifierShift | eKeyboardModifierControl)));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamFirstFrame, kViewerNodeParamFirstFrameLabel, kViewerNodeParamFirstFrameHint, Key_Left, eKeyboardModifierControl));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamLastFrame, kViewerNodeParamLastFrameLabel, kViewerNodeParamLastFrameHint, Key_Right, eKeyboardModifierControl));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamSetInPoint, kViewerNodeParamSetInPointLabel, kViewerNodeParamSetInPointHint, Key_I, eKeyboardModifierAlt));
ret->addActionShortcut( PluginActionShortcut(kViewerNodeParamSetOutPoint, kViewerNodeParamSetOutPointLabel, kViewerNodeParamSetOutPointHint, Key_O, eKeyboardModifierAlt));
return ret;
}
