Revision control
++ // Copyright (C) 2022 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++ // Qt-Security score:critical reason:data-parser
++
++ #include "addnodemodel.h"
++ #include "nodesmodel.h"
++ #include "effectmanager.h"
++ #include <QDir>
++
++ bool operator==(const AddNodeModel::NodeData &a, const AddNodeModel::NodeData &b) noexcept
++ {
++ return a.name == b.name;
++ }
++
++ AddNodeModel::AddNodeModel(QObject *effectManager)
++ : QAbstractListModel(effectManager)
++ {
++ m_effectManager = static_cast<EffectManager *>(effectManager);
++ connect(this, &QAbstractListModel::modelReset, this, &AddNodeModel::rowCountChanged);
++ updateNodesList();
++ }
++
++ int AddNodeModel::rowCount(const QModelIndex &) const
++ {
++ return m_modelList.size();
++ }
++
++ QHash<int, QByteArray> AddNodeModel::roleNames() const
++ {
++ QHash<int, QByteArray> roles;
++ roles[Name] = "name";
++ roles[Description] = "description";
++ roles[File] = "file";
++ roles[Group] = "group";
++ roles[Properties] = "properties";
++ roles[CanBeAdded] = "canBeAdded";
++ roles[Show] = "show";
++ roles[RequiredNodes] = "requires";
++ return roles;
++ }
++
++ QVariant AddNodeModel::data(const QModelIndex &index, int role) const
++ {
++ if (!index.isValid())
++ return QVariant();
++
++ if (index.row() >= m_modelList.size())
++ return false;
++
++ const auto &node = (m_modelList)[index.row()];
++
++ if (role == Name)
++ return QVariant::fromValue(node.name);
++ else if (role == Description)
++ return QVariant::fromValue(node.description);
++ else if (role == File)
++ return QVariant::fromValue(node.file);
++ else if (role == Group)
++ return QVariant::fromValue(node.group);
++ else if (role == Properties)
++ return QVariant::fromValue(node.properties);
++ else if (role == CanBeAdded)
++ return QVariant::fromValue(node.canBeAdded);
++ else if (role == Show)
++ return QVariant::fromValue(node.show);
++ else if (role == RequiredNodes)
++ return QVariant::fromValue(node.requiredNodes.join(", "));
++
++ return QVariant();
++ }
++
++ void AddNodeModel::loadNodesFromPath(const QString &path) {
++ qInfo() << "Loading nodes from:" << path;
++ QList<NodeData> nodes;
++
++ QDir rootDirectory(path);
++ QStringList dirList;
++ dirList << path;
++ // List subdirectories, in our preferred order
++ QStringList subDirList = rootDirectory.entryList(QDir::AllDirs | QDir::NoDotAndDotDot, QDir::Name);
++ for (auto &subDir : subDirList) {
++ QString dirPath = (path + "/" + subDir);
++ // Trick to get "common" nodes first in list
++ if (subDir == "common")
++ dirList.prepend(dirPath);
++ else
++ dirList.append(dirPath);
++ }
++ // Load nodes from all subdirectories
++ for (const auto &dirPath : dirList) {
++ QDir directory(dirPath);
++ QStringList nodeList = directory.entryList(QStringList() << "*.qen" << "*.QEN", QDir::Files, QDir::Name);
++ for (auto &filename : nodeList) {
++ QString filePath = directory.path() + "/" + filename;
++ auto node = m_effectManager->loadEffectNode(filePath);
++ if (!node.name.isEmpty()) {
++ NodeData data;
++ data.file = filePath;
++ data.name = node.name;
++ if (!node.jsonUniforms.isEmpty()) {
++ for (const auto &u : node.jsonUniforms) {
++ NodeDataProperty property;
++ property.m_name = u.name;
++ if (u.type == UniformModel::Uniform::Type::Define)
++ property.m_type = QStringLiteral("define");
++ else
++ property.m_type = UniformModel::typeToProperty(u.type);
++ QVariant varProperty;
++ varProperty.setValue(property);
++ data.properties << varProperty;
++ }
++ }
++ data.description = node.description;
++ data.group = directory.dirName();
++ // Seek through code to get tags
++ QStringList shaderCodeLines;
++ shaderCodeLines += node.vertexCode.split('\n');
++ shaderCodeLines += node.fragmentCode.split('\n');
++ for (const auto &codeLine : shaderCodeLines) {
++ QString trimmedLine = codeLine.trimmed();
++ if (trimmedLine.startsWith("@requires")) {
++ // Get the required node, remove "@requires"
++ QString l = trimmedLine.sliced(9).trimmed();
++ QString nodeName = l.split(' ').first();
++ if (!nodeName.isEmpty() && !data.requiredNodes.contains(nodeName))
++ data.requiredNodes << nodeName;
++ }
++ }
++ if (!m_modelList.contains(data))
++ nodes << data;
++ }
++ }
++ }
++
++ // Add all nodes into model
++ for (const auto &node : nodes)
++ m_modelList << node;
++ }
++
++ void AddNodeModel::updateCanBeAdded(const QStringList &propertyNames)
++ {
++ beginResetModel();
++ // Check which nodes contain overlapping properties
++ for (auto &nodeData : m_modelList) {
++ for (const auto &variant : nodeData.properties) {
++ NodeDataProperty property = variant.value<NodeDataProperty>();
++ if (propertyNames.contains(property.m_name)) {
++ nodeData.canBeAdded = false;
++ } else {
++ nodeData.canBeAdded = true;
++ }
++ }
++ }
++ endResetModel();
++ }
++
++ void AddNodeModel::updateShowHide(const QString &groupName, bool show)
++ {
++ int i = 0;
++ for (auto &nodeData : m_modelList) {
++ if (nodeData.group == groupName) {
++ nodeData.show = show;
++ Q_EMIT dataChanged(QAbstractItemModel::createIndex(0, 0),
++ QAbstractItemModel::createIndex(i, 0));
++ }
++ i++;
++ }
++ }
++
++ void AddNodeModel::updateNodesList()
++ {
++ beginResetModel();
++
++ m_modelList.clear();
++
++ QString defaultNodePath = m_effectManager->settings()->defaultResourcePath() + "/defaultnodes";
++ loadNodesFromPath(defaultNodePath);
++
++ auto customNodesPaths = m_effectManager->settings()->customNodesPaths();
++ for (const auto &nodesPath : std::as_const(customNodesPaths))
++ loadNodesFromPath(nodesPath);
++
++ static QString envCustomNodePath = qEnvironmentVariable("QQEM_CUSTOM_NODES_PATH");
++ if (!envCustomNodePath.isEmpty())
++ loadNodesFromPath(envCustomNodePath);
++
++ endResetModel();
++ }