| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php |
| * |
| * 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 com.android.ide.common.layout; |
| |
| import static com.android.SdkConstants.ANDROID_URI; |
| import static com.android.SdkConstants.ATTR_BASELINE_ALIGNED; |
| import static com.android.SdkConstants.ATTR_LAYOUT_GRAVITY; |
| import static com.android.SdkConstants.ATTR_LAYOUT_HEIGHT; |
| import static com.android.SdkConstants.ATTR_LAYOUT_WEIGHT; |
| import static com.android.SdkConstants.ATTR_LAYOUT_WIDTH; |
| import static com.android.SdkConstants.ATTR_ORIENTATION; |
| import static com.android.SdkConstants.ATTR_WEIGHT_SUM; |
| import static com.android.SdkConstants.VALUE_1; |
| import static com.android.SdkConstants.VALUE_HORIZONTAL; |
| import static com.android.SdkConstants.VALUE_VERTICAL; |
| import static com.android.SdkConstants.VALUE_WRAP_CONTENT; |
| import static com.android.SdkConstants.VALUE_ZERO_DP; |
| import static com.android.ide.eclipse.adt.AdtUtils.formatFloatAttribute; |
| |
| import com.android.SdkConstants; |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.common.api.DrawingStyle; |
| import com.android.ide.common.api.DropFeedback; |
| import com.android.ide.common.api.IClientRulesEngine; |
| import com.android.ide.common.api.IDragElement; |
| import com.android.ide.common.api.IFeedbackPainter; |
| import com.android.ide.common.api.IGraphics; |
| import com.android.ide.common.api.IMenuCallback; |
| import com.android.ide.common.api.INode; |
| import com.android.ide.common.api.INodeHandler; |
| import com.android.ide.common.api.IViewMetadata; |
| import com.android.ide.common.api.IViewMetadata.FillPreference; |
| import com.android.ide.common.api.IViewRule; |
| import com.android.ide.common.api.InsertType; |
| import com.android.ide.common.api.Point; |
| import com.android.ide.common.api.Rect; |
| import com.android.ide.common.api.RuleAction; |
| import com.android.ide.common.api.RuleAction.Choices; |
| import com.android.ide.common.api.SegmentType; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * An {@link IViewRule} for android.widget.LinearLayout and all its derived |
| * classes. |
| */ |
| public class LinearLayoutRule extends BaseLayoutRule { |
| private static final String ACTION_ORIENTATION = "_orientation"; //$NON-NLS-1$ |
| private static final String ACTION_WEIGHT = "_weight"; //$NON-NLS-1$ |
| private static final String ACTION_DISTRIBUTE = "_distribute"; //$NON-NLS-1$ |
| private static final String ACTION_BASELINE = "_baseline"; //$NON-NLS-1$ |
| private static final String ACTION_CLEAR = "_clear"; //$NON-NLS-1$ |
| private static final String ACTION_DOMINATE = "_dominate"; //$NON-NLS-1$ |
| |
| private static final URL ICON_HORIZONTAL = |
| LinearLayoutRule.class.getResource("hlinear.png"); //$NON-NLS-1$ |
| private static final URL ICON_VERTICAL = |
| LinearLayoutRule.class.getResource("vlinear.png"); //$NON-NLS-1$ |
| private static final URL ICON_WEIGHTS = |
| LinearLayoutRule.class.getResource("weights.png"); //$NON-NLS-1$ |
| private static final URL ICON_DISTRIBUTE = |
| LinearLayoutRule.class.getResource("distribute.png"); //$NON-NLS-1$ |
| private static final URL ICON_BASELINE = |
| LinearLayoutRule.class.getResource("baseline.png"); //$NON-NLS-1$ |
| private static final URL ICON_CLEAR_WEIGHTS = |
| LinearLayoutRule.class.getResource("clearweights.png"); //$NON-NLS-1$ |
| private static final URL ICON_DOMINATE = |
| LinearLayoutRule.class.getResource("allweight.png"); //$NON-NLS-1$ |
| |
| /** |
| * Returns the current orientation, regardless of whether it has been defined in XML |
| * |
| * @param node The LinearLayout to look up the orientation for |
| * @return "horizontal" or "vertical" depending on the current orientation of the |
| * linear layout |
| */ |
| private String getCurrentOrientation(final INode node) { |
| String orientation = node.getStringAttr(ANDROID_URI, ATTR_ORIENTATION); |
| if (orientation == null || orientation.length() == 0) { |
| orientation = VALUE_HORIZONTAL; |
| } |
| return orientation; |
| } |
| |
| /** |
| * Returns true if the given node represents a vertical linear layout. |
| * @param node the node to check layout orientation for |
| * @return true if the layout is in vertical mode, otherwise false |
| */ |
| protected boolean isVertical(INode node) { |
| // Horizontal is the default, so if no value is specified it is horizontal. |
| return VALUE_VERTICAL.equals(node.getStringAttr(ANDROID_URI, |
| ATTR_ORIENTATION)); |
| } |
| |
| /** |
| * Returns true if this LinearLayout supports switching orientation. |
| * |
| * @return true if this layout supports orientations |
| */ |
| protected boolean supportsOrientation() { |
| return true; |
| } |
| |
| @Override |
| public void addLayoutActions( |
| @NonNull List<RuleAction> actions, |
| final @NonNull INode parentNode, |
| final @NonNull List<? extends INode> children) { |
| super.addLayoutActions(actions, parentNode, children); |
| if (supportsOrientation()) { |
| Choices action = RuleAction.createChoices( |
| ACTION_ORIENTATION, "Orientation", //$NON-NLS-1$ |
| new PropertyCallback(Collections.singletonList(parentNode), |
| "Change LinearLayout Orientation", |
| ANDROID_URI, ATTR_ORIENTATION), |
| Arrays.<String>asList("Set Horizontal Orientation","Set Vertical Orientation"), |
| Arrays.<URL>asList(ICON_HORIZONTAL, ICON_VERTICAL), |
| Arrays.<String>asList("horizontal", "vertical"), |
| getCurrentOrientation(parentNode), |
| null /* icon */, |
| -10, |
| false /* supportsMultipleNodes */ |
| ); |
| action.setRadio(true); |
| actions.add(action); |
| } |
| if (!isVertical(parentNode)) { |
| String current = parentNode.getStringAttr(ANDROID_URI, ATTR_BASELINE_ALIGNED); |
| boolean isAligned = current == null || Boolean.valueOf(current); |
| actions.add(RuleAction.createToggle(ACTION_BASELINE, "Toggle Baseline Alignment", |
| isAligned, |
| new PropertyCallback(Collections.singletonList(parentNode), |
| "Change Baseline Alignment", |
| ANDROID_URI, ATTR_BASELINE_ALIGNED), // TODO: Also set index? |
| ICON_BASELINE, 38, false)); |
| } |
| |
| // Gravity |
| if (children != null && children.size() > 0) { |
| actions.add(RuleAction.createSeparator(35)); |
| |
| // Margins |
| actions.add(createMarginAction(parentNode, children)); |
| |
| // Gravity |
| actions.add(createGravityAction(children, ATTR_LAYOUT_GRAVITY)); |
| |
| // Weights |
| IMenuCallback actionCallback = new IMenuCallback() { |
| @Override |
| public void action( |
| final @NonNull RuleAction action, |
| @NonNull List<? extends INode> selectedNodes, |
| final @Nullable String valueId, |
| final @Nullable Boolean newValue) { |
| parentNode.editXml("Change Weight", new INodeHandler() { |
| @Override |
| public void handle(@NonNull INode n) { |
| String id = action.getId(); |
| if (id.equals(ACTION_WEIGHT)) { |
| String weight = |
| children.get(0).getStringAttr(ANDROID_URI, ATTR_LAYOUT_WEIGHT); |
| if (weight == null || weight.length() == 0) { |
| weight = "0.0"; //$NON-NLS-1$ |
| } |
| weight = mRulesEngine.displayInput("Enter Weight Value:", weight, |
| null); |
| if (weight != null) { |
| if (weight.isEmpty()) { |
| weight = null; // remove attribute |
| } |
| for (INode child : children) { |
| child.setAttribute(ANDROID_URI, |
| ATTR_LAYOUT_WEIGHT, weight); |
| } |
| } |
| } else if (id.equals(ACTION_DISTRIBUTE)) { |
| distributeWeights(parentNode, parentNode.getChildren()); |
| } else if (id.equals(ACTION_CLEAR)) { |
| clearWeights(parentNode); |
| } else if (id.equals(ACTION_CLEAR) || id.equals(ACTION_DOMINATE)) { |
| clearWeights(parentNode); |
| distributeWeights(parentNode, |
| children.toArray(new INode[children.size()])); |
| } else { |
| assert id.equals(ACTION_BASELINE); |
| } |
| } |
| }); |
| } |
| }; |
| actions.add(RuleAction.createSeparator(50)); |
| actions.add(RuleAction.createAction(ACTION_DISTRIBUTE, "Distribute Weights Evenly", |
| actionCallback, ICON_DISTRIBUTE, 60, false /*supportsMultipleNodes*/)); |
| actions.add(RuleAction.createAction(ACTION_DOMINATE, "Assign All Weight", |
| actionCallback, ICON_DOMINATE, 70, false)); |
| actions.add(RuleAction.createAction(ACTION_WEIGHT, "Change Layout Weight", |
| actionCallback, ICON_WEIGHTS, 80, false)); |
| actions.add(RuleAction.createAction(ACTION_CLEAR, "Clear All Weights", |
| actionCallback, ICON_CLEAR_WEIGHTS, 90, false)); |
| } |
| } |
| |
| private void distributeWeights(INode parentNode, INode[] targets) { |
| // Any XML to get weight sum? |
| String weightSum = parentNode.getStringAttr(ANDROID_URI, |
| ATTR_WEIGHT_SUM); |
| double sum = -1.0; |
| if (weightSum != null) { |
| // Distribute |
| try { |
| sum = Double.parseDouble(weightSum); |
| } catch (NumberFormatException nfe) { |
| // Just keep using the default |
| } |
| } |
| int numTargets = targets.length; |
| double share; |
| if (sum <= 0.0) { |
| // The sum will be computed from the children, so just |
| // use arbitrary amount |
| share = 1.0; |
| } else { |
| share = sum / numTargets; |
| } |
| String value = formatFloatAttribute((float) share); |
| String sizeAttribute = isVertical(parentNode) ? |
| ATTR_LAYOUT_HEIGHT : ATTR_LAYOUT_WIDTH; |
| for (INode target : targets) { |
| target.setAttribute(ANDROID_URI, ATTR_LAYOUT_WEIGHT, value); |
| // Also set the width/height to 0dp to ensure actual equal |
| // size (without this, only the remaining space is |
| // distributed) |
| if (VALUE_WRAP_CONTENT.equals(target.getStringAttr(ANDROID_URI, sizeAttribute))) { |
| target.setAttribute(ANDROID_URI, sizeAttribute, VALUE_ZERO_DP); |
| } |
| } |
| } |
| |
| private void clearWeights(INode parentNode) { |
| // Clear attributes |
| String sizeAttribute = isVertical(parentNode) |
| ? ATTR_LAYOUT_HEIGHT : ATTR_LAYOUT_WIDTH; |
| for (INode target : parentNode.getChildren()) { |
| target.setAttribute(ANDROID_URI, ATTR_LAYOUT_WEIGHT, null); |
| String size = target.getStringAttr(ANDROID_URI, sizeAttribute); |
| if (size != null && size.startsWith("0")) { //$NON-NLS-1$ |
| target.setAttribute(ANDROID_URI, sizeAttribute, VALUE_WRAP_CONTENT); |
| } |
| } |
| } |
| |
| // ==== Drag'n'drop support ==== |
| |
| @Override |
| public DropFeedback onDropEnter(final @NonNull INode targetNode, @Nullable Object targetView, |
| final @Nullable IDragElement[] elements) { |
| |
| if (elements.length == 0) { |
| return null; |
| } |
| |
| Rect bn = targetNode.getBounds(); |
| if (!bn.isValid()) { |
| return null; |
| } |
| |
| boolean isVertical = isVertical(targetNode); |
| |
| // Prepare a list of insertion points: X coords for horizontal, Y for |
| // vertical. |
| List<MatchPos> indexes = new ArrayList<MatchPos>(); |
| |
| int last = isVertical ? bn.y : bn.x; |
| int pos = 0; |
| boolean lastDragged = false; |
| int selfPos = -1; |
| for (INode it : targetNode.getChildren()) { |
| Rect bc = it.getBounds(); |
| if (bc.isValid()) { |
| // First see if this node looks like it's the same as one of the |
| // *dragged* bounds |
| boolean isDragged = false; |
| for (IDragElement element : elements) { |
| // This tries to determine if an INode corresponds to an |
| // IDragElement, by comparing their bounds. |
| if (element.isSame(it)) { |
| isDragged = true; |
| break; |
| } |
| } |
| |
| // We don't want to insert drag positions before or after the |
| // element that is itself being dragged. However, we -do- want |
| // to insert a match position here, at the center, such that |
| // when you drag near its current position we show a match right |
| // where it's already positioned. |
| if (isDragged) { |
| int v = isVertical ? bc.y + (bc.h / 2) : bc.x + (bc.w / 2); |
| selfPos = pos; |
| indexes.add(new MatchPos(v, pos++)); |
| } else if (lastDragged) { |
| // Even though we don't want to insert a match below, we |
| // need to increment the index counter such that subsequent |
| // lines know their correct index in the child list. |
| pos++; |
| } else { |
| // Add an insertion point between the last point and the |
| // start of this child |
| int v = isVertical ? bc.y : bc.x; |
| v = (last + v) / 2; |
| indexes.add(new MatchPos(v, pos++)); |
| } |
| |
| last = isVertical ? (bc.y + bc.h) : (bc.x + bc.w); |
| lastDragged = isDragged; |
| } else { |
| // We still have to count this position even if it has no bounds, or |
| // subsequent children will be inserted at the wrong place |
| pos++; |
| } |
| } |
| |
| // Finally add an insert position after all the children - unless of |
| // course we happened to be dragging the last element |
| if (!lastDragged) { |
| int v = last + 1; |
| indexes.add(new MatchPos(v, pos)); |
| } |
| |
| int posCount = targetNode.getChildren().length + 1; |
| return new DropFeedback(new LinearDropData(indexes, posCount, isVertical, selfPos), |
| new IFeedbackPainter() { |
| |
| @Override |
| public void paint(@NonNull IGraphics gc, @NonNull INode node, |
| @NonNull DropFeedback feedback) { |
| // Paint callback for the LinearLayout. This is called |
| // by the canvas when a draw is needed. |
| drawFeedback(gc, node, elements, feedback); |
| } |
| }); |
| } |
| |
| void drawFeedback(IGraphics gc, INode node, IDragElement[] elements, DropFeedback feedback) { |
| Rect b = node.getBounds(); |
| if (!b.isValid()) { |
| return; |
| } |
| |
| // Highlight the receiver |
| gc.useStyle(DrawingStyle.DROP_RECIPIENT); |
| gc.drawRect(b); |
| |
| gc.useStyle(DrawingStyle.DROP_ZONE); |
| |
| LinearDropData data = (LinearDropData) feedback.userData; |
| boolean isVertical = data.isVertical(); |
| int selfPos = data.getSelfPos(); |
| |
| for (MatchPos it : data.getIndexes()) { |
| int i = it.getDistance(); |
| int pos = it.getPosition(); |
| // Don't show insert drop zones for "self"-index since that one goes |
| // right through the center of the widget rather than in a sibling |
| // position |
| if (pos != selfPos) { |
| if (isVertical) { |
| // draw horizontal lines |
| gc.drawLine(b.x, i, b.x + b.w, i); |
| } else { |
| // draw vertical lines |
| gc.drawLine(i, b.y, i, b.y + b.h); |
| } |
| } |
| } |
| |
| Integer currX = data.getCurrX(); |
| Integer currY = data.getCurrY(); |
| |
| if (currX != null && currY != null) { |
| gc.useStyle(DrawingStyle.DROP_ZONE_ACTIVE); |
| |
| int x = currX; |
| int y = currY; |
| |
| Rect be = elements[0].getBounds(); |
| |
| // Draw a clear line at the closest drop zone (unless we're over the |
| // dragged element itself) |
| if (data.getInsertPos() != selfPos || selfPos == -1) { |
| gc.useStyle(DrawingStyle.DROP_PREVIEW); |
| if (data.getWidth() != null) { |
| int width = data.getWidth(); |
| int fromX = x - width / 2; |
| int toX = x + width / 2; |
| gc.drawLine(fromX, y, toX, y); |
| } else if (data.getHeight() != null) { |
| int height = data.getHeight(); |
| int fromY = y - height / 2; |
| int toY = y + height / 2; |
| gc.drawLine(x, fromY, x, toY); |
| } |
| } |
| |
| if (be.isValid()) { |
| boolean isLast = data.isLastPosition(); |
| |
| // At least the first element has a bound. Draw rectangles for |
| // all dropped elements with valid bounds, offset at the drop |
| // point. |
| int offsetX; |
| int offsetY; |
| if (isVertical) { |
| offsetX = b.x - be.x; |
| offsetY = currY - be.y - (isLast ? 0 : (be.h / 2)); |
| |
| } else { |
| offsetX = currX - be.x - (isLast ? 0 : (be.w / 2)); |
| offsetY = b.y - be.y; |
| } |
| |
| gc.useStyle(DrawingStyle.DROP_PREVIEW); |
| for (IDragElement element : elements) { |
| Rect bounds = element.getBounds(); |
| if (bounds.isValid() && (bounds.w > b.w || bounds.h > b.h) && |
| node.getChildren().length == 0) { |
| // The bounds of the child does not fully fit inside the target. |
| // Limit the bounds to the layout bounds (but only when there |
| // are no children, since otherwise positioning around the existing |
| // children gets difficult) |
| final int px, py, pw, ph; |
| if (bounds.w > b.w) { |
| px = b.x; |
| pw = b.w; |
| } else { |
| px = bounds.x + offsetX; |
| pw = bounds.w; |
| } |
| if (bounds.h > b.h) { |
| py = b.y; |
| ph = b.h; |
| } else { |
| py = bounds.y + offsetY; |
| ph = bounds.h; |
| } |
| Rect within = new Rect(px, py, pw, ph); |
| gc.drawRect(within); |
| } else { |
| drawElement(gc, element, offsetX, offsetY); |
| } |
| } |
| } |
| } |
| } |
| |
| @Override |
| public DropFeedback onDropMove(@NonNull INode targetNode, @NonNull IDragElement[] elements, |
| @Nullable DropFeedback feedback, @NonNull Point p) { |
| Rect b = targetNode.getBounds(); |
| if (!b.isValid()) { |
| return feedback; |
| } |
| |
| LinearDropData data = (LinearDropData) feedback.userData; |
| boolean isVertical = data.isVertical(); |
| |
| int bestDist = Integer.MAX_VALUE; |
| int bestIndex = Integer.MIN_VALUE; |
| Integer bestPos = null; |
| |
| for (MatchPos index : data.getIndexes()) { |
| int i = index.getDistance(); |
| int pos = index.getPosition(); |
| int dist = (isVertical ? p.y : p.x) - i; |
| if (dist < 0) |
| dist = -dist; |
| if (dist < bestDist) { |
| bestDist = dist; |
| bestIndex = i; |
| bestPos = pos; |
| if (bestDist <= 0) |
| break; |
| } |
| } |
| |
| if (bestIndex != Integer.MIN_VALUE) { |
| Integer oldX = data.getCurrX(); |
| Integer oldY = data.getCurrY(); |
| |
| if (isVertical) { |
| data.setCurrX(b.x + b.w / 2); |
| data.setCurrY(bestIndex); |
| data.setWidth(b.w); |
| data.setHeight(null); |
| } else { |
| data.setCurrX(bestIndex); |
| data.setCurrY(b.y + b.h / 2); |
| data.setWidth(null); |
| data.setHeight(b.h); |
| } |
| |
| data.setInsertPos(bestPos); |
| |
| feedback.requestPaint = !equals(oldX, data.getCurrX()) |
| || !equals(oldY, data.getCurrY()); |
| } |
| |
| return feedback; |
| } |
| |
| private static boolean equals(Integer i1, Integer i2) { |
| if (i1 == i2) { |
| return true; |
| } else if (i1 != null) { |
| return i1.equals(i2); |
| } else { |
| // We know i2 != null |
| return i2.equals(i1); |
| } |
| } |
| |
| @Override |
| public void onDropLeave(@NonNull INode targetNode, @NonNull IDragElement[] elements, |
| @Nullable DropFeedback feedback) { |
| // ignore |
| } |
| |
| @Override |
| public void onDropped(final @NonNull INode targetNode, final @NonNull IDragElement[] elements, |
| final @Nullable DropFeedback feedback, final @NonNull Point p) { |
| |
| LinearDropData data = (LinearDropData) feedback.userData; |
| final int initialInsertPos = data.getInsertPos(); |
| insertAt(targetNode, elements, feedback.isCopy || !feedback.sameCanvas, initialInsertPos); |
| } |
| |
| @Override |
| public void onChildInserted(@NonNull INode node, @NonNull INode parent, |
| @NonNull InsertType insertType) { |
| if (insertType == InsertType.MOVE_WITHIN) { |
| // Don't adjust widths/heights/weights when just moving within a single |
| // LinearLayout |
| return; |
| } |
| |
| // Attempt to set fill-properties on newly added views such that for example, |
| // in a vertical layout, a text field defaults to filling horizontally, but not |
| // vertically. |
| String fqcn = node.getFqcn(); |
| IViewMetadata metadata = mRulesEngine.getMetadata(fqcn); |
| if (metadata != null) { |
| boolean vertical = isVertical(parent); |
| FillPreference fill = metadata.getFillPreference(); |
| String fillParent = getFillParentValueName(); |
| if (fill.fillHorizontally(vertical)) { |
| node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, fillParent); |
| } else if (!vertical && fill == FillPreference.WIDTH_IN_VERTICAL) { |
| // In a horizontal layout, make views that would fill horizontally in a |
| // vertical layout have a non-zero weight instead. This will make the item |
| // fill but only enough to allow other views to be shown as well. |
| // (However, for drags within the same layout we do not touch |
| // the weight, since it might already have been tweaked to a particular |
| // value) |
| node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WEIGHT, VALUE_1); |
| } |
| if (fill.fillVertically(vertical)) { |
| node.setAttribute(ANDROID_URI, ATTR_LAYOUT_HEIGHT, fillParent); |
| } |
| } |
| |
| // If you insert into a layout that already is using layout weights, |
| // and all the layout weights are the same (nonzero) value, then use |
| // the same weight for this new layout as well. Also duplicate the 0dip/0px/0dp |
| // sizes, if used. |
| boolean duplicateWeight = true; |
| boolean duplicate0dip = true; |
| String sameWeight = null; |
| String sizeAttribute = isVertical(parent) ? ATTR_LAYOUT_HEIGHT : ATTR_LAYOUT_WIDTH; |
| for (INode target : parent.getChildren()) { |
| if (target == node) { |
| continue; |
| } |
| String weight = target.getStringAttr(ANDROID_URI, ATTR_LAYOUT_WEIGHT); |
| if (weight == null || weight.length() == 0) { |
| duplicateWeight = false; |
| break; |
| } else if (sameWeight != null && !sameWeight.equals(weight)) { |
| duplicateWeight = false; |
| } else { |
| sameWeight = weight; |
| } |
| String size = target.getStringAttr(ANDROID_URI, sizeAttribute); |
| if (size != null && !size.startsWith("0")) { //$NON-NLS-1$ |
| duplicate0dip = false; |
| break; |
| } |
| } |
| if (duplicateWeight && sameWeight != null) { |
| node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WEIGHT, sameWeight); |
| if (duplicate0dip) { |
| node.setAttribute(ANDROID_URI, sizeAttribute, VALUE_ZERO_DP); |
| } |
| } |
| } |
| |
| /** A possible match position */ |
| private static class MatchPos { |
| /** The pixel distance */ |
| private int mDistance; |
| /** The position among siblings */ |
| private int mPosition; |
| |
| public MatchPos(int distance, int position) { |
| mDistance = distance; |
| mPosition = position; |
| } |
| |
| @Override |
| public String toString() { |
| return "MatchPos [distance=" + mDistance //$NON-NLS-1$ |
| + ", position=" + mPosition //$NON-NLS-1$ |
| + "]"; //$NON-NLS-1$ |
| } |
| |
| private int getDistance() { |
| return mDistance; |
| } |
| |
| private int getPosition() { |
| return mPosition; |
| } |
| } |
| |
| private static class LinearDropData { |
| /** Vertical layout? */ |
| private final boolean mVertical; |
| |
| /** Insert points (pixels + index) */ |
| private final List<MatchPos> mIndexes; |
| |
| /** Number of insert positions in the target node */ |
| private final int mNumPositions; |
| |
| /** Current marker X position */ |
| private Integer mCurrX; |
| |
| /** Current marker Y position */ |
| private Integer mCurrY; |
| |
| /** Position of the dragged element in this layout (or |
| -1 if the dragged element is from elsewhere) */ |
| private final int mSelfPos; |
| |
| /** Current drop insert index (-1 for "at the end") */ |
| private int mInsertPos = -1; |
| |
| /** width of match line if it's a horizontal one */ |
| private Integer mWidth; |
| |
| /** height of match line if it's a vertical one */ |
| private Integer mHeight; |
| |
| public LinearDropData(List<MatchPos> indexes, int numPositions, |
| boolean isVertical, int selfPos) { |
| mIndexes = indexes; |
| mNumPositions = numPositions; |
| mVertical = isVertical; |
| mSelfPos = selfPos; |
| } |
| |
| @Override |
| public String toString() { |
| return "LinearDropData [currX=" + mCurrX //$NON-NLS-1$ |
| + ", currY=" + mCurrY //$NON-NLS-1$ |
| + ", height=" + mHeight //$NON-NLS-1$ |
| + ", indexes=" + mIndexes //$NON-NLS-1$ |
| + ", insertPos=" + mInsertPos //$NON-NLS-1$ |
| + ", isVertical=" + mVertical //$NON-NLS-1$ |
| + ", selfPos=" + mSelfPos //$NON-NLS-1$ |
| + ", width=" + mWidth //$NON-NLS-1$ |
| + "]"; //$NON-NLS-1$ |
| } |
| |
| private boolean isVertical() { |
| return mVertical; |
| } |
| |
| private void setCurrX(Integer currX) { |
| mCurrX = currX; |
| } |
| |
| private Integer getCurrX() { |
| return mCurrX; |
| } |
| |
| private void setCurrY(Integer currY) { |
| mCurrY = currY; |
| } |
| |
| private Integer getCurrY() { |
| return mCurrY; |
| } |
| |
| private int getSelfPos() { |
| return mSelfPos; |
| } |
| |
| private void setInsertPos(int insertPos) { |
| mInsertPos = insertPos; |
| } |
| |
| private int getInsertPos() { |
| return mInsertPos; |
| } |
| |
| private List<MatchPos> getIndexes() { |
| return mIndexes; |
| } |
| |
| private void setWidth(Integer width) { |
| mWidth = width; |
| } |
| |
| private Integer getWidth() { |
| return mWidth; |
| } |
| |
| private void setHeight(Integer height) { |
| mHeight = height; |
| } |
| |
| private Integer getHeight() { |
| return mHeight; |
| } |
| |
| /** |
| * Returns true if we are inserting into the last position |
| * |
| * @return true if we are inserting into the last position |
| */ |
| public boolean isLastPosition() { |
| return mInsertPos == mNumPositions - 1; |
| } |
| } |
| |
| /** Custom resize state used during linear layout resizing */ |
| private class LinearResizeState extends ResizeState { |
| /** Whether the node should be assigned a new weight */ |
| public boolean useWeight; |
| /** Weight sum to be applied to the parent */ |
| private float mNewWeightSum; |
| /** The weight to be set on the node (provided {@link #useWeight} is true) */ |
| private float mWeight; |
| /** Map from nodes to preferred bounds of nodes where the weights have been cleared */ |
| public final Map<INode, Rect> unweightedSizes; |
| /** Total required size required by the siblings <b>without</b> weights */ |
| public int totalLength; |
| /** List of nodes which should have their weights cleared */ |
| public List<INode> mClearWeights; |
| |
| private LinearResizeState(BaseLayoutRule rule, INode layout, Object layoutView, |
| INode node) { |
| super(rule, layout, layoutView, node); |
| |
| unweightedSizes = mRulesEngine.measureChildren(layout, |
| new IClientRulesEngine.AttributeFilter() { |
| @Override |
| public String getAttribute(@NonNull INode n, @Nullable String namespace, |
| @NonNull String localName) { |
| // Clear out layout weights; we need to measure the unweighted sizes |
| // of the children |
| if (ATTR_LAYOUT_WEIGHT.equals(localName) |
| && SdkConstants.NS_RESOURCES.equals(namespace)) { |
| return ""; //$NON-NLS-1$ |
| } |
| |
| return null; |
| } |
| }); |
| |
| // Compute total required size required by the siblings *without* weights |
| totalLength = 0; |
| final boolean isVertical = isVertical(layout); |
| for (Map.Entry<INode, Rect> entry : unweightedSizes.entrySet()) { |
| Rect preferredSize = entry.getValue(); |
| if (isVertical) { |
| totalLength += preferredSize.h; |
| } else { |
| totalLength += preferredSize.w; |
| } |
| } |
| } |
| |
| /** Resets the computed state */ |
| void reset() { |
| mNewWeightSum = -1; |
| useWeight = false; |
| mClearWeights = null; |
| } |
| |
| /** Sets a weight to be applied to the node */ |
| void setWeight(float weight) { |
| useWeight = true; |
| mWeight = weight; |
| } |
| |
| /** Sets a weight sum to be applied to the parent layout */ |
| void setWeightSum(float weightSum) { |
| mNewWeightSum = weightSum; |
| } |
| |
| /** Marks that the given node should be cleared when applying the new size */ |
| void clearWeight(INode n) { |
| if (mClearWeights == null) { |
| mClearWeights = new ArrayList<INode>(); |
| } |
| mClearWeights.add(n); |
| } |
| |
| /** Applies the state to the nodes */ |
| public void apply() { |
| assert useWeight; |
| |
| String value = mWeight > 0 ? formatFloatAttribute(mWeight) : null; |
| node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WEIGHT, value); |
| |
| if (mClearWeights != null) { |
| for (INode n : mClearWeights) { |
| if (getWeight(n) > 0.0f) { |
| n.setAttribute(ANDROID_URI, ATTR_LAYOUT_WEIGHT, null); |
| } |
| } |
| } |
| |
| if (mNewWeightSum > 0.0) { |
| layout.setAttribute(ANDROID_URI, ATTR_WEIGHT_SUM, |
| formatFloatAttribute(mNewWeightSum)); |
| } |
| } |
| } |
| |
| @Override |
| protected ResizeState createResizeState(INode layout, Object layoutView, INode node) { |
| return new LinearResizeState(this, layout, layoutView, node); |
| } |
| |
| protected void updateResizeState(LinearResizeState resizeState, final INode node, INode layout, |
| Rect oldBounds, Rect newBounds, SegmentType horizontalEdge, |
| SegmentType verticalEdge) { |
| // Update the resize state. |
| // This method attempts to compute a new layout weight to be used in the direction |
| // of the linear layout. If the superclass has already determined that we can snap to |
| // a wrap_content or match_parent boundary, we prefer that. Otherwise, we attempt to |
| // compute a layout weight - which can fail if the size is too big (not enough room), |
| // or if the size is too small (smaller than the natural width of the node), and so on. |
| // In that case this method just aborts, which will leave the resize state object |
| // in such a state that it will call the superclass to resize instead, which will fall |
| // back to device independent pixel sizing. |
| resizeState.reset(); |
| |
| if (oldBounds.equals(newBounds)) { |
| return; |
| } |
| |
| // If we're setting the width/height to wrap_content/match_parent in the dimension of the |
| // linear layout, then just apply wrap_content and clear weights. |
| boolean isVertical = isVertical(layout); |
| if (!isVertical && verticalEdge != null) { |
| if (resizeState.wrapWidth || resizeState.fillWidth) { |
| resizeState.clearWeight(node); |
| return; |
| } |
| if (newBounds.w == oldBounds.w) { |
| return; |
| } |
| } |
| |
| if (isVertical && horizontalEdge != null) { |
| if (resizeState.wrapHeight || resizeState.fillHeight) { |
| resizeState.clearWeight(node); |
| return; |
| } |
| if (newBounds.h == oldBounds.h) { |
| return; |
| } |
| } |
| |
| // Compute weight sum |
| float sum = getWeightSum(layout); |
| if (sum <= 0.0f) { |
| sum = 1.0f; |
| resizeState.setWeightSum(sum); |
| } |
| |
| // If the new size of the node is smaller than its preferred/wrap_content size, |
| // then we cannot use weights to size it; switch to pixel-based sizing instead |
| Map<INode, Rect> sizes = resizeState.unweightedSizes; |
| Rect nodePreferredSize = sizes.get(node); |
| if (nodePreferredSize != null) { |
| if (horizontalEdge != null && newBounds.h < nodePreferredSize.h || |
| verticalEdge != null && newBounds.w < nodePreferredSize.w) { |
| return; |
| } |
| } |
| |
| Rect layoutBounds = layout.getBounds(); |
| int remaining = (isVertical ? layoutBounds.h : layoutBounds.w) - resizeState.totalLength; |
| Rect nodeBounds = sizes.get(node); |
| if (nodeBounds == null) { |
| return; |
| } |
| |
| if (remaining > 0) { |
| int missing = 0; |
| if (isVertical) { |
| if (newBounds.h > nodeBounds.h) { |
| missing = newBounds.h - nodeBounds.h; |
| } else if (newBounds.h > resizeState.wrapBounds.h) { |
| // The weights concern how much space to ADD to the view. |
| // What if we have resized it to a size *smaller* than its current |
| // size without the weight delta? This can happen if you for example |
| // have set a hardcoded size, such as 500dp, and then size it to some |
| // smaller size. |
| missing = newBounds.h - resizeState.wrapBounds.h; |
| remaining += nodeBounds.h - resizeState.wrapBounds.h; |
| resizeState.wrapHeight = true; |
| } |
| } else { |
| if (newBounds.w > nodeBounds.w) { |
| missing = newBounds.w - nodeBounds.w; |
| } else if (newBounds.w > resizeState.wrapBounds.w) { |
| missing = newBounds.w - resizeState.wrapBounds.w; |
| remaining += nodeBounds.w - resizeState.wrapBounds.w; |
| resizeState.wrapWidth = true; |
| } |
| } |
| if (missing > 0) { |
| // (weight / weightSum) * remaining = missing, so |
| // weight = missing * weightSum / remaining |
| float weight = missing * sum / remaining; |
| resizeState.setWeight(weight); |
| } |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| * <p> |
| * Overridden in this layout in order to make resizing affect the layout_weight |
| * attribute instead of the layout_width (for horizontal LinearLayouts) or |
| * layout_height (for vertical LinearLayouts). |
| */ |
| @Override |
| protected void setNewSizeBounds(ResizeState state, final INode node, INode layout, |
| Rect oldBounds, Rect newBounds, SegmentType horizontalEdge, |
| SegmentType verticalEdge) { |
| LinearResizeState resizeState = (LinearResizeState) state; |
| updateResizeState(resizeState, node, layout, oldBounds, newBounds, |
| horizontalEdge, verticalEdge); |
| |
| if (resizeState.useWeight) { |
| resizeState.apply(); |
| |
| // Handle resizing in the opposite dimension of the layout |
| final boolean isVertical = isVertical(layout); |
| if (!isVertical && horizontalEdge != null) { |
| if (newBounds.h != oldBounds.h || resizeState.wrapHeight |
| || resizeState.fillHeight) { |
| node.setAttribute(ANDROID_URI, ATTR_LAYOUT_HEIGHT, |
| resizeState.getHeightAttribute()); |
| } |
| } |
| if (isVertical && verticalEdge != null) { |
| if (newBounds.w != oldBounds.w || resizeState.wrapWidth || resizeState.fillWidth) { |
| node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, |
| resizeState.getWidthAttribute()); |
| } |
| } |
| } else { |
| node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WEIGHT, null); |
| super.setNewSizeBounds(resizeState, node, layout, oldBounds, newBounds, |
| horizontalEdge, verticalEdge); |
| } |
| } |
| |
| @Override |
| protected String getResizeUpdateMessage(ResizeState state, INode child, INode parent, |
| Rect newBounds, SegmentType horizontalEdge, SegmentType verticalEdge) { |
| LinearResizeState resizeState = (LinearResizeState) state; |
| updateResizeState(resizeState, child, parent, child.getBounds(), newBounds, |
| horizontalEdge, verticalEdge); |
| |
| if (resizeState.useWeight) { |
| String weight = formatFloatAttribute(resizeState.mWeight); |
| String dimension = String.format("weight %1$s", weight); |
| |
| String width; |
| String height; |
| if (isVertical(parent)) { |
| width = resizeState.getWidthAttribute(); |
| height = dimension; |
| } else { |
| width = dimension; |
| height = resizeState.getHeightAttribute(); |
| } |
| |
| if (horizontalEdge == null) { |
| return width; |
| } else if (verticalEdge == null) { |
| return height; |
| } else { |
| // U+00D7: Unicode for multiplication sign |
| return String.format("%s \u00D7 %s", width, height); |
| } |
| } else { |
| return super.getResizeUpdateMessage(state, child, parent, newBounds, |
| horizontalEdge, verticalEdge); |
| } |
| } |
| |
| /** |
| * Returns the layout weight of of the given child of a LinearLayout, or 0.0 if it |
| * does not define a weight |
| */ |
| private static float getWeight(INode linearLayoutChild) { |
| String weight = linearLayoutChild.getStringAttr(ANDROID_URI, ATTR_LAYOUT_WEIGHT); |
| if (weight != null && weight.length() > 0) { |
| try { |
| return Float.parseFloat(weight); |
| } catch (NumberFormatException nfe) { |
| AdtPlugin.log(nfe, "Invalid weight %1$s", weight); |
| } |
| } |
| |
| return 0.0f; |
| } |
| |
| /** |
| * Returns the sum of all the layout weights of the children in the given LinearLayout |
| * |
| * @param linearLayout the layout to compute the total sum for |
| * @return the total sum of all the layout weights in the given layout |
| */ |
| private static float getWeightSum(INode linearLayout) { |
| String weightSum = linearLayout.getStringAttr(ANDROID_URI, |
| ATTR_WEIGHT_SUM); |
| float sum = -1.0f; |
| if (weightSum != null) { |
| // Distribute |
| try { |
| sum = Float.parseFloat(weightSum); |
| return sum; |
| } catch (NumberFormatException nfe) { |
| // Just keep using the default |
| } |
| } |
| |
| return getSumOfWeights(linearLayout); |
| } |
| |
| private static float getSumOfWeights(INode linearLayout) { |
| float sum = 0.0f; |
| for (INode child : linearLayout.getChildren()) { |
| sum += getWeight(child); |
| } |
| |
| return sum; |
| } |
| } |
