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; }