FlexboxLegacyContainerBuilder

Base for the LEGACY Row.Builder / Column.Builder. It keeps the exact Component.ContainerBuilder fluent surface (so every existing Row.create(c)...build() call site — Java or Kotlin — compiles unchanged and so Component.ContainerBuilder<?> handles keep working). The selected implementation is snapshotted when the builder is created: setters write directly to the legacy component when the flag is off, and accumulate a Style only when the flag is on.

build is gated by ComponentsConfiguration.useKComponentForLegacyRowColumn:

  • when ON, it constructs a KRow / KColumn carrying the accumulated Style (resolving via the launched Style -> CommonProps path — never a CommonProps -> Style -> CommonProps round trip);

  • when OFF (default), it returns the backing scratch legacy SpecGenerated Row/Column, whose CommonProps were populated directly by the inherited builder setters.

The Component.Builder machinery requires a SpecGeneratedComponent as its backing component; it doubles as the scratch for the flag-OFF path.

Inheritors

Functions

Link copied to clipboard
open override fun accessibilityHeading(isHeading: Boolean): T

Ports setAccessibilityHeading into components world. However, since the aforementioned ViewCompat's method is available only on API 19 and above, calling this method on lower APIs will have no effect. On the legit versions, on the other hand, calling this method will lead to the component being treated as a heading. The AccessibilityHeading property allows accessibility services to help users navigate directly from one heading to the next. See setHeading for more information.

Link copied to clipboard
open override fun accessibilityRole(accessibilityRole: String?): T
Link copied to clipboard
open fun accessibilityRoleDescription(@StringRes stringId: Int, vararg formatArgs: Any): T
open override fun accessibilityRoleDescription(roleDescription: CharSequence?): T
Link copied to clipboard
open override fun addSystemGestureExclusionZone(exclusion: (Rect) -> Rect): T
Link copied to clipboard
open override fun alignContent(alignContent: YogaAlign?): T

The AlignSelf property has the same options and effect as AlignItems but instead of affecting the children within a container, you can apply this property to a single child to change its alignment within its parent. See https://www.yogalayout.dev/docs/styling/align-content for more information.

Link copied to clipboard
open override fun alignItems(alignItems: YogaAlign?): T

The AlignItems property describes how to align children along the cross axis of their container. AlignItems is very similar to JustifyContent but instead of applying to the main axis, it applies to the cross axis. See https://www.yogalayout.dev/docs/styling/align-items-self for more information.

Link copied to clipboard
open override fun alignSelf(alignSelf: YogaAlign): T

Controls how a child aligns in the cross direction, overriding the alignItems of the parent. See https://www.yogalayout.dev/docs/styling/align-items-self for more information.

Link copied to clipboard
open override fun alpha(value: DynamicValue<Float>?): T

Links a DynamicValue object ot the alpha value for this Component

open override fun alpha(alpha: Float): T

Sets the alpha (opacity) of this component.

Link copied to clipboard
open override fun aspectRatio(aspectRatio: Float): T

Defined as the ratio between the width and the height of a node. See https://www.yogalayout.dev/docs/styling/aspect-ratio for more information

Link copied to clipboard
open override fun background(background: Drawable?): T

Set the background of this component. The background drawable can implement for more efficient diffing while when drawables are remounted or updated.

Link copied to clipboard
open fun backgroundAttr(@AttrRes resId: Int): T
open fun backgroundAttr(@AttrRes resId: Int, @DrawableRes defaultResId: Int): T
Link copied to clipboard
open override fun backgroundColor(value: DynamicValue<Int>?): T

Links a DynamicValue object to the background color value for this Component

open override fun backgroundColor(@ColorInt backgroundColor: Int): T
Link copied to clipboard
open override fun backgroundDynamicDrawable(value: DynamicValue<out Drawable>?): T

Links a DynamicValue object to the background drawable for this Component

Link copied to clipboard
open fun backgroundRes(@DrawableRes resId: Int): T
Link copied to clipboard
open override fun border(border: Border?): T
Link copied to clipboard
abstract fun build(): Component
Link copied to clipboard
open override fun child(child: Component.Builder<*>?): T
open override fun child(child: Component?): T
Link copied to clipboard
open override fun children(children: List<Component>): T
Link copied to clipboard
open override fun clickable(isClickable: Boolean): T
Link copied to clipboard
open override fun clickHandler(clickHandler: EventHandler<ClickEvent>?): T
Link copied to clipboard
open override fun clipChildren(clipChildren: Boolean): T

Ports setClipChildren into components world. However, there is no guarantee that child of this component would be translated into direct view child in the resulting view hierarchy.

Link copied to clipboard
open override fun clipToOutline(clipToOutline: Boolean): T
Link copied to clipboard
open override fun componentTag(componentTag: Any?): T
Link copied to clipboard
open fun contentDescription(@StringRes stringId: Int): T
open fun contentDescription(@StringRes stringId: Int, vararg formatArgs: Any): T
open override fun contentDescription(contentDescription: CharSequence?): T
Link copied to clipboard
open override fun defaultFocusHighlightEnabled(defaultFocusHighlightEnabled: Boolean): T

Ports setDefaultFocusHighlightEnabled into components world. Only effective on API 26+ (Android O); a no-op on older API levels. Setting this property will cause the Component to be represented as a View at mount time if it wasn't going to already.

open override fun dispatchPopulateAccessibilityEventHandler(dispatchPopulateAccessibilityEventHandler: EventHandler<DispatchPopulateAccessibilityEventEvent>?): T
Link copied to clipboard
open override fun duplicateChildrenStates(duplicateChildrenStates: Boolean): T

If true, component applies all of its children's drawable states (focused, pressed, etc.) to itself.

Link copied to clipboard
open override fun duplicateParentState(duplicateParentState: Boolean): T

If true, component duplicates its drawable state (focused, pressed, etc.) from the direct parent.

Link copied to clipboard
open override fun enabled(isEnabled: Boolean): T
Link copied to clipboard
open override fun flex(flex: Float): T

Yoga's flex shorthand is a different field from flexGrow, so the split by sign is load bearing. A positive value is equivalent either way here: Node.resolveFlexGrow falls back to flex, and because Litho's config sets useWebDefaults (com.facebook.litho.yoga.LithoYogaFactory.createYogaConfig) Node.processFlexBasis leaves basis at auto for a positive flex rather than pinning it to 0px. A negative value is not: Yoga reads it as shrink, and only via the !useWebDefaults branch of resolveFlexShrink, which Litho never takes — so passing it to grow would leave a negative grow factor on the node and stretch the child instead of leaving it at its content size.

Link copied to clipboard
open fun flexBasisDip(@Dimension(unit = 0) flexBasis: Float): T
Link copied to clipboard
open override fun flexBasisPercent(percent: Float): T
Link copied to clipboard
open override fun flexBasisPx(flexBasis: Int): T

The FlexBasis property is an axis-independent way of providing the default size of an item on the main axis. Setting the FlexBasis of a child is similar to setting the Width of that child if its parent is a container with FlexDirection = row or setting the Height of a child if its parent is a container with FlexDirection = column. The FlexBasis of an item is the default size of that item, the size of the item before any FlexGrow and FlexShrink calculations are performed. See https://www.yogalayout.dev/docs/styling/flex-basis-grow-shrink for more information.

Link copied to clipboard
open override fun flexGrow(flexGrow: Float): T

If the sum of childrens' main axis dimensions is less than the minimum size, how much should this component grow? This value represents the "flex grow factor" and determines how much this component should grow along the main axis in relation to any other flexible children. See https://www.yogalayout.dev/docs/styling/flex-basis-grow-shrink for more information.

Link copied to clipboard
open override fun flexShrink(flexShrink: Float): T

The FlexShrink property describes how to shrink children along the main axis in the case that the total size of the children overflow the size of the container on the main axis. See https://www.yogalayout.dev/docs/styling/flex-basis-grow-shrink for more information.

Link copied to clipboard
open override fun focusable(isFocusable: Boolean): T
Link copied to clipboard
open override fun focusChangeHandler(focusChangeHandler: EventHandler<FocusChangedEvent>?): T
Link copied to clipboard
open fun focusedHandler(@Nullable focusedHandler: EventHandler<FocusedVisibleEvent>?): T
open override fun focusedHandler(visibleWidthRatio: Float, visibleHeightRatio: Float, focusedHandler: EventHandler<FocusedVisibleEvent>?): T
Link copied to clipboard
open override fun foreground(foreground: Drawable?): T

Set the foreground of this component. The foreground drawable must extend for more efficient diffing while when drawables are remounted or updated. If the drawable does not extend ComparableDrawable then create a new class which extends ComparableDrawable and implement the isEquivalentTo.

Link copied to clipboard
open fun foregroundAttr(@AttrRes resId: Int): T
open fun foregroundAttr(@AttrRes resId: Int, @DrawableRes defaultResId: Int): T
Link copied to clipboard
open override fun foregroundColor(value: DynamicValue<Int>?): T
open override fun foregroundColor(@ColorInt foregroundColor: Int): T
Link copied to clipboard
open fun foregroundRes(@DrawableRes resId: Int): T
Link copied to clipboard
open fun fullImpressionHandler(@Nullable fullImpressionHandler: EventHandler<FullImpressionVisibleEvent>?): T
open override fun fullImpressionHandler(visibleWidthRatio: Float, visibleHeightRatio: Float, fullImpressionHandler: EventHandler<FullImpressionVisibleEvent>?): T
Link copied to clipboard
open override fun gapDip(gutter: YogaGutter, dip: Float): T

The Gap property is set on containers and spaces children evenly by a given length along a given axis

Link copied to clipboard
open override fun gapPx(gutter: YogaGutter, px: Int): T
Link copied to clipboard
Link copied to clipboard
abstract fun getThis(): T
Link copied to clipboard
open override fun handle(handle: Handle?): T
Link copied to clipboard
open override fun hasBackgroundSet(): Boolean
Link copied to clipboard
open override fun hasClickHandlerSet(): Boolean
Link copied to clipboard
open fun heightAttr(@AttrRes resId: Int): T
open fun heightAttr(@AttrRes resId: Int, @DimenRes defaultResId: Int): T
Link copied to clipboard
open fun heightDip(@Dimension(unit = 0) height: Float): T
Link copied to clipboard
open override fun heightPercent(percent: Float): T

Sets the height of the Component to be a percentage of its parent's height. Note that if the parent has unspecified height (e.g. it is a RecyclerView), then setting this will have no effect.

Link copied to clipboard
open override fun heightPx(height: Int): T

Specifies the height of the element's content area. See https://www.yogalayout.dev/docs/styling/width-height for more information

Link copied to clipboard
open fun heightRes(@DimenRes resId: Int): T
Link copied to clipboard
open override fun importantForAccessibility(importantForAccessibility: Int): T
Link copied to clipboard
open override fun interceptTouchHandler(interceptTouchHandler: EventHandler<InterceptTouchEvent>?): T
Link copied to clipboard
open fun invisibleHandler(@Nullable invisibleHandler: EventHandler<InvisibleEvent>?): T
open override fun invisibleHandler(visibleWidthRatio: Float, visibleHeightRatio: Float, invisibleHandler: EventHandler<InvisibleEvent>?): T
Link copied to clipboard
open override fun isReferenceBaseline(isReferenceBaseline: Boolean): T
Link copied to clipboard
open override fun justifyContent(justifyContent: YogaJustify?): T

The JustifyContent property describes how to align children within the main axis of a container. For example, you can use this property to center a child horizontally within a container with FlexDirection = Row or vertically within one with FlexDirection = Column. See https://www.yogalayout.dev/docs/styling/justify-content for more information.

Link copied to clipboard
open override fun key(key: String?): T

Set a key on the component that is local to its parent.

Link copied to clipboard
open override fun keyboardNavigationCluster(isKeyboardNavigationCluster: Boolean): T
Link copied to clipboard

Backwards compatibility for a Kotlin Component to accept a Style and apply it to a Java Spec Component. Using this builder method is the equivalent of setting all common props the Style defines.

Link copied to clipboard
open override fun layerType(type: Int, paint: Paint?): T
Link copied to clipboard
open override fun layoutDirection(direction: YogaDirection): T

The RTL/LTR direction of components and text. Determines whether START and END will resolve to the left or right side, among other things. INHERIT indicates this setting will be inherited from this component's parent.

Link copied to clipboard
open override fun longClickHandler(longClickHandler: EventHandler<LongClickEvent>?): T
Link copied to clipboard
open fun marginAttr(edge: YogaEdge, @AttrRes resId: Int): T
open fun marginAttr(edge: YogaEdge, @AttrRes resId: Int, @DimenRes defaultResId: Int): T
Link copied to clipboard
open override fun marginAuto(edge: YogaEdge): T
Link copied to clipboard
open fun marginDip(edge: YogaEdge, @Dimension(unit = 0) margin: Float): T
Link copied to clipboard
open override fun marginPercent(edge: YogaEdge, percent: Float): T
Link copied to clipboard
open override fun marginPx(edge: YogaEdge, margin: Int): T

Effects the spacing around the outside of a node. A node with margin will offset itself from the bounds of its parent but also offset the location of any siblings. See https://www.yogalayout.dev/docs/styling/margin-padding-border for more information

Link copied to clipboard
open fun marginRes(edge: YogaEdge, @DimenRes resId: Int): T
Link copied to clipboard
open fun maxHeightAttr(@AttrRes resId: Int): T
open fun maxHeightAttr(@AttrRes resId: Int, @DimenRes defaultResId: Int): T
Link copied to clipboard
open fun maxHeightDip(@Dimension(unit = 0) maxHeight: Float): T
Link copied to clipboard
open override fun maxHeightPercent(percent: Float): T
Link copied to clipboard
open override fun maxHeightPx(maxHeight: Int): T
Link copied to clipboard
open fun maxHeightRes(@DimenRes resId: Int): T
Link copied to clipboard
open fun maxWidthAttr(@AttrRes resId: Int): T
open fun maxWidthAttr(@AttrRes resId: Int, @DimenRes defaultResId: Int): T
Link copied to clipboard
open fun maxWidthDip(@Dimension(unit = 0) maxWidth: Float): T
Link copied to clipboard
open override fun maxWidthPercent(percent: Float): T
Link copied to clipboard
open override fun maxWidthPx(maxWidth: Int): T
Link copied to clipboard
open fun maxWidthRes(@DimenRes resId: Int): T
Link copied to clipboard
open fun minHeightAttr(@AttrRes resId: Int): T
open fun minHeightAttr(@AttrRes resId: Int, @DimenRes defaultResId: Int): T
Link copied to clipboard
open fun minHeightDip(@Dimension(unit = 0) minHeight: Float): T
Link copied to clipboard
open override fun minHeightPercent(percent: Float): T
Link copied to clipboard
open override fun minHeightPx(minHeight: Int): T
Link copied to clipboard
open fun minHeightRes(@DimenRes resId: Int): T
Link copied to clipboard
open fun minWidthAttr(@AttrRes resId: Int): T
open fun minWidthAttr(@AttrRes resId: Int, @DimenRes defaultResId: Int): T
Link copied to clipboard
open fun minWidthDip(@Dimension(unit = 0) minWidth: Float): T
Link copied to clipboard
open override fun minWidthPercent(percent: Float): T
Link copied to clipboard
open override fun minWidthPx(minWidth: Int): T

This property has higher priority than all other properties and will always be respected. See https://www.yogalayout.dev/docs/styling/min-max-width-height for more information

Link copied to clipboard
open fun minWidthRes(@DimenRes resId: Int): T
Link copied to clipboard
open override fun onInitializeAccessibilityEventHandler(onInitializeAccessibilityEventHandler: EventHandler<OnInitializeAccessibilityEventEvent>?): T
Link copied to clipboard
open override fun onInitializeAccessibilityNodeInfoHandler(onInitializeAccessibilityNodeInfoHandler: EventHandler<OnInitializeAccessibilityNodeInfoEvent>?): T
Link copied to clipboard
open override fun onPerformActionForVirtualViewHandler(onPerformActionForVirtualViewHandler: EventHandler<PerformActionForVirtualViewEvent>?): T
Link copied to clipboard
open override fun onPopulateAccessibilityEventHandler(onPopulateAccessibilityEventHandler: EventHandler<OnPopulateAccessibilityEventEvent>?): T
Link copied to clipboard
open override fun onRequestSendAccessibilityEventHandler(onRequestSendAccessibilityEventHandler: EventHandler<OnRequestSendAccessibilityEventEvent>?): T
Link copied to clipboard
open override fun onVirtualViewKeyboardFocusChangedHandler(onVirtualViewKeyboardFocusChangedHandler: EventHandler<VirtualViewKeyboardFocusChangedEvent>?): T
Link copied to clipboard
open override fun outlineProvider(outlineProvider: ViewOutlineProvider?): T
Link copied to clipboard
open fun paddingAttr(edge: YogaEdge, @AttrRes resId: Int): T
open fun paddingAttr(edge: YogaEdge, @AttrRes resId: Int, @DimenRes defaultResId: Int): T
Link copied to clipboard
open fun paddingDip(edge: YogaEdge, @Dimension(unit = 0) padding: Float): T
Link copied to clipboard
open override fun paddingPercent(edge: YogaEdge, percent: Float): T
Link copied to clipboard
open override fun paddingPx(edge: YogaEdge, padding: Int): T

Affects the size of the node it is applied to. Padding will not add to the total size of an element if it has an explicit size set. See https://www.yogalayout.dev/docs/styling/margin-padding-border for more information

Link copied to clipboard
open fun paddingRes(edge: YogaEdge, @DimenRes resId: Int): T
Link copied to clipboard
open override fun performAccessibilityActionHandler(performAccessibilityActionHandler: EventHandler<PerformAccessibilityActionEvent>?): T
Link copied to clipboard
open fun positionAttr(edge: YogaEdge, @AttrRes resId: Int): T
open fun positionAttr(edge: YogaEdge, @AttrRes resId: Int, @DimenRes defaultResId: Int): T
Link copied to clipboard
open fun positionDip(edge: YogaEdge, @Dimension(unit = 0) position: Float): T
Link copied to clipboard
open override fun positionPercent(edge: YogaEdge, percent: Float): T
Link copied to clipboard
open override fun positionPx(edge: YogaEdge, position: Int): T

When used in combination with positionType of ABSOLUTE, allows the component to specify how it should be positioned within its parent. See https://www.yogalayout.dev/docs/styling/position for more information.

Link copied to clipboard
open fun positionRes(edge: YogaEdge, @DimenRes resId: Int): T
Link copied to clipboard
open override fun positionType(positionType: YogaPositionType): T

Controls how this component will be positioned within its parent. See https://www.yogalayout.dev/docs/styling/position for more details.

Link copied to clipboard
open override fun reverse(reverse: Boolean): T

Set this to true if you want the container to be laid out in reverse.

Link copied to clipboard
open override fun rotation(rotation: DynamicValue<Float>?): T

Links a DynamicValue object to the rotation value for this Component

open override fun rotation(rotation: Float): T

Sets the degree that this component is rotated around the pivot point. Increasing the value results in clockwise rotation. By default, the pivot point is centered on the component.

Link copied to clipboard
open override fun rotationX(rotationX: DynamicValue<Float>?): T

Links a DynamicValue object to the rotationX value for this Component

open override fun rotationX(rotationX: Float): T

Sets the degree that this component is rotated around the horizontal axis through the pivot point.

Link copied to clipboard
open override fun rotationY(rotationY: DynamicValue<Float>?): T

Links a DynamicValue object to the rotationY value for this Component

open override fun rotationY(rotationY: Float): T

Sets the degree that this component is rotated around the vertical axis through the pivot point.

Link copied to clipboard
open override fun scale(scale: Float): T

Sets the scale (scaleX and scaleY) on this component. This is mostly relevant for animations and being able to animate size changes. Otherwise for non-animation usecases, you should use the standard layout properties to control the size of your component.

Link copied to clipboard
open override fun scaleX(value: DynamicValue<Float>?): T

Links a DynamicValue object to the scaleX value for this Component

Link copied to clipboard
open override fun scaleY(value: DynamicValue<Float>?): T

Links a DynamicValue object to the scaleY value for this Component

Link copied to clipboard
open override fun screenReaderFocusable(isFocusable: Boolean): T
Link copied to clipboard
open override fun selected(isSelected: Boolean): T
Link copied to clipboard
open override fun sendAccessibilityEventHandler(sendAccessibilityEventHandler: EventHandler<SendAccessibilityEventEvent>?): T
Link copied to clipboard
open override fun sendAccessibilityEventUncheckedHandler(sendAccessibilityEventUncheckedHandler: EventHandler<SendAccessibilityEventUncheckedEvent>?): T
Link copied to clipboard
open override fun shadowElevation(value: DynamicValue<Float>?): T

Links a DynamicValue object to the elevation value for this Component

Link copied to clipboard
open fun shadowElevationAttr(@AttrRes resId: Int): T
open fun shadowElevationAttr(@AttrRes resId: Int, @DimenRes defaultResId: Int): T
Link copied to clipboard
open fun shadowElevationDip(@Dimension(unit = 0) shadowElevation: Float): T
Link copied to clipboard
open override fun shadowElevationPx(shadowElevation: Float): T
Link copied to clipboard
open fun shadowElevationRes(@DimenRes resId: Int): T
Link copied to clipboard
open fun stateDescription(@StringRes stringId: Int): T
open fun stateDescription(@StringRes stringId: Int, vararg formatArgs: Any): T
open override fun stateDescription(stateDescription: CharSequence?): T
Link copied to clipboard
open override fun stateListAnimator(stateListAnimator: StateListAnimator?): T

Ports setStateListAnimator into components world. However, since the aforementioned view's method is available only on API 21 and above, calling this method on lower APIs will have no effect. On the legit versions, on the other hand, calling this method will lead to the component being wrapped into a view

Link copied to clipboard
open override fun stateListAnimatorRes(resId: Int): T

Ports setStateListAnimator into components world. However, since the aforementioned view's method is available only on API 21 and above, calling this method on lower APIs will have no effect. On the legit versions, on the other hand, calling this method will lead to the component being wrapped into a view

Link copied to clipboard
open override fun testKey(testKey: String?): T
Link copied to clipboard
open override fun tooltipText(tooltipText: String?): T
Link copied to clipboard
open fun touchExpansionAttr(edge: YogaEdge, @AttrRes resId: Int): T
open fun touchExpansionAttr(edge: YogaEdge, @AttrRes resId: Int, @DimenRes defaultResId: Int): T
Link copied to clipboard
open fun touchExpansionDip(edge: YogaEdge, @Dimension(unit = 0) touchExpansion: Float): T
Link copied to clipboard
open override fun touchExpansionPx(edge: YogaEdge, touchExpansion: Int): T
Link copied to clipboard
open fun touchExpansionRes(edge: YogaEdge, @DimenRes resId: Int): T
Link copied to clipboard
open override fun touchHandler(touchHandler: EventHandler<TouchEvent>?): T
Link copied to clipboard
open override fun transitionKey(key: String?): T
Link copied to clipboard
open override fun transitionKeyType(type: Transition.TransitionKeyType): T
Link copied to clipboard
open override fun transitionName(transitionName: String?): T
Link copied to clipboard
open override fun translationX(value: DynamicValue<Float>?): T

Links a DynamicValue object to the translationX value for this Component

Link copied to clipboard
open override fun translationY(value: DynamicValue<Float>?): T

Links a DynamicValue object to the translationY value for this Component

Link copied to clipboard
open override fun translationZ(value: DynamicValue<Float>?): T

Links a DynamicValue object to the translationZ value for this Component

Link copied to clipboard
open fun unfocusedHandler(@Nullable unfocusedHandler: EventHandler<UnfocusedVisibleEvent>?): T
open override fun unfocusedHandler(visibleWidthRatio: Float, visibleHeightRatio: Float, unfocusedHandler: EventHandler<UnfocusedVisibleEvent>?): T
Link copied to clipboard
open override fun useHeightAsBaseline(useHeightAsBaseline: Boolean): T

When set to true, overrides the default behaviour of baseline calculation and uses height of component as baseline. By default the baseline of a component is the baseline of first child of component (If the component does not have any child then baseline is height of the component)

Link copied to clipboard
open override fun viewId(id: Int): T
Link copied to clipboard
open override fun viewTag(viewTag: Any?): T
Link copied to clipboard
open override fun viewTags(viewTags: SparseArray<Any>?): T
Link copied to clipboard
open fun visibilityChangedHandler(@Nullable visibilityChangedHandler: EventHandler<VisibilityChangedEvent>?): T
open override fun visibilityChangedHandler(visibleWidthRatio: Float, visibleHeightRatio: Float, visibilityChangedHandler: EventHandler<VisibilityChangedEvent>?): T
Link copied to clipboard
open override fun visibilityOutputTag(visibilityOutputTag: String?): T
Link copied to clipboard
open fun visibleHandler(@Nullable visibleHandler: EventHandler<VisibleEvent>?): T
open override fun visibleHandler(visibleWidthRatio: Float, visibleHeightRatio: Float, visibleHandler: EventHandler<VisibleEvent>?): T
Link copied to clipboard
open fun widthAttr(@AttrRes resId: Int): T
open fun widthAttr(@AttrRes resId: Int, @DimenRes defaultResId: Int): T
Link copied to clipboard
open fun widthDip(@Dimension(unit = 0) width: Float): T
Link copied to clipboard
open override fun widthPercent(percent: Float): T

Sets the width of the Component to be a percentage of its parent's width. Note that if the parent has unspecified width (e.g. it is an HScroll), then setting this will have no effect.

Link copied to clipboard
open override fun widthPx(width: Int): T

Specifies the width of the element's content area. See https://www.yogalayout.dev/docs/styling/width-height for more information

Link copied to clipboard
open fun widthRes(@DimenRes resId: Int): T
Link copied to clipboard
open override fun wrap(wrap: YogaWrap?): T

The FlexWrap property is set on containers and controls what happens when children overflow the size of the container along the main axis. If a container specifies WRAP then its children will wrap to the next line instead of overflowing.

Link copied to clipboard
open override fun wrapInView(): T