C++ PluginInfo::isSelectable方法代码示例

void CliApplication::includePlugins(const QStringList &pPluginNames,
                                    bool pInclude) const
{
    // Retrieve all the plugins that are available

    QString pluginsDir = QCoreApplication::libraryPaths().first()+"/"+qAppName();
    QFileInfoList fileInfoList = QDir(pluginsDir).entryInfoList(QStringList("*"+PluginExtension), QDir::Files);
    QStringList availablePluginNames = QStringList();

    for (const auto &fileInfo : fileInfoList) {
        availablePluginNames << Plugin::name(fileInfo.canonicalFilePath());
    }

    // Include/exclude the given plugins to/from the GUI version of OpenCOR,
    // after having sorted them and made sure that they actually exist

    QStringList pluginNames = pPluginNames;

    std::sort(pluginNames.begin(), pluginNames.end());

    for (const auto &pluginName : pluginNames) {
        QString status;

        if (availablePluginNames.contains(pluginName)) {
            // Make sure that the plugin is selectable before including/excluding it

            QString errorMessage;
            PluginInfo *pluginInfo = Plugin::info(Plugin::fileName(pluginsDir, pluginName), &errorMessage);

            if (pluginInfo != nullptr) {
                if (pluginInfo->isSelectable()) {
                    Plugin::setLoad(pluginName, pInclude);

                    status = QString("%1 the GUI version of OpenCOR").arg(pInclude?
                                                                              "included to":
                                                                              "excluded from");
                } else {
                    status = QString("cannot be directly %1").arg(pInclude?
                                                                      "included":
                                                                      "excluded");
                }
            } else {
                status = QString("plugin information not found%1").arg(errorMessage.isEmpty()?
                                                                           QString():
                                                                           QString(" (%1)").arg(errorMessage));
            }
        } else {
            status = "unknown plugin";
        }

        std::cout << " - " << pluginName.toStdString() << ": " << status.toStdString() << "." << std::endl;
    }
}

    foreach (Plugin *plugin, plugins) {
        // Create the item corresponding to the current plugin

        QStandardItem *pluginItem = new QStandardItem((plugin->status() == Plugin::Loaded)?LoadedIcon:NotLoadedIcon,
                                                      plugin->name());

        // Only selectable plugins and plugins that are of the right type are
        // checkable

        PluginInfo *pluginInfo = plugin->info();

        if (pluginInfo) {
            pluginItem->setCheckable(pluginInfo->isSelectable());

            if (pluginItem->isCheckable()) {
                // Retrieve the loading state of the plugin

                pluginItem->setCheckState((Plugin::load(plugin->name()))?
                                              Qt::Checked:
                                              Qt::Unchecked);

                // We are dealing with a selectable plugin, so add it to our
                // list of selectable plugins

                mSelectablePluginItems << pluginItem;
            } else {
                // We are dealing with an unselectable plugin, so add it to our
                // list of unselectable plugins

                mUnselectablePluginItems << pluginItem;
            }

            // Add the plugin to the right category or the Miscellaneous
            // category, if we don't know about its category

            QStandardItem *category = mPluginCategories.value(pluginInfo->category());

            if (!category)
                category = mPluginCategories.value(MiscellaneousCategory);

            category->appendRow(pluginItem);
        } else {
            // We are not actually dealing with a plugin, so add it to the
            // Miscellaneous category

            mUnselectablePluginItems << pluginItem;

            mPluginCategories.value(MiscellaneousCategory)->appendRow(pluginItem);
        }
    }

    foreach (const QString &fileName, sortedFileNames) {
        QString pluginName = Plugin::name(fileName);
        PluginInfo *pluginInfo = pluginsInfo.value(pluginName);

        if (pluginInfo) {
            // Keep track of the plugin itself, should it be selectable and
            // requested by the user (if we are in GUI mode) or have CLI support
            // (if we are in CLI mode)

            if (   ( pGuiMode && pluginInfo->isSelectable() && Plugin::load(pluginName))
                || (!pGuiMode && pluginInfo->hasCliSupport())) {
                // Keep track of the plugin's dependencies

                neededPlugins << pluginsInfo.value(pluginName)->fullDependencies();

                // Also keep track of the plugin itself

                wantedPlugins << pluginName;
            }
        }
    }