blob: f34198378200d96cb2be10e65a85eb511a724dca [file]
#include <sstream>
#include <iomanip>
#include <array>
#include "rive/viewmodel/viewmodel.hpp"
#include "rive/viewmodel/viewmodel_property.hpp"
#include "rive/viewmodel/deferred_viewmodel_instance_body.hpp"
#include "rive/backboard.hpp"
#include "rive/data_bind/data_bind.hpp"
#include "rive/deferred_decode_lock.hpp"
#include "rive/file.hpp"
#include "rive/importers/backboard_importer.hpp"
#include <cassert>
using namespace rive;
namespace
{
// Set while this thread decodes an instance's values. Decoding one never
// needs another decoded: a value names the instance it refers to by index,
// which only a copy follows.
thread_local bool t_decodingInstance = false;
} // namespace
ViewModel::~ViewModel()
{
discardDeferredInstanceBodies();
for (auto& property : m_Properties)
{
delete property;
}
}
void ViewModel::deferInstanceBody(
size_t index,
DeferredViewModelInstanceBody* body)
{
// During the import, before anything else can see the view model.
if (m_deferredBodies.size() <= index)
{
m_deferredBodies.resize(index + 1, {nullptr, nullptr});
}
m_deferredBodies[index] = {m_Instances[index], body};
#ifdef TESTING
m_Instances[index]->m_testingBodyDeferred = true;
#endif
m_pendingBodies.fetch_add(1, std::memory_order_relaxed);
}
void ViewModel::decodeInstanceBody(size_t index)
{
assert(!t_decodingInstance);
std::lock_guard<std::recursive_mutex> lock(deferredDecodeMutex());
// Another thread may have decoded it while this one waited for the lock.
if (index >= m_deferredBodies.size() ||
m_deferredBodies[index].body == nullptr)
{
return;
}
DeferredInstance deferred = m_deferredBodies[index];
t_decodingInstance = true;
#ifdef TESTING
deferred.instance->m_testingBodyDeferred = false;
#endif
// The file outlives its pending bodies (discardDeferredInstanceBodies).
if (!m_file->decodeViewModelInstanceBody(deferred.instance, *deferred.body))
{
// Only a malformed file fails here (the import would have failed it
// whole); the instance keeps the values it read.
fprintf(
stderr,
"ViewModel: couldn't decode the deferred values of instance %s.\n",
deferred.instance->name().c_str());
m_file->m_deferredViewModelInstanceStats.decodeFailures++;
}
t_decodingInstance = false;
#ifdef TESTING
File::deferredViewModelInstanceDecodeCount++;
// Its binds have their converters before it's published: another thread
// may copy it without the lock as soon as it is. (Inside the import, the
// import resolves them, and nothing else sees the file until it's done.)
if (!m_file->m_importing)
{
for (DataBind* bind : deferred.instance->valueDataBinds())
{
assert(
(size_t)bind->converterId() >= m_file->m_DataConverters.size() ||
bind->converter() != nullptr);
}
}
#endif
m_deferredBodies[index].body = nullptr;
delete deferred.body;
m_pendingBodies.fetch_sub(1, std::memory_order_release);
}
bool ViewModel::hasDeferredInstanceBody(size_t index)
{
if (m_pendingBodies.load(std::memory_order_acquire) == 0)
{
return false;
}
std::lock_guard<std::recursive_mutex> lock(deferredDecodeMutex());
return index < m_deferredBodies.size() &&
m_deferredBodies[index].body != nullptr;
}
void ViewModel::discardDeferredInstanceBodies()
{
if (m_pendingBodies.load(std::memory_order_acquire) == 0)
{
return;
}
std::lock_guard<std::recursive_mutex> lock(deferredDecodeMutex());
for (auto& deferred : m_deferredBodies)
{
delete deferred.body;
deferred.body = nullptr;
}
m_pendingBodies.store(0, std::memory_order_release);
}
void ViewModel::addProperty(ViewModelProperty* property)
{
m_Properties.push_back(property);
}
ViewModelProperty* ViewModel::property(size_t index)
{
if (index < m_Properties.size())
{
return m_Properties[index];
}
return nullptr;
}
ViewModelProperty* ViewModel::property(const std::string& propName)
{
for (auto property : m_Properties)
{
if (property->name() == propName)
{
return property;
}
}
return nullptr;
}
ViewModelProperty* ViewModel::property(const SymbolType symbolType)
{
for (auto property : m_Properties)
{
if (property->symbolTypeValue() == static_cast<int>(symbolType))
{
return property;
}
}
return nullptr;
}
void ViewModel::addInstance(ViewModelInstance* value)
{
m_Instances.push_back(value);
value->viewModel(this);
}
// Every instance handed out is decoded first: whatever reads its values,
// copies it or binds it goes through one of these.
ViewModelInstance* ViewModel::defaultInstance()
{
if (m_Instances.size() > 0)
{
ensureDecoded(0);
return m_Instances[0];
}
return nullptr;
}
ViewModelInstance* ViewModel::instance(size_t index)
{
if (index < m_Instances.size())
{
ensureDecoded(index);
return m_Instances[index];
}
return nullptr;
}
ViewModelInstance* ViewModel::instance(const std::string& name)
{
// A deferred instance's name came with its record.
for (size_t index = 0; index < m_Instances.size(); index++)
{
if (m_Instances[index]->name() == name)
{
ensureDecoded(index);
return m_Instances[index];
}
}
return nullptr;
}
const std::string& ViewModel::instanceName(size_t index) const
{
static const std::string empty;
return index < m_Instances.size() ? m_Instances[index]->name() : empty;
}
std::vector<ViewModelInstance*> ViewModel::instances()
{
if (m_pendingBodies.load(std::memory_order_acquire) != 0)
{
for (size_t index = 0; index < m_Instances.size(); index++)
{
ensureDecoded(index);
}
}
return m_Instances;
}
size_t ViewModel::instanceCount() const { return m_Instances.size(); }
rcp<ViewModelInstance> ViewModel::createInstance()
{
if (m_file)
{
return m_file->createViewModelInstance(this);
}
return nullptr;
}
rcp<ViewModelInstance> ViewModel::createFromInstance(
const std::string& instanceName)
{
if (m_file)
{
return m_file->createViewModelInstance(this->name(), instanceName);
}
return nullptr;
}
#ifdef WITH_RIVE_EDITOR
void ViewModel::editorPrepareForDestruction()
{
// Definitions can be externally retained after the arena retires.
// Their instance lookup table must not expose freed arena entries.
m_Instances.erase(
std::remove_if(
m_Instances.begin(),
m_Instances.end(),
[](auto* instance) { return instance->editorArena() != nullptr; }),
m_Instances.end());
m_Properties.erase(
std::remove_if(
m_Properties.begin(),
m_Properties.end(),
[](auto* c) { return c->editorArena() != nullptr; }),
m_Properties.end());
}
#endif