JavaSwing基础之Layout布局相关知识详解

一、View layout方法

首先,还是从ViewRootImpl说起,界面的绘制会触发performMeasure、performLayout方法,而在performLayout方法中就会调用mView的layout方法开始一层层View的布局工作。

private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
            int desiredWindowHeight) {

        final View host = mView;
        host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
    }

mView我们都知道了,就是顶层View——DecorView,那么就进去看看DecorView的layout方法:

不好意思,DecorView中并没有layout方法...

所以,我们直接看看View的layout方法:

public void layout(int l, int t, int r, int b) {

        boolean changed = isLayoutModeOptical(mParent) ?
                setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);

        if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
            onLayout(changed, l, t, r, b);
        }
    }

    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    }
  • 首先,方法传入了四个参数,分别代表view的左、上、下、右四个值。
  • 然后通过setOpticalFrame方法或者setFrame方法判断布局参数是否改变。

具体判断过程就是通过老的上下左右值和新的上下左右值进行比较,逻辑就在setFrame方法中:

protected boolean setFrame(int left, int top, int right, int bottom) {
        boolean changed = false;

        if (mLeft != left || mRight != right || mTop != top || mBottom != bottom) {
            changed = true;

            // Remember our drawn bit
            int drawn = mPrivateFlags & PFLAG_DRAWN;

            int oldWidth = mRight - mLeft;
            int oldHeight = mBottom - mTop;
            int newWidth = right - left;
            int newHeight = bottom - top;
            boolean sizeChanged = (newWidth != oldWidth) || (newHeight != oldHeight);

            // Invalidate our old position
            invalidate(sizeChanged);

            mLeft = left;
            mTop = top;
            mRight = right;
            mBottom = bottom;
            mRenderNode.setLeftTopRightBottom(mLeft, mTop, mRight, mBottom);
        }
        return changed;
    }

如果上下左右有一个参数值发生了改变,就说明这个View的布局发生了改变,然后重新计算View的宽度高度(newWidth、newHeight),并赋值了View新的上下左右参数值。

在这个layout方法中主要涉及到了四个参数:mLeft、mTop、mBottom、mRight,分别代表了View的左坐标、上坐标、下坐标和右坐标,你可以把View理解为一个矩形,确定了这四个值,就能确定View矩形的四个顶点值,也就能确定View在画布中的具体位置。

所以,layout方法到底干了啥?

就是传入上下左右值、然后赋值上下左右值、完毕。

然后我们就可以根据这些值获取View的一系列参数,比如View宽度:

public final int getWidth() {
        return mRight - mLeft;
    }

至此,View的layout方法就结束了,主要就是通过对上下左右参数的赋值完成对View的布局,非常简单。

下面看看ViewGroup

二、ViewGroup layout方法

@Override
    public final void layout(int l, int t, int r, int b) {
        if (!mSuppressLayout && (mTransition == null || !mTransition.isChangingLayout())) {
            if (mTransition != null) {
                mTransition.layoutChange(this);
            }
            super.layout(l, t, r, b);
        } else {
            mLayoutCalledWhileSuppressed = true;
        }
    }

额,还是调用到View的layout方法,难道说ViewGroupView的布局过程是一样的,就是确定了本身的位置?

ViewGroup的子View怎么办呢?不急,我们刚才说layout方法的时候还漏了一个onLayout方法,只不过这个方法在View里面是空实现,而到了ViewGroup中变成了一个抽象方法:

@Override
    protected abstract void onLayout(boolean changed,
            int l, int t, int r, int b);

也就是任何ViewGroup都必须实现这个方法,来完成对子View的布局摆放。

具体的布局摆放逻辑就是在onLayout方法中一个个调用子View的layout方法,然后完成每个子View的布局,最终完成绘制工作。

接下来我们就来自己实现一个垂直线性布局(类似LinearLayout),正好复习下上一节的onMearsure和这一节的onLayout

三、自定义垂直布局VerticalLayout

首先,我们要确定我们这个自定义ViewGroup的作用,是类似垂直方向的LinearLayout功能,在该ViewGroup下的子View可以按垂直线性顺序依次往下排放。我们给它起个名字叫VerticalLayout

继承ViewGroup

首先,我们这个布局肯定要继承自ViewGroup,并且实现相应的构造方法:

public class VerticalLayout : ViewGroup {

    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int = 0) : super(
        context,
        attrs,
        defStyleAttr
    )

    constructor(context: Context, attrs: AttributeSet?) : super(context, attrs) {
    }
}

重写generateLayoutParams方法

自定义ViewGroup还需要重写的一个方法是generateLayoutParams,这一步是为了让我们的ViewGroup支持Margin,后续我们就可以通过MarginLayoutParams来获取子View的Margin值。

override fun generateLayoutParams(attrs: AttributeSet?): LayoutParams? {
        return MarginLayoutParams(context, attrs)
    }

重写测量方法onMeasure

然后,我们需要对我们的布局进行测量,也就是重写onMeasure方法。

在该方法中,我们需要对我们的布局进行测量,并且将测量好的宽高传入setMeasuredDimension方法,完成测量。

protected final void setMeasuredDimension(int measuredWidth, int measuredHeight)

之前我们说过,onMeasure方法会传进来两个参数,widthMeasureSpecheightMeasureSpec

里面包含了父View根据当前View的LayoutParams和父View的测量规格进行计算,得出的对当前View期望的测量模式和测量大小

  • 当测量模式为MeasureSpec.EXACTLY

也就是当宽或者高为确定值时,那么当前布局View的宽高也就是设定为父View给我们设置好的测量大小即可。比如宽为400dp,那么我们无需重新测量直接调用setMeasuredDimension传入这个固定值即可。

  • 当测量模式为MeasureSpec.AT_MOST 或者 UNSPECIFIED:

这时候,说明父View对当前View的要求不固定,是可以为任意大小或者不超过最大值的情况,比如设置这个VerticalLayout的高度为wrap_content。那么我们就必须重新进行高度测量了,因为只有我们设计者知道这个自适应高度需要怎么计算。具体就是VerticalLayout是一个垂直线性布局,所以高度很自然就是所有子View的高度之和。

至此,onMeasure方法的逻辑也基本摸清了:

override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec)
        //获取宽高的测量模式和测量大小
        val widthMode = MeasureSpec.getMode(widthMeasureSpec)
        val heightMode = MeasureSpec.getMode(heightMeasureSpec)
        val sizeWidth = MeasureSpec.getSize(widthMeasureSpec)
        val sizeHeight = MeasureSpec.getSize(heightMeasureSpec)

        var mHeight = 0
        var mWidth = 0

        //遍历子View,获取总高度
        for (i in 0 until childCount) {
            val childView = getChildAt(i)
            //测量子View的宽和高
            measureChild(childView, widthMeasureSpec, heightMeasureSpec)
            val lp = childView.layoutParams as MarginLayoutParams
            val childWidth = childView.measuredWidth + lp.leftMargin + lp.rightMargin
            val childHeight = childView.measuredHeight + lp.topMargin + lp.bottomMargin

            //计算得出最大宽度
            mWidth = Math.max(mWidth, childWidth)
            //累计计算高度
            mHeight += childHeight
        }

        //设置宽高
        setMeasuredDimension(
            if (widthMode == MeasureSpec.EXACTLY) sizeWidth else mWidth,
            if (heightMode == MeasureSpec.EXACTLY) sizeHeight else mHeight
        )
    }

主要的逻辑就是遍历子View,得出VerticalLayout的实际宽高:

  • 最终ViewGroup的高 = 所有子View的 (高 + margin值)
  • 最终ViewGroup的宽 = 最大子View的 (宽 + margin值)

最后调用setMeasuredDimension 根据测量模式 传入宽高。

重写布局方法onLayout

上文说过,作为一个ViewGroup,必须重写onLayout方法,来保证子View的正常布局摆放。

垂直线性布局VerticalLayout亦是如此,那么在这个布局中onLayout方法的关键逻辑又是什么呢?

还是那句话,确定位置,也就是确定左、上、右、下四个参数值,而在VerticalLayout中,最关键的参数就是这个上,也就是top值

每个View的top值必须是上一个View的bottom值,也就是接着上一个View进行摆放,这样才会是垂直线性的效果,所以我们需要做的就是动态计算每个View的top值,其实也就是不断累加View的高度,作为下一个View的top值。

override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
        var childWidth = 0
        var childHeight = 0
        var childTop = 0
        var lp: MarginLayoutParams

        //遍历子View,布局每个子View
        for (i in 0 until childCount) {
            val childView = getChildAt(i)
            childHeight = childView.measuredHeight
            childWidth = childView.measuredWidth
            lp = childView.layoutParams as MarginLayoutParams

            //累计计算top值
            childTop += lp.topMargin

            //布局子View
            childView.layout(
                lp.leftMargin,
                childTop,
                lp.leftMargin + childWidth,
                childTop + childHeight
            );

            childTop += childHeight + lp.bottomMargin
        }
    }

逻辑还是挺简单的,

  • left是固定的子View的leftMargin。
  • top是累加计算的子View的高度 + Margin值。
  • right是left + 子View的宽度。
  • bottom是top + 子View的高度。

最后调用子View的layout方法,对每个子View进行布局。

大功告成,最后看看我们这个自定义垂直线性布局的效果吧~

四、效果展示

<com.panda.studynote3.VerticalLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content">

        <TextView
            android:layout_width="100dp"
            android:layout_height="100dp"
            android:text="啦啦啦"
            android:textSize="20sp"
            android:textColor="@color/white"
            android:background="@color/design_default_color_primary"
            />

        <TextView
            android:layout_width="300dp"
            android:layout_height="200dp"
            android:layout_marginTop="20dp"
            android:background="@color/cardview_dark_background"
            android:textSize="20sp"
            android:textColor="@color/white"
            android:text="你好啊"
            />

        <TextView
            android:layout_width="140dp"
            android:layout_height="100dp"
            android:text="嘻嘻"
            android:layout_marginLeft="10dp"
            android:layout_marginTop="10dp"
            android:textSize="20sp"
            android:gravity="center"
            android:textColor="@color/black"
            android:background="@color/teal_200"
            />

    </com.panda.studynote3.VerticalLayout>

到此这篇关于Java基础之Layout布局相关知识详解的文章就介绍到这了,更多相关Java Layout布局内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • java Swing布局管理之BoxLayout布局

    本文为大家解析java Swing布局管理中的BoxLayout布局,供大家参考,具体内容如下 BoxLayout:可以指定在容器中是否对控件进行水平或者垂直放置,比 FlowLayout 要更为灵活 BoxLayout与其他布局管理器稍有不同,必须向其构造函数中传递容器实例的引用,由该容器使用BoxLayout.另外必须指定BoxLayout中组件的布局方式:垂直排列(按列)或水平排列(按行).用水平组件和垂直组件的不同组合嵌套多面板的作用类似于 GridBagLayout,但没那么复杂. 1

  • java布局管理之CardLayout简单实例

    本文实例为大家分享了java布局管理之CardLayout的具体代码,供大家参考,具体内容如下 import java.awt.BorderLayout; import java.awt.CardLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JFrame; import javax.swi

  • Java Swing GridBagLayout网格袋布局的实现

    1. 布局: GridBagLayout 官方JavaDocsApi: java.awt.GridBagLayout GridBagLayout,网格袋布局管理器.它不要求组件的大小相同便可以将组件垂直.水平或沿它们的基线对齐.每个 GridBagLayout 对象维持一个动态的矩形单元格(动态计算出单个单元格的大小),每个组件占用一个或多个的单元格,该单元格被称为 显示区域.每个组件显示区域按 从左到右,从上到下,依次排列. 2. 约束: GridBagConstraints GridBagC

  • Java Swing组件BoxLayout布局用法示例

    本文实例讲述了Java Swing组件BoxLayout布局用法.分享给大家供大家参考,具体如下: BoxLayout 可以把控件依次进行水平或者垂直排列布局,这是通过参数 X_AXIS.Y_AXIS 来决定的.X_AXIS 表示水平排列,而 Y_AXIS 表示垂直排列.BoxLayout 的构造函数有两个参数,一个参数定义使用该 BoxLayout 的容器,另一个参数是指定 BoxLayout 是采用水平还是垂直排列.下面是一个使用 BoxLayout排列控件的例子: JPanel panel

  • Java Swing GroupLayout分组布局的实现代码

    1. 概述 官方JavaDocsApi: javax.swing.GroupLayout GroupLayout,分组布局管理器.它将组建按层次分组,以决定它们在 Container 中的位置.GroupLayout 主要供生成器使用(生成 并行组 和 串行组).分组由GroupLayout.Group类的实例来完成,每个组可以包含任意数量的元素(Group.Component 或 Gap). GroupLayout支持两种组: 串行组 (sequential group):按顺序沿指定方向(水

  • Java Swing CardLayout卡片布局的实现示例

    1. 概述 官方JavaDocsApi: javax.swing.CardLayout CardLayout,卡片布局管理器.它将容器中的每个组件看作一张卡片,一次只能看到一张卡片,容器则充当卡片的堆栈,默认显示第一张卡片. CardLayout 构造方法: // 创建一个间距大小为 0 的卡片布局 CardLayout() // 创建一个指定水平/垂直间距大小的卡片布局. CardLayout(int hgap, int vgap) CardLayout 常用方法: // 显示第一张卡片 vo

  • java GUI编程之布局控制器(Layout)实例分析

    本文实例讲述了java GUI编程之布局控制器(Layout).分享给大家供大家参考,具体如下: 布局控制器,是用来系统自动分配各个component在window内部是怎么排布的:默认为FlowLayout,即挨个排序.FlowLayout是Panel的 instance 1:FlowLayout import java.awt.*; public class TestLayout { public static void main(String[] args) { Frame f = new

  • JavaSwing GridLayout 网格布局的实现代码

    1. 概述 官方JavaDocsApi: java.awt.GridLayout GridLayout,网格布局管理器.它以矩形网格形式对容器的组件进行布置,把容器按行列分成大小相等的矩形网格,一个网格中放置一个组件,组件宽高自动撑满网格. 以行数和总数优先: 通过构造方法或 setRows 和 setColumns 方法将行数和列数都设置为非零值时,指定的列数将被忽略.列数通过指定的行数和布局中的组件总数来确定.因此,例如,如果指定了三行和两列,在布局中添加了九个组件,则它们将显示为三行三列.

  • Java Swing SpringLayout弹性布局的实现代码

    1. 概述 官方JavaDocsApi: javax.swing.SpringLayout javax.swing.SpringLayout.Constraints javax.swing.Spring SpringLayout,弹性布局管理器.使用该布局的容器内的 每一个组件或容器都对应着一个约束,通过该约束定义组件或容器四条边的坐标位置 来实现对组件的布局.该布局主要涉及三个类: SpringLayout.SpringLayout.Constraints.Spring,分别表示 布局管理器.

  • Java Swing BoxLayout箱式布局的实现代码

    1. 概述 官方JavaDocsApi: javax.swing.BoxLayout,javax.swing.Box BoxLayout,箱式布局管理器.它把若干组件按水平或垂直方向依次排列放置.Swing 提供了一个实现了 BoxLayout 的容器组件Box.使用 Box 提供的静态方法,可快速创建水平/垂直箱容器(Box),以及填充组件之间空隙的不可见组件.用水平箱和垂直箱的组合嵌套可实现类似于 GridBagLayout 的效果,但没那么复杂. 创建水平/垂直箱容器(Box): // 创

  • Java 最重要布局管理器GridBagLayout的使用方法

    GridBagLayout是java里面最重要的布局管理器之一,可以做出很复杂的布局,可以说GridBagLayout是必须要学好的的, GridBagLayout 类是一个灵活的布局管理器,它不要求组件的大小相同便可以将组件垂直.水平或沿它们的基线对齐. 每个 GridBagLayout 对象维持一个动态的矩形单元网格,每个组件占用一个或多个这样的单元,该单元被称为显示区域. 下面就通过一个记事本案例去说明GridBagLayout的使用方法. 分析: 带有箭头的说明可以拉伸的. 4占用4个格

  • Java Swing组件布局管理器之FlowLayout(流式布局)入门教程

    本文实例讲述了Java Swing组件布局管理器之FlowLayout(流式布局).分享给大家供大家参考,具体如下: FlowLayout应该是Swing布局管理器学习中最简单.最基础的一个.所谓流式,就是内部控件像水流一样,从前到后按顺序水平排列,直到达到容器的宽度时跳转到第二行.既然是水平排列,那么就存在三种基本的对齐方式:居中对齐(CENTER ).左对齐(LEFT )和右对齐(RIGHT ).然而,FlowLayout还提供两种对齐方式:LEADING,表示控件与容器方向开始边对应:TR

  • JavaSwing FlowLayout 流式布局的实现

    1. 概述 官方JavaDocsApi: java.awt.FlowLayout FlowLayout,流式布局管理器.按水平方向依次排列放置组件,排满一行,换下一行继续排列.排列方向(左到右 或 右到左)取决于容器的componentOrientation属性(该属性属于Component),它可能的值如下: ComponentOrientation.LEFT_TO_RIGHT(默认) ComponentOrientation.RIGHT_TO_LEFT 同一行(水平方向)的组件的对齐方式由

  • JavaSwing BorderLayout 边界布局的实现代码

    1. 概述 官方JavaDocsApi: java.awt.BorderLayout BorderLayout,边界布局管理器.它把 Container 按方位分为 5 个区域(东.西.南.北.中),每个区域放置一个组件. BorderLayout 构造方法: // 构造一个组件之间没有间距的新边框布局 BorderLayout() // 构造一个具有指定组件间距的边框布局 BorderLayout(int hgap, int vgap) BorderLayout 表示方位的 5 个常量: Bo

随机推荐