Shulou(Shulou.com)06/01 Report--

Today, the editor will share with you the relevant knowledge points about the Layout layout of the Java Swing class, which are detailed in content and clear in logic. I believe most people still know too much about this knowledge, so share this article for your reference. I hope you can get something after reading this article.

1. View layout method

First of all, starting with ViewRootImpl, the drawing of the interface triggers the performMeasure and performLayout methods, and in the performLayout method, the layout method of mView is called to start layer by layer View layout.

Private void performLayout (WindowManager.LayoutParams lp, int desiredWindowWidth, int desiredWindowHeight) {final View host = mView; host.layout (0,0, host.getMeasuredWidth (), host.getMeasuredHeight ());}

We all know that mView is the top-level View--DecorView, so let's go in and take a look at the layout method of DecorView:

Sorry, there is no layout method in DecorView.

So, let's look directly at View's layout method:

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) {}

First, the method passes in four parameters that represent the left, top, bottom, and right values of view.

Then use setOpticalFrame method or setFrame method to determine whether the layout parameters have changed.

The specific judgment process is to compare the old upper and lower left and right values with the new upper and lower left and right values. The logic is in the setFrame method:

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 }

If a parameter value changes up and down, the layout of the View has changed, and then recalculate the width and height of the View (newWidth, newHeight), and assign the new upper and lower left and right parameter values of View.

In this layout method mainly involves four parameters: mLeft, mTop, mBottom, mRight, respectively represents the left coordinates of View, upper coordinates, lower coordinates and right coordinates, you can understand View as a rectangle, determine these four values, you can determine the four vertex values of the View rectangle, that is, you can determine the specific location of View in the canvas.

So, what exactly did the layout method do?

Is to pass in the upper and lower left and right values, and then assign the upper and lower left and right values, over.

Then we can get a series of parameters of View based on these values, such as View width:

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

At this point, the layout method of View is over, mainly through the assignment of the upper and lower left and right parameters to complete the layout of the View, which is very simple.

Let's take a look at ViewGroup.

2. ViewGroup layout method @ 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 }}

Er, or call the layout method of View, can it be said that the layout process of ViewGroup and View is the same, that is, to determine its own location?

What about ViewGroup's son View? Don't worry, we missed an onLayout method when we talked about the layout method, but this method is an empty implementation in View and becomes an abstract method in ViewGroup:

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

That is, any ViewGroup must implement this method to complete the layout of the child View.

The specific layout logic is to call the layout method of sub-View one by one in the onLayout method, and then complete the layout of each sub-View, and finally complete the drawing work.

Next we'll implement a vertical linear layout ourselves (similar to LinearLayout), just in time to review the onMearsure in the previous section and the onLayout in this section.

3. Custom vertical layout VerticalLayout

First of all, we need to make sure that the role of our custom ViewGroup is similar to the vertical LinearLayout function, under which the sub-View can be discharged in vertical linear order. Let's name it VerticalLayout~.

Inherit ViewGroup

First of all, our layout must inherit from ViewGroup and implement the corresponding constructor:

Public class VerticalLayout: ViewGroup {constructor (context: Context, attrs: AttributeSet?, defStyleAttr: Int = 0): super (context, attrs, defStyleAttr) constructor (context: Context, attrs: AttributeSet?): super (context, attrs)

Override the generateLayoutParams method

Another method that needs to be overridden for custom ViewGroup is generateLayoutParams. This step is to make our ViewGroup support Margin. Later, we can obtain the Margin value of the child View through MarginLayoutParams.

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

Rewrite measurement method onMeasure

Then we need to measure our layout, that is, override the onMeasure method.

In this method, we need to measure our layout, and pass the measured width and height into the setMeasuredDimension method to complete the measurement.

Protected final void setMeasuredDimension (int measuredWidth, int measuredHeight)

As we said earlier, the onMeasure method passes in two parameters, widthMeasureSpec and heightMeasureSpec.

It contains the expected measurement mode and size of the current View calculated by the parent View based on the measurement specifications of the current View LayoutParams and parent View:

When the measurement mode is MeasureSpec.EXACTLY

That is, when the width or height is a certain value, then the width and height of the current layout View can be set to the measured size set for us by the parent View. For example, if the width is 400dp, then we can directly pass in this fixed value by calling setMeasuredDimension without re-measuring.

When the measurement mode is MeasureSpec.AT_MOST or UNSPECIFIED:

At this point, it indicates that the requirement of the parent View for the current View is not fixed, and it can be of any size or not exceeding the maximum value, such as setting the height of the VerticalLayout to wrap_content. Then we have to re-measure the height, because only we designers know how to calculate this adaptive height. Specifically, VerticalLayout is a vertical linear layout, so height is naturally the sum of the heights of all sub-View.

At this point, the logic of the onMeasure method is basically clear:

Override fun onMeasure (widthMeasureSpec: Int, heightMeasureSpec: Int) {super.onMeasure (widthMeasureSpec, heightMeasureSpec) / / get the width and height measurement mode and size 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 / / traversal child View Get the width and height of the total height for (I in 0 until childCount) {val childView = getChildAt (I) / / measured quantum View (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 / / calculate the maximum width mWidth = Math.max (mWidth ChildWidth) / / Cumulative calculation height mHeight + = childHeight} / / set width and height setMeasuredDimension (if (widthMode = = MeasureSpec.EXACTLY) sizeWidth else mWidth, if (heightMode = = MeasureSpec.EXACTLY) sizeHeight else mHeight)}

The main logic is to traverse the sub-View to get the actual width and height of the VerticalLayout:

Height of final ViewGroup = all child View (high + margin value)

The width of the final ViewGroup = the largest child View (width + margin value)

Finally, call setMeasuredDimension to pass in width and height according to the measurement mode.

Override layout method onLayout

As mentioned above, as a ViewGroup, the onLayout method must be overridden to ensure the normal layout of the sub-View.

The same is true of the vertical linear layout VerticalLayout, so what is the key logic of the onLayout method in this layout?

Again, determine the position, that is, determine the left, top, right, and bottom four parameter values, and in VerticalLayout, the most critical parameter is this top value, that is, the top value.

The top value of each View must be the bottom value of the previous View, that is, the last View will be placed, so it will be a vertical linear effect, so what we need to do is to dynamically calculate the top value of each View, that is, constantly accumulate the height of the View as the top value of the next View.

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 / / traversal child View Layout each sub-View for (I in 0 until childCount) {val childView = getChildAt (I) childHeight = childView.measuredHeight childWidth = childView.measuredWidth lp = childView.layoutParams as MarginLayoutParams / / Cumulative top value childTop + = lp.topMargin / / layout sub-View childView.layout (lp.leftMargin ChildTop, lp.leftMargin + childWidth, childTop + childHeight) ChildTop + = childHeight + lp.bottomMargin}}

The logic is quite simple.

Left is the leftMargin of a fixed child View.

Top is the height + Margin value of the cumulative sub-View.

Right is the width of the left + child View.

Bottom is the height of the top + child View.

Finally, the layout method of the child View is called to lay out each sub-View.

Fourth, the effect shows that the above is all the content of this article "what is the knowledge related to the Layout layout of Java Swing class?" Thank you for reading! I believe you will gain a lot after reading this article. The editor will update different knowledge for you every day. If you want to learn more knowledge, please pay attention to the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.