Revision control
Copy as Markdown
// Copyright (C) 2018 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qlottiebase_p.h"
#include <QLoggingCategory>
#include <QRegularExpression>
#include <QRegularExpressionMatch>
#include <QString>
QT_BEGIN_NAMESPACE
using namespace Qt::Literals::StringLiterals;
Q_LOGGING_CATEGORY(lcLottieQtLottieParser, "qt.lottieqt.lottie.parser", QtWarningMsg);
Q_LOGGING_CATEGORY(lcLottieQtLottieUpdate, "qt.lottieqt.lottie.update");
Q_LOGGING_CATEGORY(lcLottieQtLottieRender, "qt.lottieqt.lottie.render");
QLottieBase::QLottieBase(const QLottieBase &other)
{
m_definition = other.m_definition;
m_type = other.m_type;
m_hidden = other.m_hidden;
m_name = other.m_name;
for (QLottieBase *child : other.m_children) {
QLottieBase *clone = child->clone();
clone->setParent(this);
appendChild(clone);
}
}
QLottieBase::~QLottieBase()
{
qDeleteAll(m_children);
}
QLottieBase *QLottieBase::clone() const
{
return new QLottieBase(*this);
}
QString QLottieBase::name() const
{
return m_name;
}
void QLottieBase::setName(const QString &name)
{
m_name = name;
}
bool QLottieBase::setProperty(QLottieLiteral::PropertyType propertyName, QVariant value)
{
for (QLottieBase *child : std::as_const(m_children)) {
bool changed = child->setProperty(propertyName, value);
if (changed)
return true;
}
return false;
}
int QLottieBase::type() const
{
return m_type;
}
void QLottieBase::setType(int type)
{
m_type = type;
}
bool QLottieBase::isShapeElement() const
{
return (m_type >= LOTTIE_SHAPE_ELLIPSE_IX && m_type <= LOTTIE_SHAPE_REPEATER_IX);
}
bool QLottieBase::isPathElement() const
{
return (m_type == LOTTIE_SHAPE_ELLIPSE_IX || m_type == LOTTIE_SHAPE_RECT_IX
|| m_type == LOTTIE_SHAPE_SHAPE_IX || m_type == LOTTIE_SHAPE_STAR_IX);
}
void QLottieBase::prependChild(QLottieBase *child)
{
m_children.push_front(child);
}
void QLottieBase::insertChildBeforeLast(QLottieBase *child)
{
m_children.insert(qMax(m_children.size() - 1, 0), child);
}
void QLottieBase::appendChild(QLottieBase *child)
{
m_children.push_back(child);
}
QLottieBase *QLottieBase::findChild(const QString &childName)
{
if (name() == childName)
return this;
QLottieBase *found = nullptr;
for (QLottieBase *child : std::as_const(m_children)) {
found = child->findChild(childName);
if (found)
break;
}
return found;
}
void QLottieBase::updateProperties(int frame)
{
if (m_hidden)
return;
for (QLottieBase *child : std::as_const(m_children))
child->updateProperties(frame);
}
void QLottieBase::render(QLottieRenderer &renderer) const
{
if (m_hidden)
return;
renderer.saveState();
renderChildren(renderer);
renderer.restoreState();
}
void QLottieBase::renderChildren(QLottieRenderer &renderer) const
{
QList<QLottieBase *> pathElements;
for (QLottieBase *child : std::as_const(m_children)) {
if (child->isPathElement()) {
if (!child->m_hidden)
pathElements.prepend(child);
} else {
if (!pathElements.isEmpty()) {
renderer.renderPathElements(pathElements);
pathElements.clear();
}
if (!child->m_hidden)
child->render(renderer);
}
}
if (!pathElements.isEmpty())
renderer.renderPathElements(pathElements);
}
bool QLottieBase::isStructureDumping() const
{
if (m_structureDumping < 0) {
QLottieBase *p = parent();
m_structureDumping = p ? p->isStructureDumping() : 0;
}
return bool(m_structureDumping);
}
void QLottieBase::resolveTopRoot()
{
if (!m_topRoot) {
QLottieBase *p = this;
while (p) {
m_topRoot = p;
p = p->parent();
}
}
Q_ASSERT(m_topRoot);
}
QLottieBase *QLottieBase::topRoot() const
{
if (!m_topRoot)
const_cast<QLottieBase *>(this)->resolveTopRoot();
return m_topRoot;
}
int QLottieBase::parse(const QJsonObject &definition)
{
qCDebug(lcLottieQtLottieParser) << "QLottieBase::parse()";
m_definition = definition;
m_hidden = definition.value("hd"_L1).toBool(false);
m_name = definition.value("nm"_L1).toString();
m_matchName = definition.value("mn"_L1).toString();
return 0;
}
const QJsonObject &QLottieBase::definition() const
{
return m_definition;
}
bool QLottieBase::active(int frame) const
{
Q_UNUSED(frame);
return !m_hidden;
}
bool QLottieBase::hidden() const
{
return m_hidden;
}
QSize QLottieBase::layerSize() const
{
return m_parent ? m_parent->layerSize() : QSize();
}
void QLottieBase::setParent(QLottieBase *parent)
{
m_parent = parent;
}
const QJsonObject QLottieBase::resolveExpression(const QJsonObject &definition)
{
QString expr = definition.value("x"_L1).toString();
// If there is no expression, return the original object definition
if (expr.isEmpty())
return definition;
// Find out layer handle
resolveTopRoot();
QRegularExpression re(QStringLiteral("effect\\(\\'(.*?)\\'\\)\\(\\'(.*?)\\'\\)"));
QRegularExpressionMatch match = re.match(expr);
if (!match.hasMatch())
return definition;
QString effect = match.captured(1);
QString elementName = match.captured(2);
QJsonObject retVal = definition;
if (QLottieBase *source = m_topRoot->findChild(effect)) {
if (source->children().size())
retVal = source->children().at(0)->definition().value("v"_L1).toObject();
else
retVal = source->definition().value("v"_L1).toObject();
if (source->children().size() > 1)
qCInfo(lcLottieQtLottieParser) << "Effect source points"
"to a group that has"
"many children. The"
"first is be picked";
} else {
qCInfo(lcLottieQtLottieParser) << "Failed to find specified effect" << effect;
}
// Let users of the json know that it is originated from expression,
// so they can adjust their behavior accordingly
retVal.insert("fromExpression"_L1, true);
return retVal;
}
bool QLottieBase::checkRequiredKeys(const QJsonObject &definition, const QLatin1StringView type,
const QList<QLatin1StringView> &keys, const QString &name) const
{
for (auto key : keys) {
if (!definition.contains(key)) {
qCWarning(lcLottieQtLottieParser) << type << name << "is missing required key \"" << key << "\"";
return false;
}
}
return true;
}
QT_END_NAMESPACE