src/component.cpp

#include "rive/component.hpp"
#include "rive/artboard.hpp"
#include "rive/container_component.hpp"
#include "rive/core_context.hpp"
#include "rive/importers/artboard_importer.hpp"
#include "rive/importers/import_stack.hpp"
#include <algorithm>

using namespace rive;

StatusCode Component::onAddedDirty(CoreContext* context)
{
	m_Artboard = static_cast<Artboard*>(context);
	if (this == m_Artboard)
	{
		// We're the artboard, don't parent to ourselves.
		return StatusCode::Ok;
	}
	auto coreObject = context->resolve(parentId());
	if (coreObject == nullptr || !coreObject->is<ContainerComponent>())
	{
		return StatusCode::MissingObject;
	}
	m_Parent = reinterpret_cast<ContainerComponent*>(coreObject);
	return StatusCode::Ok;
}

void Component::addDependent(Component* component)
{
	// Make it's not already a dependent.
	if (std::find(m_Dependents.begin(), m_Dependents.end(), component) !=
	    m_Dependents.end())
	{
		return;
	}
	m_Dependents.push_back(component);
}

bool Component::addDirt(ComponentDirt value, bool recurse)
{
	if ((m_Dirt & value) == value)
	{
		// Already marked.
		return false;
	}

	// Make sure dirt is set before calling anything that can set more dirt.
	m_Dirt |= value;

	onDirty(m_Dirt);

	m_Artboard->onComponentDirty(this);

	if (!recurse)
	{
		return true;
	}

	for (auto d : m_Dependents)
	{
		d->addDirt(value, true);
	}
	return true;
}

StatusCode Component::import(ImportStack& importStack)
{
	if (is<Artboard>())
	{
		// Artboards are always their first object.
		assert(as<Artboard>()->objects().size() == 0);
		as<Artboard>()->addObject(this);
		return Super::import(importStack);
	}

	auto artboardImporter =
	    importStack.latest<ArtboardImporter>(ArtboardBase::typeKey);
	if (artboardImporter == nullptr)
	{
		return StatusCode::MissingObject;
	}
	artboardImporter->addComponent(this);
	return Super::import(importStack);
}