| /* |
| * Copyright (C) 2018 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.support.constraint.solver.widgets; |
| |
| import android.support.constraint.solver.widgets.ConstraintWidget.DimensionBehaviour; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** |
| * Class to do widget constraints analysis. |
| * <p> |
| * Identify groups of widgets independent from each other. |
| * TODO: Identify Chains here instead. |
| */ |
| public class Analyzer { |
| |
| private Analyzer() { |
| } |
| |
| /** |
| * Find groups of constrained widgets. |
| * <p> |
| * Used to simplify the resolution process to layout the widgets when using optimizations. |
| * Wrap_content layouts require measuring the final size, groups are identified when |
| * the layout can be measured. |
| * |
| * @param layoutWidget Layout to analyze. |
| */ |
| public static void determineGroups(ConstraintWidgetContainer layoutWidget) { |
| if ((layoutWidget.getOptimizationLevel() & Optimizer.OPTIMIZATION_GROUPS) != Optimizer.OPTIMIZATION_GROUPS) { |
| singleGroup(layoutWidget); |
| return; |
| } |
| layoutWidget.mSkipSolver = true; |
| layoutWidget.mGroupsWrapOptimized = false; |
| layoutWidget.mHorizontalWrapOptimized = false; |
| layoutWidget.mVerticalWrapOptimized = false; |
| final List<ConstraintWidget> widgets = layoutWidget.mChildren; |
| final List<ConstraintWidgetGroup> widgetGroups = layoutWidget.mWidgetGroups; |
| boolean horizontalWrapContent = layoutWidget.getHorizontalDimensionBehaviour() == DimensionBehaviour.WRAP_CONTENT; |
| boolean verticalWrapContent = layoutWidget.getVerticalDimensionBehaviour() == DimensionBehaviour.WRAP_CONTENT; |
| boolean hasWrapContent = horizontalWrapContent || verticalWrapContent; |
| widgetGroups.clear(); |
| |
| for (ConstraintWidget widget : widgets) { |
| widget.mBelongingGroup = null; |
| widget.mGroupsToSolver = false; |
| widget.resetResolutionNodes(); |
| } |
| for (ConstraintWidget widget : widgets) { |
| if (widget.mBelongingGroup == null) { |
| if (!determineGroups(widget, widgetGroups, hasWrapContent)) { |
| singleGroup(layoutWidget); |
| layoutWidget.mSkipSolver = false; |
| return; |
| } |
| } |
| } |
| int measuredWidth = 0; |
| int measuredHeight = 0; |
| // Resolve solvable widgets. |
| for (ConstraintWidgetGroup group : widgetGroups) { |
| measuredWidth = Math.max(measuredWidth, |
| getMaxDimension(group, ConstraintWidget.HORIZONTAL)); |
| measuredHeight = Math.max(measuredHeight, |
| getMaxDimension(group, ConstraintWidget.VERTICAL)); |
| } |
| // Change container to fixed and set resolved dimensions. |
| if (horizontalWrapContent) { |
| layoutWidget.setHorizontalDimensionBehaviour(DimensionBehaviour.FIXED); |
| layoutWidget.setWidth(measuredWidth); |
| layoutWidget.mGroupsWrapOptimized = true; |
| layoutWidget.mHorizontalWrapOptimized = true; |
| layoutWidget.mWrapFixedWidth = measuredWidth; |
| } |
| if (verticalWrapContent) { |
| layoutWidget.setVerticalDimensionBehaviour(DimensionBehaviour.FIXED); |
| layoutWidget.setHeight(measuredHeight); |
| layoutWidget.mGroupsWrapOptimized = true; |
| layoutWidget.mVerticalWrapOptimized = true; |
| layoutWidget.mWrapFixedHeight = measuredHeight; |
| } |
| setPosition(widgetGroups, ConstraintWidget.HORIZONTAL, layoutWidget.getWidth()); |
| setPosition(widgetGroups, ConstraintWidget.VERTICAL, layoutWidget.getHeight()); |
| } |
| |
| /** |
| * @param widget Widget being traversed. |
| * @param widgetGroups Starting list to contain the widgets in this group. |
| * @param hasWrapContent Indicating if any dimension of the parent is in wrap_content. |
| * @return False if the group can't be optimized in any way. |
| */ |
| private static boolean determineGroups(ConstraintWidget widget, |
| List<ConstraintWidgetGroup> widgetGroups, boolean hasWrapContent) { |
| ConstraintWidgetGroup traverseList = new ConstraintWidgetGroup(new ArrayList<ConstraintWidget>(), true); |
| widgetGroups.add(traverseList); |
| return traverse(widget, traverseList, widgetGroups, hasWrapContent); |
| } |
| |
| /** |
| * Recursive function to traverse constrained widgets. |
| * The objective is to maintain in a single list all the widgets that can be reached through |
| * their constraints except for their parent. |
| * |
| * @param widget Widget being traversed. |
| * @param upperGroup List being passed down, originally by {@link #determineGroups(ConstraintWidget, List, boolean)}. |
| * @param widgetGroups List of widget groups identified. |
| * @param hasWrapContent Indicates if the layout has any dimension as wrap_content. |
| * @return If the group analysis failed or can't be done. |
| */ |
| private static boolean traverse(ConstraintWidget widget, ConstraintWidgetGroup upperGroup, |
| List<ConstraintWidgetGroup> widgetGroups, boolean hasWrapContent) { |
| if (widget == null) { |
| return true; |
| } |
| widget.mOptimizerMeasured = false; |
| ConstraintWidgetContainer layoutWidget = (ConstraintWidgetContainer) widget.getParent(); |
| if (widget.mBelongingGroup == null) { |
| // If it hasn't been assigned to a group. |
| widget.mOptimizerMeasurable = true; |
| upperGroup.mConstrainedGroup.add(widget); |
| widget.mBelongingGroup = upperGroup; |
| // Determine if group is measurable. |
| if (widget.mLeft.mTarget == null |
| && widget.mRight.mTarget == null |
| && widget.mTop.mTarget == null |
| && widget.mBottom.mTarget == null |
| && widget.mBaseline.mTarget == null |
| && widget.mCenter.mTarget == null) { |
| invalidate(layoutWidget, widget, upperGroup); |
| if (hasWrapContent) { |
| return false; |
| } |
| } |
| // Check if it has vertical bias. |
| if (widget.mTop.mTarget != null && widget.mBottom.mTarget != null) { |
| // Allow if it has no wrap content in that dimension an constrained to the parent. |
| boolean wrap = layoutWidget.getVerticalDimensionBehaviour() == DimensionBehaviour.WRAP_CONTENT; |
| if (hasWrapContent) { |
| invalidate(layoutWidget, widget, upperGroup); |
| return false; |
| } else if (!(widget.mTop.mTarget.mOwner == widget.getParent() |
| && widget.mBottom.mTarget.mOwner == widget.getParent())) { |
| invalidate(layoutWidget, widget, upperGroup); |
| } |
| } |
| // Check if it has horizontal bias. |
| if (widget.mLeft.mTarget != null && widget.mRight.mTarget != null) { |
| // Allow if it has no wrap content in that dimension an constrained to the parent. |
| boolean wrap = layoutWidget.getHorizontalDimensionBehaviour() == DimensionBehaviour.WRAP_CONTENT; |
| if (hasWrapContent) { |
| invalidate(layoutWidget, widget, upperGroup); |
| return false; |
| } else if (!(widget.mLeft.mTarget.mOwner == widget.getParent() |
| && widget.mRight.mTarget.mOwner == widget.getParent())) { |
| invalidate(layoutWidget, widget, upperGroup); |
| } |
| } |
| if ((widget.getHorizontalDimensionBehaviour() == DimensionBehaviour.MATCH_CONSTRAINT |
| ^ widget.getVerticalDimensionBehaviour() == DimensionBehaviour.MATCH_CONSTRAINT) |
| && widget.mDimensionRatio != 0.0f) { |
| // Calculate dimension. |
| resolveDimensionRatio(widget); |
| } else if (!(widget.getHorizontalDimensionBehaviour() != DimensionBehaviour.MATCH_CONSTRAINT |
| && widget.getVerticalDimensionBehaviour() != DimensionBehaviour.MATCH_CONSTRAINT)) { |
| invalidate(layoutWidget, widget, upperGroup); |
| if (hasWrapContent) { |
| return false; |
| } |
| } |
| // Is Horizontal start |
| if (((widget.mLeft.mTarget == null && widget.mRight.mTarget == null) |
| || (widget.mLeft.mTarget != null && widget.mLeft.mTarget.mOwner == widget.mParent && widget.mRight.mTarget == null) |
| || (widget.mRight.mTarget != null && widget.mRight.mTarget.mOwner == widget.mParent && widget.mLeft.mTarget == null) |
| || (widget.mLeft.mTarget != null && widget.mLeft.mTarget.mOwner == widget.mParent |
| && widget.mRight.mTarget != null && widget.mRight.mTarget.mOwner == widget.mParent)) |
| && (widget.mCenter.mTarget == null)) { |
| if (!(widget instanceof Guideline) && !(widget instanceof Helper)) { |
| upperGroup.mStartHorizontalWidgets.add(widget); |
| } |
| |
| } |
| // Is Vertical start |
| if (((widget.mTop.mTarget == null && widget.mBottom.mTarget == null) |
| || (widget.mTop.mTarget != null && widget.mTop.mTarget.mOwner == widget.mParent && widget.mBottom.mTarget == null) |
| || (widget.mBottom.mTarget != null && widget.mBottom.mTarget.mOwner == widget.mParent && widget.mTop.mTarget == null) |
| || (widget.mTop.mTarget != null && widget.mTop.mTarget.mOwner == widget.mParent |
| && widget.mBottom.mTarget != null && widget.mBottom.mTarget.mOwner == widget.mParent)) |
| && (widget.mCenter.mTarget == null && widget.mBaseline.mTarget == null)) { |
| if (!(widget instanceof Guideline) && !(widget instanceof Helper)) { |
| upperGroup.mStartVerticalWidgets.add(widget); |
| } |
| } |
| } else { |
| // If it has, join the list and re-assign. Remove joint list from mWidgetGroups (if its a different list) |
| if (widget.mBelongingGroup != upperGroup) { |
| upperGroup.mConstrainedGroup.addAll(widget.mBelongingGroup.mConstrainedGroup); |
| upperGroup.mStartHorizontalWidgets.addAll(widget.mBelongingGroup.mStartHorizontalWidgets); |
| upperGroup.mStartVerticalWidgets.addAll(widget.mBelongingGroup.mStartVerticalWidgets); |
| if (widget.mBelongingGroup.mSkipSolver == false) { |
| upperGroup.mSkipSolver = false; |
| } |
| widgetGroups.remove(widget.mBelongingGroup); |
| for (ConstraintWidget auxWidget : widget.mBelongingGroup.mConstrainedGroup) { |
| auxWidget.mBelongingGroup = upperGroup; |
| } |
| } |
| return true; |
| } |
| // Proceed to traverse widgets, start with HelperWidgets since they contain multiple widgets. |
| if (widget instanceof Helper) { |
| invalidate(layoutWidget, widget, upperGroup); |
| if (hasWrapContent) { |
| return false; |
| } |
| final Helper hWidget = (Helper) widget; |
| for (int widgetsCount = 0; widgetsCount < hWidget.mWidgetsCount; widgetsCount++) { |
| if (!traverse(hWidget.mWidgets[widgetsCount], upperGroup, widgetGroups, hasWrapContent)) { |
| return false; |
| } |
| } |
| } |
| // We traverse every anchor, for wrap_content we ignore center (circular constraints). |
| final int anchorsSize = widget.mListAnchors.length; |
| for (int i = 0; i < anchorsSize; i++) { |
| final ConstraintAnchor anchor = widget.mListAnchors[i]; |
| if (anchor.mTarget != null && anchor.mTarget.mOwner != widget.getParent()) { |
| if (anchor.mType == ConstraintAnchor.Type.CENTER) { |
| invalidate(layoutWidget, widget, upperGroup); |
| if (hasWrapContent) { |
| return false; |
| } |
| } else { |
| setConnection(anchor); |
| } |
| if (!traverse(anchor.mTarget.mOwner, upperGroup, widgetGroups, hasWrapContent)) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| private static void invalidate(ConstraintWidgetContainer layoutWidget, ConstraintWidget widget, ConstraintWidgetGroup group) { |
| group.mSkipSolver = false; |
| layoutWidget.mSkipSolver = false; |
| widget.mOptimizerMeasurable = false; |
| } |
| |
| /** |
| * Obtain the max length of a {@link ConstraintWidgetGroup} on a specific orientation. |
| * Length is saved on the group for future use as well. |
| * |
| * @param group Group of widgets being measured. |
| * @param orientation Orientation being measured. |
| * @return Max dimension in the group. |
| */ |
| private static int getMaxDimension(ConstraintWidgetGroup group, int orientation) { |
| int dimension = 0; |
| int offset = orientation * 2; |
| List<ConstraintWidget> startWidgets = group.getStartWidgets(orientation); |
| final int size = startWidgets.size(); |
| for (int i = 0; i < size; i++) { |
| ConstraintWidget widget = startWidgets.get(i); |
| boolean topLeftFlow = widget.mListAnchors[offset + 1].mTarget == null |
| || (widget.mListAnchors[offset].mTarget != null |
| && widget.mListAnchors[offset + 1].mTarget != null); |
| dimension = Math.max(dimension, getMaxDimensionTraversal(widget, orientation, topLeftFlow, 0)); |
| } |
| |
| group.mGroupDimensions[orientation] = dimension; |
| return dimension; |
| } |
| |
| /** |
| * Traverse from a widget at the start of a tree (a widget constrained to any side of their parent), |
| * find the maximum length of the tree. |
| * Avoids cases when a widget's dimension shouldn't be considered. |
| * |
| * @param widget Widget being traversed. |
| * @param orientation Dimension being measured (HORIZONTAL/VERTICAL). |
| * @param topLeftFlow Indicates if the tree starts at the top or left of the container. |
| * @param depth How far the widget is from the start of the tree. |
| * @return Max dimension from the widget being traversed. |
| */ |
| private static int getMaxDimensionTraversal(ConstraintWidget widget, int orientation, boolean topLeftFlow, int depth) { |
| // Start and end offset used to point to the correct anchors according to the flow |
| // of the widget at the start of the tree. |
| if (!widget.mOptimizerMeasurable) { |
| return 0; |
| } |
| int startOffset; |
| int endOffset; |
| int dimension = 0; |
| int dimensionPre = 0; |
| int dimensionPost = 0; |
| final int flow; |
| final int baselinePreDistance; |
| final int baselinePostDistance; |
| // If it has baseline, the dimensions change, despite maintaining the flow. |
| final boolean hasBaseline = widget.mBaseline.mTarget != null && orientation == ConstraintWidget.VERTICAL; |
| |
| if (topLeftFlow) { |
| baselinePreDistance = widget.getBaselineDistance(); |
| baselinePostDistance = widget.getHeight() - widget.getBaselineDistance(); |
| startOffset = orientation * 2; |
| endOffset = startOffset + 1; |
| } else { |
| baselinePreDistance = widget.getHeight() - widget.getBaselineDistance(); |
| baselinePostDistance = widget.getBaselineDistance(); |
| endOffset = orientation * 2; |
| startOffset = endOffset + 1; |
| } |
| |
| // Define the correct flow of direction. left -> right or left <- right. |
| // If the flow is going opposite from the startWidget, lengths and margin subtract. |
| if (widget.mListAnchors[endOffset].mTarget != null && widget.mListAnchors[startOffset].mTarget == null) { |
| flow = -1; |
| int aux = startOffset; |
| startOffset = endOffset; |
| endOffset = aux; |
| } else { |
| flow = 1; |
| } |
| |
| if (hasBaseline) { |
| depth -= baselinePreDistance; |
| } |
| // Get position from horizontal/vertical bias. |
| dimension = widget.mListAnchors[startOffset].getMargin() * flow + getParentBiasOffset(widget, orientation); |
| int downDepth = dimension + depth; |
| int postTemp = ((orientation == ConstraintWidget.HORIZONTAL) ? widget.getWidth() : widget.getHeight()) * flow; |
| for (ResolutionNode targetNode : widget.mListAnchors[startOffset].getResolutionNode().dependents) { |
| final ResolutionAnchor anchor = (ResolutionAnchor) targetNode; |
| dimensionPre = Math.max(dimensionPre, getMaxDimensionTraversal(anchor.myAnchor.mOwner, orientation, topLeftFlow, downDepth)); |
| } |
| for (ResolutionNode targetNode : widget.mListAnchors[endOffset].getResolutionNode().dependents) { |
| final ResolutionAnchor anchor = (ResolutionAnchor) targetNode; |
| dimensionPost = Math.max(dimensionPost, getMaxDimensionTraversal(anchor.myAnchor.mOwner, orientation, topLeftFlow, postTemp + downDepth)); |
| } |
| if (hasBaseline) { |
| dimensionPre -= baselinePreDistance; |
| dimensionPost += baselinePostDistance; |
| } else { |
| dimensionPost += ((orientation == ConstraintWidget.HORIZONTAL) ? widget.getWidth() : widget.getHeight()) * flow; |
| } |
| |
| // Baseline, only add distance from baseline to bottom instead of entire height. |
| int dimensionBaseline = 0; |
| if (orientation == ConstraintWidget.VERTICAL) { |
| for (ResolutionNode targetNode : widget.mBaseline.getResolutionNode().dependents) { |
| final ResolutionAnchor anchor = (ResolutionAnchor) targetNode; |
| if (flow == 1) { |
| dimensionBaseline = Math.max(dimensionBaseline, getMaxDimensionTraversal(anchor.myAnchor.mOwner, orientation, topLeftFlow, baselinePreDistance + downDepth)); |
| } else { |
| dimensionBaseline = Math.max(dimensionBaseline, getMaxDimensionTraversal(anchor.myAnchor.mOwner, orientation, topLeftFlow, (baselinePostDistance * flow) + downDepth)); |
| } |
| } |
| if (widget.mBaseline.getResolutionNode().dependents.size() > 0 && !hasBaseline) { |
| if (flow == 1) { |
| dimensionBaseline += baselinePreDistance; |
| } else { |
| dimensionBaseline -= baselinePostDistance; |
| } |
| } |
| } |
| |
| int distanceBeforeWidget = dimension; |
| dimension += Math.max(dimensionPre, Math.max(dimensionPost, dimensionBaseline)); |
| int leftTop = depth + distanceBeforeWidget; |
| int end = leftTop + postTemp; |
| if (flow == -1) { |
| int aux = end; |
| end = leftTop; |
| leftTop = aux; |
| } |
| if (topLeftFlow) { |
| Optimizer.setOptimizedWidget(widget, orientation, leftTop); |
| widget.setFrame(leftTop, end, orientation); |
| } else { |
| widget.mBelongingGroup.addWidgetsToSet(widget, orientation); |
| widget.setRelativePositioning(leftTop, orientation); |
| } |
| // Assuming widgets with only one dimension on Match_constraint would be measurable. |
| if (widget.getDimensionBehaviour(orientation) == DimensionBehaviour.MATCH_CONSTRAINT |
| && widget.mDimensionRatio != 0.0f) { |
| widget.mBelongingGroup.addWidgetsToSet(widget, orientation); |
| } |
| // Assuming is not measurable when the parent is on wrap_content. |
| if (widget.mListAnchors[startOffset].mTarget != null |
| && widget.mListAnchors[endOffset].mTarget != null) { |
| final ConstraintWidget parent = widget.getParent(); |
| if (widget.mListAnchors[startOffset].mTarget.mOwner == parent |
| && widget.mListAnchors[endOffset].mTarget.mOwner == parent) { |
| widget.mBelongingGroup.addWidgetsToSet(widget, orientation); |
| } |
| } |
| return dimension; |
| } |
| |
| private static void setConnection(ConstraintAnchor originAnchor) { |
| ResolutionNode originNode = originAnchor.getResolutionNode(); |
| if (originAnchor.mTarget != null && originAnchor.mTarget.mTarget != originAnchor) { |
| // Go to Owner and add the dependent. |
| originAnchor.mTarget.getResolutionNode().addDependent(originNode); |
| } |
| } |
| |
| /** |
| * Used when the Analyzer cannot simplify in independent groups. |
| * This will make it so all widgets are included in the same group. |
| * |
| * @param layoutWidget ConstrainedWidgetContainer being analyzed. |
| */ |
| private static void singleGroup(ConstraintWidgetContainer layoutWidget) { |
| layoutWidget.mWidgetGroups.clear(); |
| layoutWidget.mWidgetGroups.add(0, new ConstraintWidgetGroup(layoutWidget.mChildren)); |
| } |
| |
| /** |
| * Update widgets positions. |
| * Necessary for widgets dependent on the right/bottom side of the Container. |
| * |
| * @param groups Groups of widgets being updated. |
| * @param orientation Dimension to update on the widgets. |
| * @param containerLength Length of the widget container. |
| */ |
| public static void setPosition(List<ConstraintWidgetGroup> groups, int orientation, int containerLength) { |
| final int groupsSize = groups.size(); |
| for (int i = 0; i < groupsSize; i++) { |
| ConstraintWidgetGroup group = groups.get(i); |
| for (ConstraintWidget widget : group.getWidgetsToSet(orientation)) { |
| // We can only update those that we can measure. |
| if (widget.mOptimizerMeasurable) { |
| updateSizeDependentWidgets(widget, orientation, containerLength); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Update the final layout position of widgets that depend on the size of the container. |
| * Exception for dimension-ratio as a work-around. |
| * |
| * @param widget Widget being updated. |
| * @param orientation Orientation being updated. |
| * @param containerLength The final container dimension in the orientation. |
| */ |
| private static void updateSizeDependentWidgets(ConstraintWidget widget, int orientation, int containerLength) { |
| final int end; |
| final int start; |
| final int offset = orientation * 2; |
| ConstraintAnchor startAnchor = widget.mListAnchors[offset]; |
| ConstraintAnchor endAnchor = widget.mListAnchors[offset + 1]; |
| boolean hasBias = startAnchor.mTarget != null && endAnchor.mTarget != null; |
| if (hasBias) { |
| start = getParentBiasOffset(widget, orientation) + startAnchor.getMargin(); |
| Optimizer.setOptimizedWidget(widget, orientation, start); |
| return; |
| } |
| /* |
| * ConstraintLayout::internalMeasureChildren() workaround (it would reset the widget's |
| * dimension even if it was set beforehand). |
| * It is assumed that the left/top anchor has been resolved. Since only the dimension is being reset. |
| */ |
| if (widget.mDimensionRatio != 0.0f && widget.getDimensionBehaviour(orientation) == DimensionBehaviour.MATCH_CONSTRAINT) { |
| int length = resolveDimensionRatio(widget); |
| start = (int) widget.mListAnchors[offset].getResolutionNode().resolvedOffset; |
| end = start + length; |
| endAnchor.getResolutionNode().resolvedTarget = startAnchor.getResolutionNode(); |
| endAnchor.getResolutionNode().resolvedOffset = length; |
| endAnchor.getResolutionNode().state = ResolutionNode.RESOLVED; |
| widget.setFrame(start, end, orientation); |
| return; |
| } |
| end = containerLength - widget.getRelativePositioning(orientation); |
| start = end - widget.getLength(orientation); |
| widget.setFrame(start, end, orientation); |
| Optimizer.setOptimizedWidget(widget, orientation, start); |
| } |
| |
| /** |
| * Get the offset of a widget with bias exclusively with the parent. |
| * Offset is the distance from the left/top side of the parent to the start of the widget. |
| * |
| * @param orientation Orientation for the offset. |
| * @return The distance from the root based on the bias (does not include margin distance). 0 if it can't be calculated. |
| */ |
| private static int getParentBiasOffset(ConstraintWidget widget, int orientation) { |
| int offset = orientation * 2; |
| ConstraintAnchor startAnchor = widget.mListAnchors[offset]; |
| ConstraintAnchor endAnchor = widget.mListAnchors[offset + 1]; |
| if (startAnchor.mTarget != null && startAnchor.mTarget.mOwner == widget.mParent |
| && endAnchor.mTarget != null && endAnchor.mTarget.mOwner == widget.mParent) { |
| int length = 0; |
| int widgetDimension = 0; |
| float bias = 0.0f; |
| length = widget.mParent.getLength(orientation); |
| bias = (orientation == ConstraintWidget.HORIZONTAL) ? widget.mHorizontalBiasPercent : |
| widget.mVerticalBiasPercent; |
| widgetDimension = widget.getLength(orientation); |
| length = length - startAnchor.getMargin() - endAnchor.getMargin(); |
| length = length - widgetDimension; |
| length = ((int) ((float) length * bias)); |
| return length; |
| } else { |
| return 0; |
| } |
| } |
| |
| /** |
| * Calculate the widget's dimension based on dimension ratio. |
| * |
| * @return The dimension calculated. |
| */ |
| private static int resolveDimensionRatio(ConstraintWidget widget) { |
| int length = ConstraintWidget.UNKNOWN; |
| if (widget.getHorizontalDimensionBehaviour() == DimensionBehaviour.MATCH_CONSTRAINT) { |
| if (widget.mDimensionRatioSide == ConstraintWidget.HORIZONTAL) { |
| length = (int) ((float) widget.getHeight() * widget.mDimensionRatio); |
| } else { |
| length = (int) ((float) widget.getHeight() / widget.mDimensionRatio); |
| } |
| widget.setWidth(length); |
| } else if (widget.getVerticalDimensionBehaviour() == DimensionBehaviour.MATCH_CONSTRAINT) { |
| if (widget.mDimensionRatioSide == ConstraintWidget.VERTICAL) { |
| length = (int) ((float) widget.getWidth() * widget.mDimensionRatio); |
| } else { |
| length = (int) ((float) widget.getWidth() / widget.mDimensionRatio); |
| } |
| widget.setHeight(length); |
| } |
| return length; |
| } |
| } |
