| /* |
| * Copyright (C) 2015 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.LinearSystem; |
| import android.support.constraint.solver.Metrics; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| |
| import static android.support.constraint.solver.LinearSystem.FULL_DEBUG; |
| import static android.support.constraint.solver.widgets.ConstraintWidget.DimensionBehaviour.WRAP_CONTENT; |
| |
| /** |
| * A container of ConstraintWidget that can layout its children |
| */ |
| public class ConstraintWidgetContainer extends WidgetContainer { |
| |
| private static final boolean USE_SNAPSHOT = true; |
| private static final int MAX_ITERATIONS = 8; |
| |
| private static final boolean DEBUG = FULL_DEBUG; |
| private static final boolean DEBUG_LAYOUT = false; |
| static final boolean DEBUG_GRAPH = false; |
| |
| private boolean mIsRtl = false; |
| |
| public void fillMetrics(Metrics metrics) { |
| mSystem.fillMetrics(metrics); |
| } |
| |
| protected LinearSystem mSystem = new LinearSystem(); |
| |
| private Snapshot mSnapshot; |
| |
| int mPaddingLeft; |
| int mPaddingTop; |
| int mPaddingRight; |
| int mPaddingBottom; |
| |
| int mHorizontalChainsSize = 0; |
| int mVerticalChainsSize = 0; |
| |
| ChainHead[] mVerticalChainsArray = new ChainHead[4]; |
| ChainHead[] mHorizontalChainsArray = new ChainHead[4]; |
| |
| public List<ConstraintWidgetGroup> mWidgetGroups = new ArrayList<>(); |
| public boolean mGroupsWrapOptimized = false; |
| public boolean mHorizontalWrapOptimized = false; |
| public boolean mVerticalWrapOptimized = false; |
| public int mWrapFixedWidth = 0; |
| public int mWrapFixedHeight = 0; |
| |
| private int mOptimizationLevel = Optimizer.OPTIMIZATION_STANDARD; |
| public boolean mSkipSolver = false; |
| |
| private boolean mWidthMeasuredTooSmall = false; |
| private boolean mHeightMeasuredTooSmall = false; |
| |
| /*-----------------------------------------------------------------------*/ |
| // Construction |
| /*-----------------------------------------------------------------------*/ |
| |
| /** |
| * Default constructor |
| */ |
| public ConstraintWidgetContainer() { |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param x x position |
| * @param y y position |
| * @param width width of the layout |
| * @param height height of the layout |
| */ |
| public ConstraintWidgetContainer(int x, int y, int width, int height) { |
| super(x, y, width, height); |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param width width of the layout |
| * @param height height of the layout |
| */ |
| public ConstraintWidgetContainer(int width, int height) { |
| super(width, height); |
| } |
| |
| /** |
| * Resolves the system directly when possible |
| * |
| * @param value optimization level |
| */ |
| public void setOptimizationLevel(int value) { |
| mOptimizationLevel = value; |
| } |
| |
| /** |
| * Returns the current optimization level |
| * |
| * @return |
| */ |
| public int getOptimizationLevel() { |
| return mOptimizationLevel; |
| } |
| |
| /** |
| * Returns true if the given feature should be optimized |
| * @param feature |
| * @return |
| */ |
| public boolean optimizeFor(int feature) { |
| return (mOptimizationLevel & feature) == feature; |
| } |
| |
| /** |
| * Specify the xml type for the container |
| * |
| * @return |
| */ |
| @Override |
| public String getType() { |
| return "ConstraintLayout"; |
| } |
| |
| @Override |
| public void reset() { |
| mSystem.reset(); |
| mPaddingLeft = 0; |
| mPaddingRight = 0; |
| mPaddingTop = 0; |
| mPaddingBottom = 0; |
| mWidgetGroups.clear(); |
| mSkipSolver = false; |
| super.reset(); |
| } |
| |
| /** |
| * Return true if the width given is too small for the content layed out |
| */ |
| public boolean isWidthMeasuredTooSmall() { return mWidthMeasuredTooSmall; } |
| |
| /** |
| * Return true if the height given is too small for the content layed out |
| */ |
| public boolean isHeightMeasuredTooSmall() { return mHeightMeasuredTooSmall; } |
| |
| int mDebugSolverPassCount = 0; |
| |
| /** |
| * Add this widget to the solver |
| * |
| * @param system the solver we want to add the widget to |
| */ |
| public boolean addChildrenToSolver(LinearSystem system) { |
| if (DEBUG) { |
| System.out.println("\n#######################################"); |
| System.out.println("## ADD CHILDREN TO SOLVER (" + mDebugSolverPassCount + ") ##"); |
| System.out.println("#######################################\n"); |
| mDebugSolverPassCount++; |
| } |
| addToSolver(system); |
| final int count = mChildren.size(); |
| |
| for (int i = 0; i < count; i++) { |
| ConstraintWidget widget = mChildren.get(i); |
| if (widget instanceof ConstraintWidgetContainer) { |
| DimensionBehaviour horizontalBehaviour = widget.mListDimensionBehaviors[DIMENSION_HORIZONTAL]; |
| DimensionBehaviour verticalBehaviour = widget.mListDimensionBehaviors[DIMENSION_VERTICAL]; |
| if (horizontalBehaviour == WRAP_CONTENT) { |
| widget.setHorizontalDimensionBehaviour(DimensionBehaviour.FIXED); |
| } |
| if (verticalBehaviour == WRAP_CONTENT) { |
| widget.setVerticalDimensionBehaviour(DimensionBehaviour.FIXED); |
| } |
| widget.addToSolver(system); |
| if (horizontalBehaviour == WRAP_CONTENT) { |
| widget.setHorizontalDimensionBehaviour(horizontalBehaviour); |
| } |
| if (verticalBehaviour == WRAP_CONTENT) { |
| widget.setVerticalDimensionBehaviour(verticalBehaviour); |
| } |
| } else { |
| Optimizer.checkMatchParent(this, system, widget); |
| widget.addToSolver(system); |
| } |
| } |
| |
| if (mHorizontalChainsSize > 0) { |
| Chain.applyChainConstraints(this, system, HORIZONTAL); |
| } |
| if (mVerticalChainsSize > 0) { |
| Chain.applyChainConstraints(this, system, VERTICAL); |
| } |
| return true; |
| } |
| |
| /** |
| * Update the frame of the layout and its children from the solver |
| * |
| * @param system the solver we get the values from. |
| */ |
| public void updateChildrenFromSolver(LinearSystem system, boolean flags[]) { |
| flags[Optimizer.FLAG_RECOMPUTE_BOUNDS] = false; |
| updateFromSolver(system); |
| final int count = mChildren.size(); |
| for (int i = 0; i < count; i++) { |
| ConstraintWidget widget = mChildren.get(i); |
| widget.updateFromSolver(system); |
| if (widget.mListDimensionBehaviors[DIMENSION_HORIZONTAL] == DimensionBehaviour.MATCH_CONSTRAINT |
| && widget.getWidth() < widget.getWrapWidth()) { |
| flags[Optimizer.FLAG_RECOMPUTE_BOUNDS] = true; |
| } |
| if (widget.mListDimensionBehaviors[DIMENSION_VERTICAL] == DimensionBehaviour.MATCH_CONSTRAINT |
| && widget.getHeight() < widget.getWrapHeight()) { |
| flags[Optimizer.FLAG_RECOMPUTE_BOUNDS] = true; |
| } |
| } |
| } |
| |
| /** |
| * Set the padding on this container. It will apply to the position of the children. |
| * |
| * @param left left padding |
| * @param top top padding |
| * @param right right padding |
| * @param bottom bottom padding |
| */ |
| public void setPadding(int left, int top, int right, int bottom) { |
| mPaddingLeft = left; |
| mPaddingTop = top; |
| mPaddingRight = right; |
| mPaddingBottom = bottom; |
| } |
| |
| /** |
| * Set the rtl status. This has implications for Chains. |
| * @param isRtl true if we are in RTL. |
| */ |
| public void setRtl(boolean isRtl) { |
| mIsRtl = isRtl; |
| } |
| |
| /** |
| * Returns the rtl status. |
| * @return true if in RTL, false otherwise. |
| */ |
| public boolean isRtl() { |
| return mIsRtl; |
| } |
| |
| /*-----------------------------------------------------------------------*/ |
| // Overloaded methods from ConstraintWidget |
| /*-----------------------------------------------------------------------*/ |
| |
| /** |
| * Graph analysis |
| * @param optimizationLevel the current optimisation level |
| */ |
| @Override |
| public void analyze(int optimizationLevel) { |
| super.analyze(optimizationLevel); |
| final int count = mChildren.size(); |
| for (int i = 0; i < count; i++) { |
| mChildren.get(i).analyze(optimizationLevel); |
| } |
| } |
| |
| /** |
| * Layout the tree of widgets |
| */ |
| @Override |
| public void layout() { |
| if (DEBUG) { |
| System.out.println("\n#####################################"); |
| System.out.println("## LAYOUT PASS ##"); |
| System.out.println("#####################################\n"); |
| mDebugSolverPassCount = 0; |
| } |
| int prex = mX; |
| int prey = mY; |
| int prew = Math.max(0, getWidth()); |
| int preh = Math.max(0, getHeight()); |
| mWidthMeasuredTooSmall = false; |
| mHeightMeasuredTooSmall = false; |
| |
| if (mParent != null && USE_SNAPSHOT) { |
| if (mSnapshot == null) { |
| mSnapshot = new Snapshot(this); |
| } |
| mSnapshot.updateFrom(this); |
| // We clear ourselves of external anchors as |
| // well as repositioning us to (0, 0) |
| // before inserting us in the solver, so that our |
| // children's positions get computed relative to us. |
| setX(mPaddingLeft); |
| setY(mPaddingTop); |
| resetAnchors(); |
| resetSolverVariables(mSystem.getCache()); |
| } else { |
| mX = 0; |
| mY = 0; |
| } |
| |
| if (mOptimizationLevel != Optimizer.OPTIMIZATION_NONE) { |
| if (!optimizeFor(Optimizer.OPTIMIZATION_DIMENSIONS)) { |
| optimizeReset(); |
| } |
| if (!optimizeFor(Optimizer.OPTIMIZATION_GROUPS)) { |
| optimize(); |
| } |
| mSystem.graphOptimizer = true; |
| } else { |
| mSystem.graphOptimizer = false; |
| } |
| |
| boolean wrap_override = false; |
| DimensionBehaviour originalVerticalDimensionBehaviour = mListDimensionBehaviors[DIMENSION_VERTICAL]; |
| DimensionBehaviour originalHorizontalDimensionBehaviour = mListDimensionBehaviors[DIMENSION_HORIZONTAL]; |
| |
| if (DEBUG_LAYOUT) { |
| System.out.println("layout with prew: " + prew + " (" + mListDimensionBehaviors[DIMENSION_HORIZONTAL] |
| + ") preh: " + preh + " (" + mListDimensionBehaviors[DIMENSION_VERTICAL] + ")"); |
| } |
| |
| // Reset the chains before iterating on our children |
| resetChains(); |
| |
| if (mWidgetGroups.size() == 0){ |
| mWidgetGroups.clear(); |
| mWidgetGroups.add(0, new ConstraintWidgetGroup(mChildren)); |
| } |
| |
| int countSolve = 0; |
| final int groupSize = mWidgetGroups.size(); |
| final List<ConstraintWidget> allChildren = mChildren; |
| boolean hasWrapContent = getHorizontalDimensionBehaviour() == WRAP_CONTENT || getVerticalDimensionBehaviour() == WRAP_CONTENT; |
| |
| for (int groupIndex = 0; groupIndex < groupSize && !mSkipSolver; groupIndex++) { |
| if (mWidgetGroups.get(groupIndex).mSkipSolver) { |
| continue; |
| } |
| if (optimizeFor(Optimizer.OPTIMIZATION_GROUPS)) { |
| if (getHorizontalDimensionBehaviour() == DimensionBehaviour.FIXED && getVerticalDimensionBehaviour() == DimensionBehaviour.FIXED) { |
| mChildren = (ArrayList<ConstraintWidget>) mWidgetGroups.get(groupIndex).getWidgetsToSolve(); |
| } else { |
| mChildren = (ArrayList<ConstraintWidget>) mWidgetGroups.get(groupIndex).mConstrainedGroup; |
| } |
| } |
| resetChains(); |
| final int count = mChildren.size(); |
| countSolve = 0; |
| |
| // Before we solve our system, we should call layout() on any |
| // of our children that is a container. |
| for (int i = 0; i < count; i++) { |
| ConstraintWidget widget = mChildren.get(i); |
| if (widget instanceof WidgetContainer) { |
| ((WidgetContainer) widget).layout(); |
| } |
| } |
| |
| // Now let's solve our system as usual |
| boolean needsSolving = true; |
| while (needsSolving) { |
| countSolve++; |
| try { |
| mSystem.reset(); |
| resetChains(); |
| if (DEBUG) { |
| setDebugSolverName(mSystem, getDebugName()); |
| for (int i = 0; i < count; i++) { |
| ConstraintWidget widget = mChildren.get(i); |
| if (widget.getDebugName() != null) { |
| widget.setDebugSolverName(mSystem, widget.getDebugName()); |
| } |
| } |
| } else { |
| createObjectVariables(mSystem); |
| for (int i = 0; i < count; i++) { |
| ConstraintWidget widget = mChildren.get(i); |
| widget.createObjectVariables(mSystem); |
| } |
| } |
| needsSolving = addChildrenToSolver(mSystem); |
| if (needsSolving) { |
| mSystem.minimize(); |
| } |
| } catch (Exception e) { |
| e.printStackTrace(); |
| System.out.println("EXCEPTION : " + e); |
| } |
| if (needsSolving) { |
| updateChildrenFromSolver(mSystem, Optimizer.flags); |
| } else { |
| updateFromSolver(mSystem); |
| for (int i = 0; i < count; i++) { |
| ConstraintWidget widget = mChildren.get(i); |
| if (widget.mListDimensionBehaviors[DIMENSION_HORIZONTAL] |
| == DimensionBehaviour.MATCH_CONSTRAINT |
| && widget.getWidth() < widget.getWrapWidth()) { |
| Optimizer.flags[Optimizer.FLAG_RECOMPUTE_BOUNDS] = true; |
| break; |
| } |
| if (widget.mListDimensionBehaviors[DIMENSION_VERTICAL] |
| == DimensionBehaviour.MATCH_CONSTRAINT |
| && widget.getHeight() < widget.getWrapHeight()) { |
| Optimizer.flags[Optimizer.FLAG_RECOMPUTE_BOUNDS] = true; |
| break; |
| } |
| } |
| } |
| needsSolving = false; |
| |
| if (hasWrapContent && countSolve < MAX_ITERATIONS |
| && Optimizer.flags[Optimizer.FLAG_RECOMPUTE_BOUNDS]) { |
| // let's get the new bounds |
| int maxX = 0; |
| int maxY = 0; |
| for (int i = 0; i < count; i++) { |
| ConstraintWidget widget = mChildren.get(i); |
| maxX = Math.max(maxX, widget.mX + widget.getWidth()); |
| maxY = Math.max(maxY, widget.mY + widget.getHeight()); |
| } |
| maxX = Math.max(mMinWidth, maxX); |
| maxY = Math.max(mMinHeight, maxY); |
| if (originalHorizontalDimensionBehaviour == WRAP_CONTENT) { |
| if (getWidth() < maxX) { |
| if (DEBUG_LAYOUT) { |
| System.out.println( |
| "layout override width from " + getWidth() + " vs " + maxX); |
| } |
| setWidth(maxX); |
| mListDimensionBehaviors[DIMENSION_HORIZONTAL] = WRAP_CONTENT; // force using the solver |
| wrap_override = true; |
| needsSolving = true; |
| } |
| } |
| if (originalVerticalDimensionBehaviour == WRAP_CONTENT) { |
| if (getHeight() < maxY) { |
| if (DEBUG_LAYOUT) { |
| System.out.println( |
| "layout override height from " + getHeight() + " vs " + maxY); |
| } |
| setHeight(maxY); |
| mListDimensionBehaviors[DIMENSION_VERTICAL] = WRAP_CONTENT; // force using the solver |
| wrap_override = true; |
| needsSolving = true; |
| } |
| } |
| } |
| if (true) { |
| int width = Math.max(mMinWidth, getWidth()); |
| if (width > getWidth()) { |
| if (DEBUG_LAYOUT) { |
| System.out.println( |
| "layout override 2, width from " + getWidth() + " vs " + width); |
| } |
| setWidth(width); |
| mListDimensionBehaviors[DIMENSION_HORIZONTAL] = DimensionBehaviour.FIXED; |
| wrap_override = true; |
| needsSolving = true; |
| } |
| int height = Math.max(mMinHeight, getHeight()); |
| if (height > getHeight()) { |
| if (DEBUG_LAYOUT) { |
| System.out.println( |
| "layout override 2, height from " + getHeight() + " vs " + height); |
| } |
| setHeight(height); |
| mListDimensionBehaviors[DIMENSION_VERTICAL] = DimensionBehaviour.FIXED; |
| wrap_override = true; |
| needsSolving = true; |
| } |
| |
| if (!wrap_override) { |
| if (mListDimensionBehaviors[DIMENSION_HORIZONTAL] == WRAP_CONTENT |
| && prew > 0) { |
| if (getWidth() > prew) { |
| if (DEBUG_LAYOUT) { |
| System.out.println( |
| "layout override 3, width from " + getWidth() + " vs " |
| + prew); |
| } |
| mWidthMeasuredTooSmall = true; |
| wrap_override = true; |
| mListDimensionBehaviors[DIMENSION_HORIZONTAL] = DimensionBehaviour.FIXED; |
| setWidth(prew); |
| needsSolving = true; |
| } |
| } |
| if (mListDimensionBehaviors[DIMENSION_VERTICAL] == WRAP_CONTENT |
| && preh > 0) { |
| if (getHeight() > preh) { |
| if (DEBUG_LAYOUT) { |
| System.out.println( |
| "layout override 3, height from " + getHeight() + " vs " |
| + preh); |
| } |
| mHeightMeasuredTooSmall = true; |
| wrap_override = true; |
| mListDimensionBehaviors[DIMENSION_VERTICAL] = DimensionBehaviour.FIXED; |
| setHeight(preh); |
| needsSolving = true; |
| } |
| } |
| } |
| } |
| } |
| if (DEBUG_LAYOUT) { |
| System.out.println( |
| "Solved system in " + countSolve + " iterations (" + getWidth() + " x " |
| + getHeight() + ")"); |
| } |
| // Update UnresolvedWidgets that did not need solver. |
| mWidgetGroups.get(groupIndex).updateUnresolvedWidgets(); |
| } |
| mChildren = (ArrayList<ConstraintWidget>)allChildren; |
| |
| if (mParent != null && USE_SNAPSHOT) { |
| int width = Math.max(mMinWidth, getWidth()); |
| int height = Math.max(mMinHeight, getHeight()); |
| // Let's restore our state... |
| mSnapshot.applyTo(this); |
| setWidth(width + mPaddingLeft + mPaddingRight); |
| setHeight(height + mPaddingTop + mPaddingBottom); |
| } else { |
| mX = prex; |
| mY = prey; |
| } |
| if (wrap_override) { |
| mListDimensionBehaviors[DIMENSION_HORIZONTAL] = originalHorizontalDimensionBehaviour; |
| mListDimensionBehaviors[DIMENSION_VERTICAL] = originalVerticalDimensionBehaviour; |
| } |
| |
| if (DEBUG_GRAPH) { |
| for (int i = 0; i < mChildren.size(); i++) { |
| ConstraintWidget widget = mChildren.get(i); |
| System.out.println( |
| "final child [" + i + "/" + mChildren.size() + "] - " + widget.mLeft |
| .getResolutionNode() |
| + ", " + widget.mTop.getResolutionNode() |
| + ", " + widget.mRight.getResolutionNode() |
| + ", " + widget.mBottom.getResolutionNode()); |
| } |
| } |
| |
| resetSolverVariables(mSystem.getCache()); |
| if (this == getRootConstraintContainer()) { |
| updateDrawPosition(); |
| } |
| } |
| |
| public void preOptimize() { |
| optimizeReset(); |
| analyze(mOptimizationLevel); |
| } |
| |
| public void solveGraph() { |
| ResolutionAnchor leftNode = getAnchor(ConstraintAnchor.Type.LEFT).getResolutionNode(); |
| ResolutionAnchor topNode = getAnchor(ConstraintAnchor.Type.TOP).getResolutionNode(); |
| |
| if (DEBUG_GRAPH) { |
| System.out.println("### RESOLUTION ###"); |
| } |
| |
| leftNode.resolve(null, 0); |
| topNode.resolve(null, 0); |
| } |
| |
| public void resetGraph() { |
| ResolutionAnchor leftNode = getAnchor(ConstraintAnchor.Type.LEFT).getResolutionNode(); |
| ResolutionAnchor topNode = getAnchor(ConstraintAnchor.Type.TOP).getResolutionNode(); |
| |
| if (DEBUG_GRAPH) { |
| System.out.println("### RESET ###"); |
| } |
| |
| leftNode.invalidateAnchors(); |
| topNode.invalidateAnchors(); |
| leftNode.resolve(null, 0); |
| topNode.resolve(null, 0); |
| } |
| |
| public void optimizeForDimensions(int width, int height) { |
| if (mListDimensionBehaviors[HORIZONTAL] != WRAP_CONTENT && mResolutionWidth != null) { |
| mResolutionWidth.resolve(width); |
| } |
| if (mListDimensionBehaviors[VERTICAL] != WRAP_CONTENT && mResolutionHeight != null) { |
| mResolutionHeight.resolve(height); |
| } |
| } |
| |
| public void optimizeReset() { |
| final int count = mChildren.size(); |
| resetResolutionNodes(); |
| for (int i = 0; i < count; i++) { |
| mChildren.get(i).resetResolutionNodes(); |
| } |
| } |
| |
| public void optimize() { |
| if (DEBUG_GRAPH) { |
| System.out.println("### Graph resolution... " + mWidth + " x " + mHeight + " ###"); |
| } |
| |
| if (DEBUG_GRAPH) { |
| System.out.println("### Update Constraints Graph ###"); |
| setDebugName("Root"); |
| } |
| |
| if (!optimizeFor(Optimizer.OPTIMIZATION_DIMENSIONS)) { |
| analyze(mOptimizationLevel); |
| } |
| |
| if (DEBUG_GRAPH) { |
| for (int i = 0; i < mChildren.size(); i++) { |
| ConstraintWidget widget = mChildren.get(i); |
| System.out.println("(pre) child [" + i + "/" + mChildren.size() + "] - " + widget.mLeft.getResolutionNode() |
| + ", " + widget.mTop.getResolutionNode() |
| + ", " + widget.mRight.getResolutionNode() |
| + ", " + widget.mBottom.getResolutionNode()); |
| } |
| } |
| solveGraph(); |
| if (DEBUG_GRAPH) { |
| for (int i = 0; i < mChildren.size(); i++) { |
| ConstraintWidget widget = mChildren.get(i); |
| System.out.println("child [" + i + "/" + mChildren.size() + "] - " + widget.mLeft.getResolutionNode() |
| + ", " + widget.mTop.getResolutionNode() |
| + ", " + widget.mRight.getResolutionNode() |
| + ", " + widget.mBottom.getResolutionNode()); |
| } |
| } |
| } |
| |
| /** |
| * Indicates if the container knows how to layout its content on its own |
| * |
| * @return true if the container does the layout, false otherwise |
| */ |
| public boolean handlesInternalConstraints() { |
| return false; |
| } |
| |
| /*-----------------------------------------------------------------------*/ |
| // Guidelines |
| /*-----------------------------------------------------------------------*/ |
| |
| /** |
| * Accessor to the vertical guidelines contained in the table. |
| * |
| * @return array of guidelines |
| */ |
| public ArrayList<Guideline> getVerticalGuidelines() { |
| ArrayList<Guideline> guidelines = new ArrayList<>(); |
| for (int i = 0, mChildrenSize = mChildren.size(); i < mChildrenSize; i++) { |
| final ConstraintWidget widget = mChildren.get(i); |
| if (widget instanceof Guideline) { |
| Guideline guideline = (Guideline) widget; |
| if (guideline.getOrientation() == Guideline.VERTICAL) { |
| guidelines.add(guideline); |
| } |
| } |
| } |
| return guidelines; |
| } |
| |
| /** |
| * Accessor to the horizontal guidelines contained in the table. |
| * |
| * @return array of guidelines |
| */ |
| public ArrayList<Guideline> getHorizontalGuidelines() { |
| ArrayList<Guideline> guidelines = new ArrayList<>(); |
| for (int i = 0, mChildrenSize = mChildren.size(); i < mChildrenSize; i++) { |
| final ConstraintWidget widget = mChildren.get(i); |
| if (widget instanceof Guideline) { |
| Guideline guideline = (Guideline) widget; |
| if (guideline.getOrientation() == Guideline.HORIZONTAL) { |
| guidelines.add(guideline); |
| } |
| } |
| } |
| return guidelines; |
| } |
| |
| public LinearSystem getSystem() { |
| return mSystem; |
| } |
| |
| /*-----------------------------------------------------------------------*/ |
| // Chains |
| /*-----------------------------------------------------------------------*/ |
| |
| /** |
| * Reset the chains array. Need to be called before layout. |
| */ |
| private void resetChains() { |
| mHorizontalChainsSize = 0; |
| mVerticalChainsSize = 0; |
| } |
| |
| /** |
| * Add the chain which constraintWidget is part of. Called by ConstraintWidget::addToSolver() |
| * |
| * @param constraintWidget |
| * @param type HORIZONTAL or VERTICAL chain |
| */ |
| void addChain(ConstraintWidget constraintWidget, int type) { |
| ConstraintWidget widget = constraintWidget; |
| if (type == HORIZONTAL) { |
| addHorizontalChain(widget); |
| } else if (type == VERTICAL) { |
| addVerticalChain(widget); |
| } |
| } |
| |
| /** |
| * Add a widget to the list of horizontal chains. The widget is the left-most widget |
| * of the chain which doesn't have a left dual connection. |
| * |
| * @param widget widget starting the chain |
| */ |
| private void addHorizontalChain(ConstraintWidget widget) { |
| if (mHorizontalChainsSize + 1 >= mHorizontalChainsArray.length) { |
| mHorizontalChainsArray = Arrays |
| .copyOf(mHorizontalChainsArray, mHorizontalChainsArray.length * 2); |
| } |
| mHorizontalChainsArray[mHorizontalChainsSize] = new ChainHead(widget, HORIZONTAL, isRtl()); |
| mHorizontalChainsSize++; |
| } |
| |
| /** |
| * Add a widget to the list of vertical chains. The widget is the top-most widget |
| * of the chain which doesn't have a top dual connection. |
| * |
| * @param widget widget starting the chain |
| */ |
| private void addVerticalChain(ConstraintWidget widget) { |
| if (mVerticalChainsSize + 1 >= mVerticalChainsArray.length) { |
| mVerticalChainsArray = Arrays |
| .copyOf(mVerticalChainsArray, mVerticalChainsArray.length * 2); |
| } |
| mVerticalChainsArray[mVerticalChainsSize] = new ChainHead(widget, VERTICAL, isRtl()); |
| mVerticalChainsSize++; |
| } |
| |
| /*-----------------------------------------------------------------------*/ |
| // Widgets |
| /*-----------------------------------------------------------------------*/ |
| |
| /** |
| * {@link #mWidgetGroups} getter. |
| * |
| * @return The list of independently constrained widget groups. |
| */ |
| public List<ConstraintWidgetGroup> getWidgetGroups() { |
| return mWidgetGroups; |
| } |
| } |
