鸿蒙5.0开发进阶:UI框架-ArkTS组件(RelativeContainer)

OpenHarmony实战开发-相对布局 (RelativeContainer) 在应用的开发过程中,经常需要设计复杂界面,此时涉及到多个相同或不同组件之间的嵌套。如果布局组件嵌套深度过深,或者嵌套组件数过多,会带来额外的开销。如果在布局的方式上进行优化,就可以有效的提升性能,减少时间开销。请参考优化布局时间了解RelativeContainer相对于List,在布局时间上的性能提升。 阅读详情

往期鸿蒙全套实战文章必看:(文中附带全栈鸿蒙学习资料)


RelativeContainer

相对布局组件,用于复杂场景中元素对齐的布局。

说明

该组件从API Version 9开始支持。后续版本如有新增内容,则采用上角标单独标记该内容的起始版本。

规则说明

  • 容器内子组件区分水平方向,垂直方向:
    • 水平方向为left, middle, right,对应容器的HorizontalAlign.Start, HorizontalAlign.Center, HorizontalAlign.End。
    • 垂直方向为top, center, bottom,对应容器的VerticalAlign.Top, VerticalAlign.Center, VerticalAlign.Bottom。
  • 子组件可以将容器、guideline、barrier或者其他子组件设为锚点:
    • 参与相对布局的容器内组件,不设置id的组件能显示,但是不能被其他子组件作为锚点,相对布局容器会为其拼接id,此id的规律无法被应用感知;容器id固定为__container__;guideline和barrier的id不能与组件重复,重复的话按照组件 > guideline > barrier的优先级生效。
    • 此子组件某一方向上的三个位置(水平方向为left、middle、right,垂直方向为top、center、bottom)可以指定容器或其他子组件同方向的三个位置(水平方向为HorizontalAlign.Start、HorizontalAlign.Center、HorizontalAlign.End,垂直方向为VerticalAlign.Top、VerticalAlign.Center、VerticalAlign.Bottom)为锚点。若同方向上设置两个以上锚点,水平方向Start和Center优先,垂直方向Top和Center优先。例如,水平方向上指定了left以容器的HorizontalAlign.Start为锚点,middle以容器的HorizontalAlign.Center为锚点,又指定right的锚点为容器的HorizontalAlign.End,当组件的width和容器的width不能同时满足3条约束规则时,优先取Start和Center的约束规则。
    • 当同时存在前端页面设置的子组件尺寸和相对布局规则时,子组件的绘制尺寸取决于约束规则。从API Version 11开始,该规则发生变化,子组件绘制尺寸取决于前端页面设置的尺寸。
    • 对齐后需要额外偏移可设置offset(API Version 11上新增了bias, 不建议再使用offset)。
    • 从API Version 11开始,在RelativeContainer组件中,width、height设置auto表示自适应子组件。
    • 当width设置auto时,如果水平方向上子组件以容器作为锚点,则auto不生效,垂直方向上同理。
    • 相对布局容器内的子组件的margin含义不同于通用属性的margin,其含义为到该方向上的锚点的距离。若该方向上没有锚点,则该方向的margin不生效。
    • guideline的位置在不声明或者声明异常值(如undefined)时,取start:0的位置;start和end两种方式声明一种即可,同时声明时仅start生效。
    • 当容器在某个方向的size声明为“auto”时,该方向上guideline的位置只能使用start的方式声明(不可使用百分比)。
    • 垂直方向的guideline和barrier只能作为组件水平方向的锚点,作为垂直方向的锚点时取0;水平方向的guideline和barrier只能作为组件垂直方向的锚点,作为水平方向的锚点时取0。
    • 链的形成依靠组件间的依赖关系。以一个组件A、组件B组成的最小水平链为例,需要有锚点1 <-- 组件A <---> 组件B --> 锚点2的依赖关系,即A具有left锚点,B具有right锚点,同时A的right锚点是B的HorizontalAlign.Start,B的left锚点是A的HorizontalAlign.End。
    • 链的方向和格式声明在链头组件的chainMode接口;链内元素的bias属性全部失效,链头元素的bias作为整个链的bias生效。
    • 链内所有元素的size如果超出链的锚点约束,超出的部分将均分在链的两侧。在Packed链中,超出部分的分布可以通过bias来设置。
  • 特殊情况
    • 根据约束条件和子组件本身的size属性无法确定子组件大小,则子组件不绘制。
    • 互相依赖、环形依赖时容器内子组件全部不绘制。
    • 同方向上两个及以上位置设置锚点但锚点位置逆序时此子组件大小为0,即不绘制。

子组件

支持多个子组件。

接口

RelativeContainer()

卡片能力: 从API version 9开始,该接口支持在ArkTS卡片中使用。

元服务API: 从API version 11开始,该接口支持在元服务中使用。

系统能力: SystemCapability.ArkUI.ArkUI.Full

属性

除支持通用属性外,还支持如下属性:

guideLine12+

guideLine(value: Array<GuideLineStyle>)

设置RelativeContainer容器内的辅助线,Array中每个项目即为一条guideline。

元服务API: 从API version 12开始,该接口支持在元服务中使用。

系统能力: SystemCapability.ArkUI.ArkUI.Full

参数:

参数名类型必填说明
valueArray<GuideLineStyle>是RelativeContainer容器内的辅助线。

barrier12+

barrier(value: Array<BarrierStyle>)

设置RelativeContainer容器内的屏障,Array中每个项目即为一条barrier。

元服务API: 从API version 12开始,该接口支持在元服务中使用。

系统能力: SystemCapability.ArkUI.ArkUI.Full

参数:

参数名类型必填说明
valueArray<BarrierStyle>是RelativeContainer容器内的屏障。

barrier12+

barrier(barrierStyle: Array<LocalizedBarrierStyle>)

设置RelativeContaine容器内的屏障,Array中每个项目即为一条barrier。

元服务API: 从API version 12开始,该接口支持在元服务中使用。

系统能力: SystemCapability.ArkUI.ArkUI.Full

参数:

参数名类型必填说明
barrierStyleArray<LocalizedBarrierStyle>是RelativeContaine容器内的屏障。

GuideLineStyle12+对象说明

guideLine参数,用于定义一条guideline的id、方向和位置。

元服务API: 从API version 12开始,该接口支持在元服务中使用。

系统能力: SystemCapability.ArkUI.ArkUI.Full

名称类型必填说明
idstring是guideline的id,必须是唯一的并且不可与容器内组件重名。
directionAxis是

指定guideline的方向。

默认值:Axis.Vertical

positionGuideLinePosition是

指定guideline的位置。

默认值:

{

start: 0

}

GuideLinePosition12+对象说明

guideLine位置参数,用于定义guideline的位置。

元服务API: 从API version 12开始,该接口支持在元服务中使用。

系统能力: SystemCapability.ArkUI.ArkUI.Full

名称类型必填说明
startDimension否guideline距离容器左侧或者顶部的距离。
endDimension否guideline距离容器右侧或者底部的距离。

BarrierStyle12+对象说明

barrier参数,用于定义一条barrier的id、方向和生成时所依赖的组件。

元服务API: 从API version 12开始,该接口支持在元服务中使用。

系统能力: SystemCapability.ArkUI.ArkUI.Full

名称类型必填说明
idstring是barrier的id,必须是唯一的并且不可与容器内组件重名。
directionBarrierDirection是

指定barrier的方向。

默认值:BarrierDirection.LEFT

referencedIdArray<string>是指定生成barrier所依赖的组件。

BarrierDirection12+枚举说明

定义屏障线的方向。

元服务API: 从API version 12开始,该接口支持在元服务中使用。

系统能力: SystemCapability.ArkUI.ArkUI.Full

名称描述
LEFT屏障在其所有referencedId的最左侧。
RIGHT屏障在其所有referencedId的最右侧。
TOP屏障在其所有referencedId的最上方。
BOTTOM屏障在其所有referencedId的最下方。

LocalizedBarrierStyle12+对象说明

barrier参数,用于定义一条barrier的id、方向和生成时所依赖的组件。

元服务API: 从API version 12开始,该接口支持在元服务中使用。

系统能力: SystemCapability.ArkUI.ArkUI.Full

名称类型必填说明
idstring是barrier的id,必须是唯一的并且不可与容器内组件重名。
localizedDirectionLocalizedBarrierDirection是指定barrier的方向。
referencedIdArray<string>是指定生成barrier所依赖的组件。

LocalizedBarrierDirection12+枚举说明

定义屏障线的方向。

元服务API: 从API version 12开始,该接口支持在元服务中使用。

系统能力: SystemCapability.ArkUI.ArkUI.Full

名称值描述
START0屏障在其所有referencedId的最左/右侧,LTR模式时为最左侧,RTL模式时为最右侧。
END1屏障在其所有referencedId的最左/右侧, LTR模式时为最右侧,RTL模式时为最左侧。
TOP2屏障在其所有referencedId的最上方。
BOTTOM3屏障在其所有referencedId的最下方。

示例

示例1(以容器和容器内组件作为锚点进行布局)

本示例通过alignRules接口实现了以容器和容器内组件作为锚点进行布局的功能。

@Entry
@Component
struct Index {
  build() {
    Row() {
      RelativeContainer() {
        Row() {
          Text('row1')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#a3cf62')
        .alignRules({
          top: { anchor: "__container__", align: VerticalAlign.Top },
          left: { anchor: "__container__", align: HorizontalAlign.Start }
        })
        .id("row1")

        Row() {
          Text('row2')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#00ae9d')
        .alignRules({
          top: { anchor: "__container__", align: VerticalAlign.Top },
          right: { anchor: "__container__", align: HorizontalAlign.End }
        })
        .id("row2")

        Row() {
          Text('row3')
        }
        .justifyContent(FlexAlign.Center)
        .height(100)
        .backgroundColor('#0a59f7')
        .alignRules({
          top: { anchor: "row1", align: VerticalAlign.Bottom },
          left: { anchor: "row1", align: HorizontalAlign.End },
          right: { anchor: "row2", align: HorizontalAlign.Start }
        })
        .id("row3")

        Row() {
          Text('row4')
        }.justifyContent(FlexAlign.Center)
        .backgroundColor('#2ca9e0')
        .alignRules({
          top: { anchor: "row3", align: VerticalAlign.Bottom },
          bottom: { anchor: "__container__", align: VerticalAlign.Bottom },
          left: { anchor: "__container__", align: HorizontalAlign.Start },
          right: { anchor: "row1", align: HorizontalAlign.End }
        })
        .id("row4")

        Row() {
          Text('row5')
        }.justifyContent(FlexAlign.Center)
        .backgroundColor('#30c9f7')
        .alignRules({
          top: { anchor: "row3", align: VerticalAlign.Bottom },
          bottom: { anchor: "__container__", align: VerticalAlign.Bottom },
          left: { anchor: "row2", align: HorizontalAlign.Start },
          right: { anchor: "__container__", align: HorizontalAlign.End }
        })
        .id("row5")
      }
      .width(300).height(300)
      .margin({ left: 50 })
      .border({ width: 2, color: "#6699FF" })
    }
    .height('100%')
  }
}

示例2(子组件设置外边距)

本示例展示了容器内子组件设置外边距的用法。

@Entry
@Component
struct Index {
  build() {
    Row() {
      RelativeContainer() {
        Row() {
          Text('row1')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#a3cf62')
        .alignRules({
          top: { anchor: "__container__", align: VerticalAlign.Top },
          left: { anchor: "__container__", align: HorizontalAlign.Start }
        })
        .id("row1")
        .margin(10)

        Row() {
          Text('row2')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#00ae9d')
        .alignRules({
          left: { anchor: "row1", align: HorizontalAlign.End },
          top: { anchor: "row1", align: VerticalAlign.Top }
        })
        .id("row2")

        Row() {
          Text('row3')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#0a59f7')
        .alignRules({
          left: { anchor: "row1", align: HorizontalAlign.Start },
          top: { anchor: "row1", align: VerticalAlign.Bottom }
        })
        .id("row3")

        Row() {
          Text('row4')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#2ca9e0')
        .alignRules({
          left: { anchor: "row3", align: HorizontalAlign.End },
          top: { anchor: "row2", align: VerticalAlign.Bottom }
        })
        .id("row4")
        .margin(10)
      }
      .width(300).height(300)
      .margin({ left: 50 })
      .border({ width: 2, color: "#6699FF" })
    }
    .height('100%')
  }
}

示例3(设置容器大小自适应内容)

本示例展示了容器大小适应内容(声明width或height为"auto")的用法。

@Entry
@Component
struct Index {
  build() {
    Row() {
      RelativeContainer() {
        Row() {
          Text('row1')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#a3cf62')
        .id("row1")

        Row() {
          Text('row2')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#00ae9d')
        .alignRules({
          left: { anchor: "row1", align: HorizontalAlign.End },
          top: { anchor: "row1", align: VerticalAlign.Top }
        })
        .id("row2")

        Row() {
          Text('row3')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#0a59f7')
        .alignRules({
          left: { anchor: "row1", align: HorizontalAlign.Start },
          top: { anchor: "row1", align: VerticalAlign.Bottom }
        })
        .id("row3")

        Row() {
          Text('row4')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#2ca9e0')
        .alignRules({
          left: { anchor: "row3", align: HorizontalAlign.End },
          top: { anchor: "row2", align: VerticalAlign.Bottom }
        })
        .id("row4")
      }
      .width("auto").height("auto")
      .margin({ left: 50 })
      .border({ width: 2, color: "#6699FF" })
    }
    .height('100%')
  }
}

示例4(设置偏移)

本示例通过bias实现了子组件的位置在竖直方向的两个锚点间偏移的效果

@Entry
@Component
struct Index {
  build() {
    Row() {
      RelativeContainer() {
        Row()
          .width(100)
          .height(100)
          .backgroundColor('#a3cf62')
          .alignRules({
            top: { anchor: "__container__", align: VerticalAlign.Top },
            bottom: { anchor: "__container__", align: VerticalAlign.Bottom },
            left: { anchor: "__container__", align: HorizontalAlign.Start },
            right: { anchor: "__container__", align: HorizontalAlign.End },
            bias: { vertical: 0.3 }
          })
          .id("row1")
      }
      .width(300).height(300)
      .margin({ left: 50 })
      .border({ width: 2, color: "#6699FF" })
    }
    .height('100%')
  }
}

示例5(设置辅助线)

本示例展示了相对布局组件通过guideLine接口设置辅助线,子组件以辅助线为锚点的功能。

@Entry
@Component
struct Index {
  build() {
    Row() {
      RelativeContainer() {
        Row()
          .width(100)
          .height(100)
          .backgroundColor('#a3cf62')
          .alignRules({
            left: { anchor: "guideline1", align: HorizontalAlign.End },
            top: { anchor: "guideline2", align: VerticalAlign.Top }
          })
          .id("row1")
      }
      .width(300)
      .height(300)
      .margin({ left: 50 })
      .border({ width: 2, color: "#6699FF" })
      .guideLine([{ id: "guideline1", direction: Axis.Vertical, position: { start: 50 } },
        { id: "guideline2", direction: Axis.Horizontal, position: { start: 50 } }])
    }
    .height('100%')
  }
}

示例6(设置屏障)

本示例展示了相对布局组件通过barrier接口设置屏障,子组件以屏障为锚点的用法。

@Entry
@Component
struct Index {
  build() {
    Row() {
      RelativeContainer() {
        Row() {
          Text('row1')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#a3cf62')
        .id("row1")

        Row() {
          Text('row2')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#00ae9d')
        .alignRules({
          middle: { anchor: "row1", align: HorizontalAlign.End },
          top: { anchor: "row1", align: VerticalAlign.Bottom }
        })
        .id("row2")

        Row() {
          Text('row3')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#0a59f7')
        .alignRules({
          left: { anchor: "barrier1", align: HorizontalAlign.End },
          top: { anchor: "row1", align: VerticalAlign.Top }
        })
        .id("row3")

        Row() {
          Text('row4')
        }
        .justifyContent(FlexAlign.Center)
        .width(50)
        .height(50)
        .backgroundColor('#2ca9e0')
        .alignRules({
          left: { anchor: "row1", align: HorizontalAlign.Start },
          top: { anchor: "barrier2", align: VerticalAlign.Bottom }
        })
        .id("row4")
      }
      .width(300)
      .height(300)
      .margin({ left: 50 })
      .border({ width: 2, color: "#6699FF" })
      .barrier([{ id: "barrier1", direction: BarrierDirection.RIGHT, referencedId: ["row1", "row2"] },
        { id: "barrier2", direction: BarrierDirection.BOTTOM, referencedId: ["row1", "row2"] }])
    }
    .height('100%')
  }
}

示例7(设置链)

本示例通过chainMode接口从上至下分别实现了水平方向的SPREAD链,SPREAD_INSIDE链和PACKED链。

@Entry
@Component
struct Index {
  build() {
    Row() {
      RelativeContainer() {
        Row() {
          Text('row1')
        }
        .justifyContent(FlexAlign.Center)
        .width(80)
        .height(80)
        .backgroundColor('#a3cf62')
        .alignRules({
          left: { anchor: "__container__", align: HorizontalAlign.Start },
          right: { anchor: "row2", align: HorizontalAlign.Start },
          top: { anchor: "__container__", align: VerticalAlign.Top }
        })
        .id("row1")
        .chainMode(Axis.Horizontal, ChainStyle.SPREAD)

        Row() {
          Text('row2')
        }
        .justifyContent(FlexAlign.Center)
        .width(80)
        .height(80)
        .backgroundColor('#00ae9d')
        .alignRules({
          left: { anchor: "row1", align: HorizontalAlign.End },
          right: { anchor: "row3", align: HorizontalAlign.Start },
          top: { anchor: "row1", align: VerticalAlign.Top }
        })
        .id("row2")

        Row() {
          Text('row3')
        }
        .justifyContent(FlexAlign.Center)
        .width(80)
        .height(80)
        .backgroundColor('#0a59f7')
        .alignRules({
          left: { anchor: "row2", align: HorizontalAlign.End },
          right: { anchor: "__container__", align: HorizontalAlign.End },
          top: { anchor: "row1", align: VerticalAlign.Top }
        })
        .id("row3")

        Row() {
          Text('row4')
        }
        .justifyContent(FlexAlign.Center)
        .width(80)
        .height(80)
        .backgroundColor('#a3cf62')
        .alignRules({
          left: { anchor: "__container__", align: HorizontalAlign.Start },
          right: { anchor: "row5", align: HorizontalAlign.Start },
          center: { anchor: "__container__", align: VerticalAlign.Center }
        })
        .id("row4")
        .chainMode(Axis.Horizontal, ChainStyle.SPREAD_INSIDE)

        Row() {
          Text('row5')
        }
        .justifyContent(FlexAlign.Center)
        .width(80)
        .height(80)
        .backgroundColor('#00ae9d')
        .alignRules({
          left: { anchor: "row4", align: HorizontalAlign.End },
          right: { anchor: "row6", align: HorizontalAlign.Start },
          top: { anchor: "row4", align: VerticalAlign.Top }
        })
        .id("row5")

        Row() {
          Text('row6')
        }
        .justifyContent(FlexAlign.Center)
        .width(80)
        .height(80)
        .backgroundColor('#0a59f7')
        .alignRules({
          left: { anchor: "row5", align: HorizontalAlign.End },
          right: { anchor: "__container__", align: HorizontalAlign.End },
          top: { anchor: "row4", align: VerticalAlign.Top }
        })
        .id("row6")

        Row() {
          Text('row7')
        }
        .justifyContent(FlexAlign.Center)
        .width(80)
        .height(80)
        .backgroundColor('#a3cf62')
        .alignRules({
          left: { anchor: "__container__", align: HorizontalAlign.Start },
          right: { anchor: "row8", align: HorizontalAlign.Start },
          bottom: { anchor: "__container__", align: VerticalAlign.Bottom }
        })
        .id("row7")
        .chainMode(Axis.Horizontal, ChainStyle.PACKED)

        Row() {
          Text('row8')
        }
        .justifyContent(FlexAlign.Center)
        .width(80)
        .height(80)
        .backgroundColor('#00ae9d')
        .alignRules({
          left: { anchor: "row7", align: HorizontalAlign.End },
          right: { anchor: "row9", align: HorizontalAlign.Start },
          top: { anchor: "row7", align: VerticalAlign.Top }
        })
        .id("row8")

        Row() {
          Text('row9')
        }
        .justifyContent(FlexAlign.Center)
        .width(80)
        .height(80)
        .backgroundColor('#0a59f7')
        .alignRules({
          left: { anchor: "row8", align: HorizontalAlign.End },
          right: { anchor: "__container__", align: HorizontalAlign.End },
          top: { anchor: "row7", align: VerticalAlign.Top }
        })
        .id("row9")
      }
      .width(300).height(300)
      .margin({ left: 50 })
      .border({ width: 2, color: "#6699FF" })
    }
    .height('100%')
  }
}

示例8(链中设置偏移)

本示例通过chainMode和bias接口实现了水平方向的带偏移的PACKED链。

@Entry
@Component
struct Index {
  build() {
    Row() {
      RelativeContainer() {
        Row() {
          Text('row1')
        }
        .justifyContent(FlexAlign.Center)
        .width(80)
        .height(80)
        .backgroundColor('#a3cf62')
        .alignRules({
          left: { anchor: "__container__", align: HorizontalAlign.Start },
          right: { anchor: "row2", align: HorizontalAlign.Start },
          center: { anchor: "__container__", align: VerticalAlign.Center },
          bias: { horizontal: 0 }
        })
        .id("row1")
        .chainMode(Axis.Horizontal, ChainStyle.PACKED)

        Row() {
          Text('row2')
        }
        .justifyContent(FlexAlign.Center)
        .width(80)
        .height(80)
        .backgroundColor('#00ae9d')
        .alignRules({
          left: { anchor: "row1", align: HorizontalAlign.End },
          right: { anchor: "row3", align: HorizontalAlign.Start },
          top: { anchor: "row1", align: VerticalAlign.Top }
        })
        .id("row2")

        Row() {
          Text('row3')
        }
        .justifyContent(FlexAlign.Center)
        .width(80)
        .height(80)
        .backgroundColor('#0a59f7')
        .alignRules({
          left: { anchor: "row2", align: HorizontalAlign.End },
          right: { anchor: "__container__", align: HorizontalAlign.End },
          top: { anchor: "row1", align: VerticalAlign.Top }
        })
        .id("row3")
      }
      .width(300).height(300)
      .margin({ left: 50 })
      .border({ width: 2, color: "#6699FF" })
    }
    .height('100%')
  }
}

示例9(设置镜像模式)

本示例展示了在镜像模式(direction声明Direction.Rtl)下以屏障为锚点时使用LocalizedAlignRuleOptions和LocalizedBarrierDirection设置对齐方式的用法。

@Entry
@Component
struct Index {
  build() {
    Row() {
      RelativeContainer() {
        Row() {
          Text('row1')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#a3cf62')
        .id("row1")

        Row() {
          Text('row2')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#00ae9d')
        .alignRules({
          middle: { anchor: "row1", align: HorizontalAlign.End },
          top: { anchor: "row1", align: VerticalAlign.Bottom }
        })
        .id("row2")

        Row() {
          Text('row3')
        }
        .justifyContent(FlexAlign.Center)
        .width(100)
        .height(100)
        .backgroundColor('#0a59f7')
        .alignRules({
          start: { anchor: "barrier1", align: HorizontalAlign.End },
          top: { anchor: "row1", align: VerticalAlign.Top }
        })
        .id("row3")

        Row() {
          Text('row4')
        }
        .justifyContent(FlexAlign.Center)
        .width(50)
        .height(50)
        .backgroundColor('#2ca9e0')
        .alignRules({
          start: { anchor: "row1", align: HorizontalAlign.Start },
          top: { anchor: "barrier2", align: VerticalAlign.Bottom }
        })
        .id("row4")
      }
      .direction(Direction.Rtl)
      .width(300)
      .height(300)
      .margin({ left: 50 })
      .border({ width: 2, color: "#6699FF" })
      .barrier([{ id: "barrier1", localizedDirection: LocalizedBarrierDirection.END, referencedId: ["row1", "row2"] },
        { id: "barrier2", localizedDirection: LocalizedBarrierDirection.BOTTOM, referencedId: ["row1", "row2"] }])
    }
    .height('100%')
  }
}

鸿蒙ArkTS容器组件:【RelativeContainer】 相对布局组件,用于复杂场景中元素对齐的布局。点击或者复制转到。该组件从API Version 9开始支持。后续版本如有新增内容,则采用上角标单独标记该内容的起始版本。 阅读详情

相关推荐

鸿蒙Harmony应用开发—ArkTS声明式开发(容器组件:RelativeContainer)

ArkTS声明式开发(容器组件:RelativeContainer)

m0_64420071的博客 2574

【愚公系列】2023年12月 HarmonyOS教学课程 008-ArkUI组件(RelativeContainer)

ArkUI组件中的RelativeContainer是一个相对定位的容器,可以用来将子组件按照相对位置布局。在RelativeContainer中,每个子组件都可以设置相对于父容器或其他组件的位置和大小。可以通过设置相对位置、偏移量、宽度和高度来实现布局。相对位置可以设置为左侧、上方、右侧和下方。偏移量可以设置为相对位置的偏移值,例如向右偏移10像素或向下偏移5像素。宽度和高度可以设置为相对值或绝对值。使用RelativeContainer时,要注意避免组件重叠或越出容器边界的情况。

愚公智库 6万+

鸿蒙开发5.0【UI开发技巧】

让TextInput再次获取焦点,并弹出键盘,可调用下面方法,参数为TextInput的id/key

2401_82772199的博客 1278

鸿蒙Harmony-相对布局(RelativeContainer)详解

成年人的世界,从来没有容易二字,想要什么,就得凭自己的努力去拿,遇到事情就得自己生生的硬抗,希望你即使再辛苦,但还是会选择这滚烫的人生,加油陌生的朋友们

袁震的博客 4960

鸿蒙5.0开发进阶:页面加载效果实现案例

本示例介绍Stack堆叠组件和LoadingProgress加载组件模拟首次进入页面实现页面加载的效果。

HSMMQAQ的博客 1075

鸿蒙开发实战:从ArkTS到分布式应用全解析

分布式操作系统作为现代计算的重要演进方向,通过设备虚拟化技术实现跨终端的无缝协同。鸿蒙HarmonyOS作为典型代表,其ArkTS语言和ArkUI框架构建了声明式开发范式,相比传统移动开发具有更高的代码复用率和场景适应性。在工程实践中,开发者需要掌握类型系统增强、多层级状态管理等核心技术,特别是在物联网和智能家居等分布式场景下,设备发现、数据同步等能力直接影响用户体验。通过本文的ArkUI布局系统详解和性能优化方案,开发者可以快速构建高性能鸿蒙应用,应对日益复杂的全场景开需求。

wangqiaowqo的专栏 446

HarmonyOS6 ArkTS RelativeContainer 相对布局容器使用文档

是 HarmonyOS ArkTS 中灵活的相对定位布局容器,核心特性是让子组件通过锚点 ID建立依赖关系,实现基于其他组件/容器的位置定位,打破了 Column/Row 线性布局、Stack 堆叠布局的限制。布局特点:基于锚点的相对定位,无固定排列方向核心能力:组件间相互锚点、容器锚点、多方向对齐、间距微调核心优势:无需多层嵌套即可实现复杂布局,层级清晰、适配性强适用场景:卡片角标、自定义仪表盘、非规则排版、灵活的组件组合布局、需基于其他组件定位的UI场景。

qq_37048082的博客 5565

鸿蒙应用开发学习-初识ArkUI

方舟开发框架(简称:ArkUI)

初一十五的博客 1976

【鸿蒙HarmonyOS|第2期】鸿蒙开发初体验:解读 “Hello World” 代码

在当今多设备互联的时代,鸿蒙操作系统(HarmonyOS)以其跨平台、轻量级的特性受到了广大开发者的关注。本文将带您深入探讨鸿蒙 HarmonyOS Next 中的 ArkTS(Ark TypeScript)组件开发,通过上期所述的 Hello World 示例,让您快速掌握鸿蒙应用的基本开发技巧。

Commas的博客 1295

别再只调陀螺仪了!用OpenCV实现基于透视变换的EIS防抖,实测效果媲美手机

本文深入探讨了基于透视变换的EIS电子稳像技术,通过OpenCV实现高阶防抖算法,效果媲美主流手机厂商方案。详细解析了传统旋转平移模型的局限性,并展示了透视变换在复杂场景下的优势,包括数学原理、OpenCV实战代码及性能优化技巧,为视频防抖提供了专业解决方案。

weixin_42613501的博客 454

从交换机安全配置,看常见局域网攻击

前言 构建零信任网络,自然离不开网络准入(NAC),这就涉及到交换机的一些安全测试,于是有了此文《从交换机安全配置看常见局域网攻击》。 交换机安全配置 如本文标题所说从交换机安全配置看常见的局域网攻击,那么下面提到的各种攻击方式,自然是建立在交换机安全配置之上来说的。我们通过h3c官方提供的《H3C 交换机安全加固手册》和《安全配置指导》,从这两份手册可以看出交换机支持的安全配置非常多,基本已经覆盖了各种我们熟知局域网攻击。下面就挑几个典型的攻击方式进行演示。 arp欺骗 【一>所有资源获取&lt

kali_Ma的博客 1万+

鸿蒙 ArkTS 布局之 RelativeContainer 实战:自适应表单

摘要(138字): 本文介绍鸿蒙ArkTS中RelativeContainer布局实现自适应表单的实战方案。通过个人信息登记表示例,展示如何利用相对布局的锚点约束特性替代传统嵌套方案,解决多行表单的精确控制问题。文章详细解析alignRules机制,包括左右上下边缘的对齐规则及语义化写法,并提供了完整代码实现,涵盖标题、分隔线、输入项等元素的定位与样式控制。该方案支持不同屏幕尺寸下的稳定表现,实现标签左对齐、输入框自适应拉伸等表单常见需求,代码简洁且维护性强。

zjxcq520的博客 446

【汽车主动降噪】【ANC算法优化】基于深度学习的汽车主动噪声控制技术研究及Matlab实现

本文探讨了基于深度学习的汽车主动降噪(ANC)算法优化方案。针对传统FXLMS算法在应对复杂、非线性车内噪声时的局限性,文章详细解析了如何利用神经网络作为非线性建模器、深度滤波器或智能步长调节器来增强ANC系统性能,并提供了完整的Matlab仿真实战流程,展示了深度学习在提升降噪效果和收敛速度方面的潜力。

seed的博客 541

七、ArkTS 声明式UI-常用布局-相对布局 (RelativeContainer)

在应用的开发过程中,经常需要设计复杂界面,此时涉及到多个相同或不同组件之间的嵌套。如果布局组件嵌套深度过深,或者嵌套组件数过多,会带来额外的开销。如果在布局的方式上进行优化,就可以有效的提升性能,减少时间开销。RelativeContainer为采用相对布局的容器,支持容器内部的子元素设置相对位置关系,适用于界面复杂场景的情况,对多个子组件进行对齐和排列。子元素支持指定兄弟元素作为锚点,也支持指定父容器作为锚点,基于锚点做相对位置布局。

Harry的博客 1084

Dify 1.0+内网部署全攻略:模型插件离线安装与信创环境适配

本文详细介绍了Dify 1.0+版本在内网环境中的部署全攻略,重点解析了模型工具插件的离线安装方法与信创环境适配技巧。通过实战经验分享,帮助企业在严格的内网隔离条件下高效部署AI平台,解决插件依赖和安装难题,提升大语言模型的应用效率。

weixin_29224529的博客 277

车载诊断架构 --- 车载ECU开发中DTC数量与芯片存储能力的关系及应对策略

本文探讨了汽车电子系统中ECU存储DTC故障码的容量问题及解决方案。作者作为汽车电子工程师,针对台架测试中遇到的DTC存储超限案例展开分析,指出随着汽车智能化发展,ECU需处理的DTC数量激增与芯片存储能力有限的矛盾。文章详细介绍了DTC的存储需求、ECU支持数量与芯片容量的关系,并提出应对策略,通过实际案例验证了方案的可行性。最后强调在ECU开发中需合理分配存储资源,确保关键故障信息不丢失。

Soly_kun的博客 90

鸿蒙原生 ArkTS 布局精讲:RelativeContainer 实现居中加载动画

本文详细介绍了在鸿蒙原生应用开发中,如何使用ArkTS语言和ArkUI框架,通过RelativeContainer相对布局容器结合LoadingProgress组件,实现优雅的全屏居中加载动画效果。文章包含环境准备(DevEco Studio 5.0+,API 24)、核心技术解析(RelativeContainer的alignRules规则、__container__特殊锚点、LoadingProgress特性)、布局设计思路,并提供了完整实现代码。该方案利用相对定位实现组件精准居中,配合动态进度提示和渐

m0_67000457的博客 326

数字电路逻辑与设计实验一 门电路逻辑功能及测试

(1)选二输入四异或门电路 74LS86,按图 1-8 接线,输入端 1、2、4、5 接逻辑开 关(S1~S4),输出端 A、B、Y 接电平显示发光二极管.用六反相器(非门)按图 1-11 接线,输入 80KHz 连续脉冲,用双踪示波器测输入, 输出相位差,计算每个门的平均传输延迟时间的 tpd 值。测试不同的输入组合:对门电路进行全面的测试,尝试不同的输入组合,包括各种可能的逻辑状态。检查门电路的输入:确认门电路的输入是否正确,并且输入信号的电平符合门电路的规格要求。确保输入信号的稳定性和准确性。

欢迎交流学习心得 2万+

鸿蒙 ArkTS 七大布局组件详解

简单上下排列 → Column简单左右一行 → Row叠加浮层 / 角标 → Stack流式自动换行 / 均分 → Flex组件互相参照定位 → RelativeContainer图片滑动轮播 → Swiper顶部底部切换页面 → Tabs。

2401_87235428的博客 768

微信小程序 - request:fail errcode:10011 cronet_error_code:0 error_msg:network change, cancel all task请求报错

微信小程序请求接口,报request:fail errcode:10011是什么原因,uniapp微信小程序request:fail errcode:10011 cronet_error_code:0 error_msg:network change, cancel all task,微信小程序wx.request常规访问接口,有个别用户的接口请求频繁报错,UniApp 微信小程序uni.request请求接口报错:request:fail errcode:10011 的原因分析与解决方案,苹果ios,安卓

🏆 前端领域优质创作者 4569

在Simulink中进行基于强化学习控制策略的三相逆变器仿真

本文详细介绍了在Simulink中实现基于强化学习控制策略的三相逆变器仿真的完整流程。主要内容包括:1)准备工作,确保MATLAB/Simulink及相关工具箱安装;2)构建三相逆变器基础模型,包含电源、全桥电路、LC滤波器和负载;3)重点阐述强化学习控制器设计,涉及状态空间、动作空间定义,奖励函数设计和算法选择;4)实现控制逻辑,包括环境创建、代理配置和训练过程;5)仿真设置与结果分析。文章强调了模型调试优化的重要性,并建议结合文献研究提升控制效果。该方案为开发自适应电力电子控制系统提供了实用指南。

amy_mhd的博客 272

从需求到页面:RelativeContainer 相对布局的 ArkTS 原生实现

技术路线:HarmonyOS 原生 ArkTS / ArkUI。

2401_83963227的博客 227

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

鸿蒙原生 ArkTS 布局深度解析:RelativeContainer 与 AbsoluteContainer 实战对比

本文对比分析了鸿蒙原生ArkTS中两种核心布局方式:RelativeContainer(相对布局)和Stack+position()(绝对布局)。RelativeContainer通过锚点链式定位实现组件间的相对关系,具备天然自适应能力,适合卡片布局、响应式页面等场景。绝对布局则通过精确坐标控制元素位置,支持zIndex层叠,适用于商品徽标、仪表盘等需要精确控制的界面。文章通过多个实战场景演示了两者的API使用和差异,并提供了详细的选型指南,帮助开发者根据具体需求选择最佳布局方案。

zjxcq520的博客 382

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

鸿蒙HarmonyOS 5.0开发实战:页面加载效果实现案例

本示例介绍Stack堆叠组件和LoadingProgress加载组件模拟首次进入页面实现页面加载的效果。

m0_73088370的博客 428

ArkTS(UI)组件布局

布局是鸿蒙ArkUI界面开发的基础。不同布局组件有着不同的排列规则,能实现各式各样的页面效果。

k199909210625的博客 302

鸿蒙原生ArkTS布局方式之RelativeContainer水平居中相对布局

本文介绍了鸿蒙原生ArkTS中的RelativeContainer相对布局容器,重点讲解如何实现子组件水平居中。RelativeContainer通过alignRules规则实现组件相对于父容器或兄弟组件的精确定位,其中middle属性用于水平居中,center属性用于垂直居中。文章详细解析了核心API(alignRules、HorizontalAlign、VerticalAlign)和使用方法,并通过代码示例演示了实现过程,同时指出常见误区。这种布局方式特别适合需要精确控制组件位置或实现重叠效果的场景,相

2501_91738721的博客 424
上一篇: 鸿蒙5.0开发进阶:UI框架-ArkTS组件(Stack)
下一篇: 鸿蒙5.0开发进阶:UI框架-ArkTS组件(FolderStack)
懂你的大海
博客等级 码龄6年 9049粉丝 1381原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值