final Component component = holder.getRootComponent(); final InternalNode layoutFromWillRender = component.consumeLayoutCreatedInWillRender(); final InternalNode nestedTree = layoutFromWillRender == null ? holder.getNestedTree() : layoutFromWillRender; nestedTree.getLastWidthSpec(), nestedTree.getLastHeightSpec(), widthSpec, heightSpec, nestedTree.getLastMeasuredWidth(), nestedTree.getLastMeasuredHeight())) { final Component root = holder.getRootComponent(); if (context.isNestedTreeResolutionExperimentEnabled() && root != null) { holder.setRootComponent(copy); widthSpec, heightSpec, holder.getDiffNode()); // Was set while traversing the holder's tree. resolvedLayout.setLastWidthSpec(widthSpec); resolvedLayout.setLastHeightSpec(heightSpec); resolvedLayout.setLastMeasuredHeight(resolvedLayout.getHeight()); resolvedLayout.setLastMeasuredWidth(resolvedLayout.getWidth()); holder.setNestedTree(resolvedLayout); } else {
final boolean isTreeRoot = layoutNode.getParent() == null; if (isLayoutSpecWithSizeSpec(layoutNode.getRootComponent()) && !isTreeRoot) { layoutNode.setDiffNode(diffNode); return; layoutNode.setDiffNode(diffNode); final int layoutCount = layoutNode.getChildCount(); final int diffCount = diffNode.getChildCount(); applyDiffNodeToUnchangedNodes(layoutNode.getChildAt(i), diffNode.getChildAt(i));
void copyInto(InternalNode layout) { if ((mPrivateFlags & PFLAG_CLICK_HANDLER_IS_SET) != 0) { layout.clickHandler(mClickHandler); layout.longClickHandler(mLongClickHandler); layout.focusChangeHandler(mFocusChangeHandler); layout.touchHandler(mTouchHandler); layout.interceptTouchHandler(mInterceptTouchHandler); layout.accessibilityRole(mAccessibilityRole); layout.accessibilityRoleDescription(mAccessibilityRoleDescription); layout.dispatchPopulateAccessibilityEventHandler(mDispatchPopulateAccessibilityEventHandler); layout.onInitializeAccessibilityEventHandler(mOnInitializeAccessibilityEventHandler); layout.onInitializeAccessibilityNodeInfoHandler(mOnInitializeAccessibilityNodeInfoHandler); layout.onPopulateAccessibilityEventHandler(mOnPopulateAccessibilityEventHandler); layout.onRequestSendAccessibilityEventHandler(mOnRequestSendAccessibilityEventHandler); layout.performAccessibilityActionHandler(mPerformAccessibilityActionHandler); layout.sendAccessibilityEventHandler(mSendAccessibilityEventHandler);
private boolean isLayoutRoot(InternalNode node) { return mLayoutRoot.isNestedTreeHolder() ? node == mLayoutRoot.getNestedTree() : node == mLayoutRoot; }
private static InternalNode parent(InternalNode node) { final InternalNode parent = node.getParent(); return parent != null ? parent : node.getNestedTreeHolder(); }
verify(node).layoutDirection(YogaDirection.INHERIT); verify(node).alignSelf(YogaAlign.AUTO); verify(node).positionType(YogaPositionType.ABSOLUTE); verify(node).flex(2); verify(node).flexGrow(3); verify(node).flexShrink(4); verify(node).flexBasisPx(5); verify(node).flexBasisPercent(6); .importantForAccessibility(ImportantForAccessibility.IMPORTANT_FOR_ACCESSIBILITY_AUTO); verify(node).duplicateParentState(false); verify(node).marginPx(YogaEdge.ALL, 5); verify(node).marginPx(YogaEdge.RIGHT, 6); verify(node).marginPx(YogaEdge.LEFT, 4); verify(node).marginPercent(YogaEdge.ALL, 10); verify(node).marginPercent(YogaEdge.VERTICAL, 12); verify(node).marginPercent(YogaEdge.RIGHT, 5); verify(node).marginAuto(YogaEdge.LEFT); verify(node).marginAuto(YogaEdge.TOP); verify(node).marginAuto(YogaEdge.RIGHT); verify(node).marginAuto(YogaEdge.BOTTOM); verify(node).paddingPx(YogaEdge.ALL, 1); verify(node).paddingPx(YogaEdge.RIGHT, 2); verify(node).paddingPx(YogaEdge.LEFT, 3); verify(node).paddingPercent(YogaEdge.VERTICAL, 7); verify(node).paddingPercent(YogaEdge.RIGHT, 6); verify(node).paddingPercent(YogaEdge.ALL, 5);
LayoutState layoutState, DiffNode parentDiffNode) { if (node.hasNewLayout()) { node.markLayoutSeen(); final Component component = node.getRootComponent(); final boolean isTracing = ComponentsSystrace.isTracing(); if (isTracing) { if (node.isNestedTreeHolder()) { .arg("widthSpec", "EXACTLY " + node.getWidth()) .arg("heightSpec", "EXACTLY " + node.getHeight()) .arg("rootComponentId", node.getRootComponent().getId()) .flush(); parentContext.isNestedTreeResolutionExperimentEnabled() ? parentContext : node.getContext(), node, SizeSpec.makeSizeSpec(node.getWidth(), EXACTLY), SizeSpec.makeSizeSpec(node.getHeight(), EXACTLY)); if (isTracing) { ComponentsSystrace.endSection(); layoutState.mCurrentX += node.getX(); layoutState.mCurrentY += node.getY(); layoutState.mCurrentX -= node.getX();
YogaMeasureMode heightMode) { final InternalNode node = (InternalNode) cssNode.getData(); final DiffNode diffNode = node.areCachedMeasuresValid() ? node.getDiffNode() : null; final Component component = node.getRootComponent(); final int widthSpec; final int heightSpec; node.setLastWidthSpec(widthSpec); node.setLastHeightSpec(heightSpec); if (Component.isNestedTree(component) || node.hasNestedTree()) { ComponentContext context = node.getContext(); if (node.getParent() != null) { context = node.getParent().getContext(); } else if (context.getLogger() != null) { context outputWidth = nestedTree.getWidth(); outputHeight = nestedTree.getHeight(); } else if (diffNode != null && diffNode.getLastWidthSpec() == widthSpec if (node.getDiffNode() != null) { node.getDiffNode().setLastWidthSpec(widthSpec); node.getDiffNode().setLastHeightSpec(heightSpec); node.getDiffNode().setLastMeasuredWidth(outputWidth); node.getDiffNode().setLastMeasuredHeight(outputHeight);
if (lastMeasuredLayout == null || !MeasureComparisonUtils.isMeasureSpecCompatible( lastMeasuredLayout.getLastWidthSpec(), widthSpec, lastMeasuredLayout.getWidth()) || !MeasureComparisonUtils.isMeasureSpecCompatible( lastMeasuredLayout.getLastHeightSpec(), heightSpec, lastMeasuredLayout.getHeight())) { releaseCachedLayout(); lastMeasuredLayout.setLastWidthSpec(widthSpec); lastMeasuredLayout.setLastHeightSpec(heightSpec); lastMeasuredLayout.setLastMeasuredWidth(lastMeasuredLayout.getWidth()); lastMeasuredLayout.setLastMeasuredHeight(lastMeasuredLayout.getHeight()); outputSize.width = lastMeasuredLayout.getWidth(); outputSize.height = lastMeasuredLayout.getHeight();
LayoutState layoutState) { final int l = layoutState.mCurrentX + node.getX(); final int t = layoutState.mCurrentY + node.getY(); final int r = l + node.getWidth(); final int b = t + node.getHeight(); final EventHandler<VisibleEvent> visibleHandler = node.getVisibleHandler(); final EventHandler<FocusedVisibleEvent> focusedHandler = node.getFocusedHandler(); final EventHandler<UnfocusedVisibleEvent> unfocusedHandler = node.getUnfocusedHandler(); final EventHandler<FullImpressionVisibleEvent> fullImpressionHandler = node.getFullImpressionHandler(); final EventHandler<InvisibleEvent> invisibleHandler = node.getInvisibleHandler(); final EventHandler<VisibilityChangedEvent> visibleRectChangedEventHandler = node.getVisibilityChangedHandler(); final VisibilityOutput visibilityOutput = ComponentsPools.acquireVisibilityOutput(); visibilityOutput.setComponent(node.getRootComponent()); visibilityOutput.setBounds(l, t, r, b); visibilityOutput.setVisibleHeightRatio(node.getVisibleHeightRatio()); visibilityOutput.setVisibleWidthRatio(node.getVisibleWidthRatio()); visibilityOutput.setVisibleEventHandler(visibleHandler); visibilityOutput.setFocusedEventHandler(focusedHandler);
int l = layoutState.mCurrentX + node.getX(); int t = layoutState.mCurrentY + node.getY(); int r = l + node.getWidth(); int b = t + node.getHeight(); final int paddingLeft = useNodePadding ? node.getPaddingLeft() : 0; final int paddingTop = useNodePadding ? node.getPaddingTop() : 0; final int paddingRight = useNodePadding ? node.getPaddingRight() : 0; final int paddingBottom = useNodePadding ? node.getPaddingBottom() : 0; NodeInfo nodeInfo = node.getNodeInfo(); if (isMountViewSpec) { layoutOutput.setNodeInfo(nodeInfo); if (useNodePadding && node.isPaddingSet()) { viewNodeInfo.setPadding(paddingLeft, paddingTop, paddingRight, paddingBottom); viewNodeInfo.setLayoutDirection(node.getResolvedLayoutDirection()); viewNodeInfo.setExpandedTouchBounds( node,
static void releaseNodeTree(InternalNode node, boolean isNestedTree) { if (node == NULL_LAYOUT) { throw new IllegalArgumentException("Cannot release a null node tree"); } for (int i = node.getChildCount() - 1; i >= 0; i--) { final InternalNode child = node.getChildAt(i); if (isNestedTree && node.hasNewLayout()) { node.markLayoutSeen(); } // A node must be detached from its parent *before* being released (otherwise the parent would // retain a reference to a node that may get re-used by another thread) node.removeChildAt(i); releaseNodeTree(child, isNestedTree); } if (node.hasNestedTree() && node.getNestedTree() != NULL_LAYOUT) { releaseNodeTree(node.getNestedTree(), true); } node.release(); }
internalNode.setLastWidthSpec(widthSpec); internalNode.setLastHeightSpec(heightSpec); internalNode.setLastMeasuredWidth(internalNode.getWidth()); internalNode.setLastMeasuredHeight(internalNode.getHeight());
@Test public void testLayoutOutputForRootNestedTreeComponentWithPercentPadding() { final Component component = new InlineLayoutSpec() { @Override protected Component onCreateLayout(final ComponentContext c) { return create(c) .alignItems(FLEX_START) .widthPx(50) .heightPx(50) .child( TestSizeDependentComponent.create(c) .setFixSizes(true) .paddingPercent(ALL, 10) .backgroundColor(0xFFFF0000)) .build(); } }; final InternalNode root = createAndMeasureTreeForComponent( new ComponentContext(application), component, makeSizeSpec(0, UNSPECIFIED), makeSizeSpec(0, UNSPECIFIED)); assertThat(root.getChildAt(0).getNestedTree().getPaddingLeft()).isEqualTo(5); assertThat(root.getChildAt(0).getNestedTree().getPaddingTop()).isEqualTo(5); assertThat(root.getChildAt(0).getNestedTree().getPaddingRight()).isEqualTo(5); assertThat(root.getChildAt(0).getNestedTree().getPaddingBottom()).isEqualTo(5); }
private void checkAllComponentsHaveMeasureCache(InternalNode node) { if (node.getRootComponent() != null && node.getRootComponent().canMeasure()) { assertCachedMeasurementsDefined(node); } int numChildren = node.getChildCount(); for (int i = 0; i < numChildren; i++) { checkAllComponentsHaveMeasureCache((InternalNode) node.getChildAt(i)); } }
if (deferNestedTreeResolution) { node = ComponentsPools.acquireInternalNode(context); node.markIsNestedTreeHolder(context.getTreeProps()); } else if (component.canResolve()) { context.setTreeProps(component.getScopedContext().getTreePropsCopy()); if (node.getRootComponent() == null) { if (ComponentsConfiguration.shouldSetBaselineFunctionOnYogaNode) { node.setBaselineFunction(sBaselineFunction); node.setMeasureFunction(sMeasureFunction); node.appendComponent((Component) this); if (TransitionUtils.areTransitionsEnabled(context.getAndroidContext())) { if (needsPreviousRenderData()) { node.addComponentNeedingPreviousRenderData((Component) this); } else { final Transition transition = createTransition(context); if (transition != null) { node.addTransition(transition); node.addWorkingRanges(component.mWorkingRangeRegistrations);
final Component component = node.getRootComponent(); if (component == null) { continue; if (component.hasManualKey() || node.hasTransitionKey() || node.getTestKey() != null) { builder.append('['); if (component.hasManualKey()) { builder.append("manual.key=\"").append(component.getKey()).append("\";"); if (node.hasTransitionKey()) { builder.append("trans.key=\"").append(node.getTransitionKey()).append("\";"); if (node.getTestKey() != null) { builder.append("test.key=\"").append(node.getTestKey()).append("\";"); if (node.getChildCount() == 0) { continue; for (int index = node.getChildCount() - 1; index >= 0; index--) { stack.addLast(node.getChildAt(index));
private void applyOverridesRecursive(InternalNode node) { if (ComponentsConfiguration.isDebugModeEnabled) { DebugComponent.applyOverrides(mComponentContext, node); for (int i = 0, count = node.getChildCount(); i < count; i++) { applyOverridesRecursive(node.getChildAt(i)); } if (node.hasNestedTree()) { applyOverridesRecursive(node.getNestedTree()); } } }
@Test public void testDefaultDimenPaddingRes() { Column column = Column.create(mContext).paddingRes(LEFT, test_dimen).build(); InternalNode node = Layout.create(mContext, column); node.calculateLayout(); int dimen = mContext.getResources().getDimensionPixelSize(test_dimen); assertThat(node.getWidth()).isEqualTo(dimen); }