void YogaLayoutableShadowNode::layout(LayoutContext layoutContext) {
if (!getIsLayoutClean()) {
ensureUnsealed();
/*
* In Yoga, every single Yoga Node has to have a (non-null) pointer to
* Yoga Config (this config can be shared between many nodes),
* so every node can be individually configured. This does *not* mean
* however that Yoga consults with every single Yoga Node Config for every
* config parameter. Especially in case of `pointScaleFactor`,
* the only value in the config of the root node is taken into account
* (and this is by design).
*/
yogaConfig_.pointScaleFactor = layoutContext.pointScaleFactor;
{
SystraceSection s("YogaLayoutableShadowNode::YGNodeCalculateLayout");
YGNodeCalculateLayout(
&yogaNode_, YGUndefined, YGUndefined, YGDirectionInherit);
}
}
LayoutableShadowNode::layout(layoutContext);
}
void YogaLayoutableShadowNode::appendChild(SharedYogaLayoutableShadowNode child) {
ensureUnsealed();
auto nonConstYogaNode = std::const_pointer_cast<YGNode>(yogaNode_);
auto nonConstChildYogaNode = std::const_pointer_cast<YGNode>(child->yogaNode_);
nonConstYogaNode->insertChild(nonConstChildYogaNode.get(), nonConstYogaNode->getChildrenCount());
}
void YogaLayoutableShadowNode::layout(LayoutContext layoutContext) {
if (!getIsLayoutClean()) {
ensureUnsealed();
YGNodeCalculateLayout(&yogaNode_, YGUndefined, YGUndefined, YGDirectionInherit);
}
LayoutableShadowNode::layout(layoutContext);
}
void AttributedString::prependAttributedString(
const AttributedString &attributedString) {
ensureUnsealed();
fragments_.insert(
fragments_.begin(),
attributedString.fragments_.begin(),
attributedString.fragments_.end());
}
void ParagraphShadowNode::updateLocalData() {
ensureUnsealed();
auto localData = std::make_shared<ParagraphLocalData>();
localData->setAttributedString(getAttributedString());
localData->setTextLayoutManager(textLayoutManager_);
setLocalData(localData);
}
bool LayoutableShadowNode::setLayoutMetrics(LayoutMetrics layoutMetrics) {
if (layoutMetrics_ == layoutMetrics) {
return false;
}
ensureUnsealed();
layoutMetrics_ = layoutMetrics;
return true;
}
void YogaLayoutableShadowNode::layout(LayoutContext layoutContext) {
ensureUnsealed();
if (!getIsLayoutClean()) {
YGNode *yogaNode = const_cast<YGNode *>(yogaNode_.get());
YGNodeCalculateLayout(yogaNode, YGUndefined, YGUndefined, YGDirectionInherit);
}
LayoutableShadowNode::layout(layoutContext);
}
void YogaLayoutableShadowNode::appendChild(SharedYogaLayoutableShadowNode child) {
ensureUnsealed();
auto yogaNodeRawPtr = &yogaNode_;
auto childYogaNodeRawPtr = &child->yogaNode_;
yogaNodeRawPtr->insertChild(childYogaNodeRawPtr, yogaNodeRawPtr->getChildrenCount());
if (childYogaNodeRawPtr->getOwner() == nullptr) {
child->ensureUnsealed();
childYogaNodeRawPtr->setOwner(yogaNodeRawPtr);
}
}
void YogaLayoutableShadowNode::appendChild(SharedYogaLayoutableShadowNode child) {
ensureUnsealed();
auto yogaNodeRawPtr = &yogaNode_;
auto childYogaNodeRawPtr = &child->yogaNode_;
if (childYogaNodeRawPtr->getOwner() != nullptr) {
child = std::static_pointer_cast<const YogaLayoutableShadowNode>(cloneAndReplaceChild(child));
childYogaNodeRawPtr = &child->yogaNode_;
}
child->ensureUnsealed();
childYogaNodeRawPtr->setOwner(yogaNodeRawPtr);
yogaNodeRawPtr->insertChild(childYogaNodeRawPtr, yogaNodeRawPtr->getChildren().size());
}
void YogaLayoutableShadowNode::layoutChildren(LayoutContext layoutContext) {
ensureUnsealed();
for (auto child : getChildren()) {
auto yogaLayoutableChild = std::dynamic_pointer_cast<const YogaLayoutableShadowNode>(child);
if (!yogaLayoutableChild) {
continue;
}
auto nonConstYogaLayoutableChild = std::const_pointer_cast<YogaLayoutableShadowNode>(yogaLayoutableChild);
LayoutMetrics childLayoutMetrics = layoutMetricsFromYogaNode(*nonConstYogaLayoutableChild->yogaNode_);
bool isAffected = nonConstYogaLayoutableChild->setLayoutMetrics(childLayoutMetrics);
if (isAffected) {
layoutContext.affectedShadowNodes->insert(child);
}
}
}
void YogaLayoutableShadowNode::appendChild(YogaLayoutableShadowNode *child) {
ensureUnsealed();
auto yogaNodeRawPtr = &yogaNode_;
auto childYogaNodeRawPtr = &child->yogaNode_;
if (childYogaNodeRawPtr->getOwner() != nullptr) {
child = static_cast<YogaLayoutableShadowNode *>(
cloneAndReplaceChild(child, yogaNode_.getChildren().size()));
childYogaNodeRawPtr = &child->yogaNode_;
assert(childYogaNodeRawPtr->getOwner() == nullptr);
}
child->ensureUnsealed();
childYogaNodeRawPtr->setOwner(yogaNodeRawPtr);
yogaNodeRawPtr->insertChild(
childYogaNodeRawPtr, yogaNodeRawPtr->getChildren().size());
}
void ShadowNode::replaceChild(
const SharedShadowNode &oldChild,
const SharedShadowNode &newChild,
int suggestedIndex) {
ensureUnsealed();
cloneChildrenIfShared();
auto nonConstChildren =
std::const_pointer_cast<SharedShadowNodeList>(children_);
if (suggestedIndex != -1 && suggestedIndex < nonConstChildren->size()) {
if (nonConstChildren->at(suggestedIndex) == oldChild) {
(*nonConstChildren)[suggestedIndex] = newChild;
return;
}
}
std::replace(
nonConstChildren->begin(), nonConstChildren->end(), oldChild, newChild);
}
void ImageShadowNode::updateLocalData() {
const auto &imageSource = getImageSource();
const auto ¤tLocalData = getLocalData();
if (currentLocalData) {
assert(std::dynamic_pointer_cast<const ImageLocalData>(currentLocalData));
auto currentImageLocalData =
std::static_pointer_cast<const ImageLocalData>(currentLocalData);
if (currentImageLocalData->getImageSource() == imageSource) {
// Same `imageSource` is already in `localData`,
// no need to (re)request an image resource.
return;
}
}
// Now we are about to mutate the Shadow Node.
ensureUnsealed();
auto imageRequest = imageManager_->requestImage(imageSource);
auto imageLocalData =
std::make_shared<ImageLocalData>(imageSource, std::move(imageRequest));
setLocalData(imageLocalData);
}
Sealable& Sealable::operator= (Sealable&& other) noexcept {
ensureUnsealed();
return *this;
};
void ImageShadowNode::setImageManager(const SharedImageManager &imageManager) {
ensureUnsealed();
imageManager_ = imageManager;
}
void AttributedString::prependFragment(const Fragment &fragment) {
ensureUnsealed();
fragments_.insert(fragments_.begin(), fragment);
}
void AttributedString::appendFragment(const Fragment &fragment) {
ensureUnsealed();
fragments_.push_back(fragment);
}
void YogaLayoutableShadowNode::enableMeasurement() {
ensureUnsealed();
yogaNode_.setMeasureFunc(YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector);
}
void ParagraphShadowNode::setTextLayoutManager(
SharedTextLayoutManager textLayoutManager) {
ensureUnsealed();
textLayoutManager_ = textLayoutManager;
}
Sealable& Sealable::operator= (const Sealable& other) {
ensureUnsealed();
return *this;
}
void ShadowNode::setLocalData(const SharedLocalData &localData) {
ensureUnsealed();
localData_ = localData;
}
