src/data_bind/context/context_value.cpp

#include "rive/data_bind/context/context_value.hpp"
#include "rive/data_bind/context/context_value_color.hpp"
#include "rive/data_bind/data_values/data_type.hpp"
#include "rive/data_bind/data_values/data_value.hpp"
#include "rive/data_bind/data_values/data_value_number.hpp"
#include "rive/data_bind/data_values/data_value_string.hpp"
#include "rive/data_bind/data_values/data_value_enum.hpp"
#include "rive/data_bind/data_values/data_value_color.hpp"
#include "rive/data_bind/data_values/data_value_boolean.hpp"
#include "rive/data_bind/data_values/data_value_trigger.hpp"
#include "rive/data_bind/data_values/data_value_list.hpp"
#include "rive/data_bind/data_values/data_value_symbol_list_index.hpp"
#include "rive/data_bind/data_values/data_value_asset_image.hpp"
#include "rive/data_bind/data_values/data_value_asset_font.hpp"
#include "rive/data_bind/data_values/data_value_asset_blob.hpp"
#include "rive/data_bind/data_values/data_value_artboard.hpp"
#include "rive/data_bind/data_values/data_value_viewmodel.hpp"
#include "rive/generated/core_registry.hpp"
#include "rive/refcnt.hpp"

using namespace rive;

DataBindContextValue::DataBindContextValue(DataBind* dataBind)
{
  // Only allocate the target-side cache for binds that will read from the
  // target (toSource or TwoWay). Pure toTarget binds never touch
  // m_targetValue — calculateValueAndApply is only reached via
  // applyToSource(), which is guarded by toSource() in updateSourceBinding.
  if (dataBind->toSource())
  {
    m_targetValue.initialize(dataBind);
  }
  auto source = dataBind->source();
  if (source != nullptr)
  {
    switch (source->coreType())
    {
      case ViewModelInstanceNumberBase::typeKey:
        m_dataValue = new DataValueNumber(
            source->as<ViewModelInstanceNumber>()->propertyValue());
        break;
      case ViewModelInstanceStringBase::typeKey:
        m_dataValue = new DataValueString(
            source->as<ViewModelInstanceString>()->propertyValue());
        break;
      case ViewModelInstanceColorBase::typeKey:
        m_dataValue = new DataValueColor(
            source->as<ViewModelInstanceColor>()->propertyValue());
        break;
      case ViewModelInstanceBooleanBase::typeKey:
        m_dataValue = new DataValueBoolean(
            source->as<ViewModelInstanceBoolean>()->propertyValue());
        break;
      case ViewModelInstanceEnumBase::typeKey:
      {
        auto viewmodelInstanceEnum = source->as<ViewModelInstanceEnum>();
        auto viewModelProperty = viewmodelInstanceEnum->viewModelProperty();
        auto viewModelPropertyEnum = viewModelProperty != nullptr &&
                                             viewModelProperty
                                                 ->is<ViewModelPropertyEnum>()
                                         ? viewModelProperty
                                               ->as<ViewModelPropertyEnum>()
                                         : nullptr;
        m_dataValue = new DataValueEnum(
            viewmodelInstanceEnum->propertyValue(),
            viewModelPropertyEnum != nullptr ? viewModelPropertyEnum->dataEnum()
                                             : nullptr);
      }
      break;
      case ViewModelInstanceTriggerBase::typeKey:
        m_dataValue = new DataValueTrigger(
            source->as<ViewModelInstanceTrigger>()->propertyValue());
        break;
      case ViewModelInstanceListBase::typeKey:
        m_dataValue = new DataValueList();
        break;
      case ViewModelInstanceSymbolListIndexBase::typeKey:
        m_dataValue = new DataValueSymbolListIndex();
        break;
      case ViewModelInstanceAssetImageBase::typeKey:
        m_dataValue = new DataValueAssetImage(
            source->as<ViewModelInstanceAssetImage>()->propertyValue());
        break;
      case ViewModelInstanceAssetFontBase::typeKey:
        m_dataValue = new DataValueAssetFont(
            source->as<ViewModelInstanceAssetFont>()->propertyValue());
        break;
      case ViewModelInstanceAssetBlobBase::typeKey:
        m_dataValue = new DataValueAssetBlob(
            source->as<ViewModelInstanceAssetBlob>()->propertyValue());
        break;
      case ViewModelInstanceArtboardBase::typeKey:
        m_dataValue = new DataValueArtboard(
            source->as<ViewModelInstanceArtboard>()->propertyValue());
        break;
      case ViewModelInstanceViewModelBase::typeKey:
        m_dataValue = new DataValueViewModel();
        break;
      default:
        m_dataValue = new DataValue();
    }
  }
}

void DataBindContextValue::syncSourceValue(DataBind* dataBind)
{
  auto source = dataBind->source();
  if (source != nullptr)
  {
    switch (source->coreType())
    {
      case ViewModelInstanceNumberBase::typeKey:
        m_dataValue->as<DataValueNumber>()->value(
            source->as<ViewModelInstanceNumber>()->propertyValue());
        break;
      case ViewModelInstanceStringBase::typeKey:
        m_dataValue->as<DataValueString>()->value(
            source->as<ViewModelInstanceString>()->propertyValue());
        break;
      case ViewModelInstanceColorBase::typeKey:
        m_dataValue->as<DataValueColor>()->value(
            source->as<ViewModelInstanceColor>()->propertyValue());
        break;
      case ViewModelInstanceBooleanBase::typeKey:
        m_dataValue->as<DataValueBoolean>()->value(
            source->as<ViewModelInstanceBoolean>()->propertyValue());
        break;
      case ViewModelInstanceEnumBase::typeKey:
        m_dataValue->as<DataValueEnum>()->value(
            source->as<ViewModelInstanceEnum>()->propertyValue());
        break;
      case ViewModelInstanceTriggerBase::typeKey:
        m_dataValue->as<DataValueTrigger>()->value(
            source->as<ViewModelInstanceTrigger>()->propertyValue());
        break;
      case ViewModelInstanceListBase::typeKey:
      {
        m_dataValue->as<DataValueList>()->clear();
        auto items = source->as<ViewModelInstanceList>()->listItems();
        for (auto& item : items)
        {
          m_dataValue->as<DataValueList>()->addItem(item);
        }
        break;
      }
      case ViewModelInstanceSymbolListIndexBase::typeKey:
        m_dataValue->as<DataValueSymbolListIndex>()->value(
            source->as<ViewModelInstanceSymbolListIndex>()->propertyValue());
        break;

      case ViewModelInstanceAssetImageBase::typeKey:
        m_dataValue->as<DataValueAssetImage>()->value(
            source->as<ViewModelInstanceAssetImage>()->propertyValue());
        break;
      case ViewModelInstanceAssetFontBase::typeKey:
        m_dataValue->as<DataValueAssetFont>()->value(
            source->as<ViewModelInstanceAssetFont>()->propertyValue());
        break;
      case ViewModelInstanceAssetBlobBase::typeKey:
        m_dataValue->as<DataValueAssetBlob>()->value(
            source->as<ViewModelInstanceAssetBlob>()->propertyValue());
        break;
      case ViewModelInstanceArtboardBase::typeKey:
        m_dataValue->as<DataValueArtboard>()->value(
            source->as<ViewModelInstanceArtboard>()->propertyValue());
        break;
      case ViewModelInstanceViewModelBase::typeKey:
        m_dataValue->as<DataValueViewModel>()->value(
            source->as<ViewModelInstanceViewModel>()
                ->referenceViewModelInstance()
                .get());
        break;
    }
  }
}

void DataBindContextValue::applyToSource(
    Core* component,
    uint32_t propertyKey,
    bool isMainDirection,
    DataBind* dataBind)
{
  auto source = dataBind->source();
  switch (source->coreType())
  {
    case ViewModelInstanceNumberBase::typeKey:
    {

      calculateValueAndApply<DataValueNumber, float, ViewModelInstanceNumber>(
          isMainDirection,
          dataBind);
    }
    break;
    case ViewModelInstanceStringBase::typeKey:
    {
      calculateValueAndApply<
          DataValueString,
          std::string,
          ViewModelInstanceString>(isMainDirection, dataBind);
    }
    break;
    case ViewModelInstanceColorBase::typeKey:
    {
      calculateValueAndApply<DataValueColor, int, ViewModelInstanceColor>(
          isMainDirection,
          dataBind);
    }
    break;
    case ViewModelInstanceBooleanBase::typeKey:
    {
      calculateValueAndApply<DataValueBoolean, bool, ViewModelInstanceBoolean>(
          isMainDirection,
          dataBind);
    }
    break;
    case ViewModelInstanceEnumBase::typeKey:
    {
      calculateValueAndApply<DataValueInteger, uint32_t, ViewModelInstanceEnum>(
          isMainDirection,
          dataBind);
    }
    break;
    case ViewModelInstanceTriggerBase::typeKey:
    {
      calculateValueAndApply<
          DataValueInteger,
          uint32_t,
          ViewModelInstanceTrigger>(isMainDirection, dataBind);
    }
    break;
    case ViewModelInstanceSymbolListIndexBase::typeKey:
    {
      calculateValueAndApply<
          DataValueInteger,
          uint32_t,
          ViewModelInstanceSymbolListIndex>(isMainDirection, dataBind);
    }
    break;
    case ViewModelInstanceAssetImageBase::typeKey:
    {
      calculateValueAndApply<
          DataValueInteger,
          uint32_t,
          ViewModelInstanceAssetImage>(isMainDirection, dataBind);
    }
    break;
    case ViewModelInstanceAssetFontBase::typeKey:
    {
      calculateValueAndApply<
          DataValueInteger,
          uint32_t,
          ViewModelInstanceAssetFont>(isMainDirection, dataBind);
    }
    break;
    case ViewModelInstanceAssetBlobBase::typeKey:
    {
      calculateValueAndApply<
          DataValueInteger,
          uint32_t,
          ViewModelInstanceAssetBlob>(isMainDirection, dataBind);
    }
    break;
    case ViewModelInstanceArtboardBase::typeKey:
    {
      calculateValueAndApply<
          DataValueInteger,
          uint32_t,
          ViewModelInstanceArtboard>(isMainDirection, dataBind);
    }
    break;
    case ViewModelInstanceViewModelBase::typeKey:
    {
      calculateValueAndApply<
          DataValueViewModel,
          ViewModelInstance*,
          ViewModelInstanceViewModel>(isMainDirection, dataBind);
    }
    break;
  }
}