/*
* 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_ID;
import static com.android.SdkConstants.ATTR_LAYOUT_ABOVE;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_BASELINE;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_BOTTOM;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_LEFT;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_PARENT_BOTTOM;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_PARENT_LEFT;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_PARENT_RIGHT;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_PARENT_TOP;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_RIGHT;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_TOP;
import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_WITH_PARENT_MISSING;
import static com.android.SdkConstants.ATTR_LAYOUT_BELOW;
import static com.android.SdkConstants.ATTR_LAYOUT_CENTER_HORIZONTAL;
import static com.android.SdkConstants.ATTR_LAYOUT_CENTER_IN_PARENT;
import static com.android.SdkConstants.ATTR_LAYOUT_CENTER_VERTICAL;
import static com.android.SdkConstants.ATTR_LAYOUT_COLUMN;
import static com.android.SdkConstants.ATTR_LAYOUT_COLUMN_SPAN;
import static com.android.SdkConstants.ATTR_LAYOUT_GRAVITY;
import static com.android.SdkConstants.ATTR_LAYOUT_HEIGHT;
import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN;
import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN_BOTTOM;
import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN_LEFT;
import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN_RIGHT;
import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN_TOP;
import static com.android.SdkConstants.ATTR_LAYOUT_ROW;
import static com.android.SdkConstants.ATTR_LAYOUT_ROW_SPAN;
import static com.android.SdkConstants.ATTR_LAYOUT_TO_LEFT_OF;
import static com.android.SdkConstants.ATTR_LAYOUT_TO_RIGHT_OF;
import static com.android.SdkConstants.ATTR_LAYOUT_WIDTH;
import static com.android.SdkConstants.ATTR_LAYOUT_X;
import static com.android.SdkConstants.ATTR_LAYOUT_Y;
import static com.android.SdkConstants.VALUE_FILL_PARENT;
import static com.android.SdkConstants.VALUE_MATCH_PARENT;
import static com.android.SdkConstants.VALUE_WRAP_CONTENT;
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.IAttributeInfo;
import com.android.ide.common.api.IClientRulesEngine;
import com.android.ide.common.api.IDragElement;
import com.android.ide.common.api.IDragElement.IDragAttribute;
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.IViewRule;
import com.android.ide.common.api.MarginType;
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.ChoiceProvider;
import com.android.ide.common.api.Segment;
import com.android.ide.common.api.SegmentType;
import com.android.utils.Pair;
import java.net.URL;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* A {@link IViewRule} for all layouts.
*/
public class BaseLayoutRule extends BaseViewRule {
private static final String ACTION_FILL_WIDTH = "_fillW"; //$NON-NLS-1$
private static final String ACTION_FILL_HEIGHT = "_fillH"; //$NON-NLS-1$
private static final String ACTION_MARGIN = "_margin"; //$NON-NLS-1$
private static final URL ICON_MARGINS =
BaseLayoutRule.class.getResource("margins.png"); //$NON-NLS-1$
private static final URL ICON_GRAVITY =
BaseLayoutRule.class.getResource("gravity.png"); //$NON-NLS-1$
private static final URL ICON_FILL_WIDTH =
BaseLayoutRule.class.getResource("fillwidth.png"); //$NON-NLS-1$
private static final URL ICON_FILL_HEIGHT =
BaseLayoutRule.class.getResource("fillheight.png"); //$NON-NLS-1$
// ==== Layout Actions support ====
// The Margin layout parameters are available for LinearLayout, FrameLayout, RelativeLayout,
// and their subclasses.
protected final RuleAction createMarginAction(final INode parentNode,
final List<? extends INode> children) {
final List<? extends INode> targets = children == null || children.size() == 0 ?
Collections.singletonList(parentNode)
: children;
final INode first = targets.get(0);
IMenuCallback actionCallback = new IMenuCallback() {
@Override
public void action(@NonNull RuleAction action,
@NonNull List<? extends INode> selectedNodes,
final @Nullable String valueId,
final @Nullable Boolean newValue) {
parentNode.editXml("Change Margins", new INodeHandler() {
@Override
public void handle(@NonNull INode n) {
String uri = ANDROID_URI;
String all = first.getStringAttr(uri, ATTR_LAYOUT_MARGIN);
String left = first.getStringAttr(uri, ATTR_LAYOUT_MARGIN_LEFT);
String right = first.getStringAttr(uri, ATTR_LAYOUT_MARGIN_RIGHT);
String top = first.getStringAttr(uri, ATTR_LAYOUT_MARGIN_TOP);
String bottom = first.getStringAttr(uri, ATTR_LAYOUT_MARGIN_BOTTOM);
String[] margins = mRulesEngine.displayMarginInput(all, left,
right, top, bottom);
if (margins != null) {
assert margins.length == 5;
for (INode child : targets) {
child.setAttribute(uri, ATTR_LAYOUT_MARGIN, margins[0]);
child.setAttribute(uri, ATTR_LAYOUT_MARGIN_LEFT, margins[1]);
child.setAttribute(uri, ATTR_LAYOUT_MARGIN_RIGHT, margins[2]);
child.setAttribute(uri, ATTR_LAYOUT_MARGIN_TOP, margins[3]);
child.setAttribute(uri, ATTR_LAYOUT_MARGIN_BOTTOM, margins[4]);
}
}
}
});
}
};
return RuleAction.createAction(ACTION_MARGIN, "Change Margins...", actionCallback,
ICON_MARGINS, 40, false);
}
// Both LinearLayout and RelativeLayout have a gravity (but RelativeLayout applies it
// to the parent whereas for LinearLayout it's on the children)
protected final RuleAction createGravityAction(final List<? extends INode> targets, final
String attributeName) {
if (targets != null && targets.size() > 0) {
final INode first = targets.get(0);
ChoiceProvider provider = new ChoiceProvider() {
@Override
public void addChoices(@NonNull List<String> titles, @NonNull List<URL> iconUrls,
@NonNull List<String> ids) {
IAttributeInfo info = first.getAttributeInfo(ANDROID_URI, attributeName);
if (info != null) {
// Generate list of possible gravity value constants
assert info.getFormats().contains(IAttributeInfo.Format.FLAG);
for (String name : info.getFlagValues()) {
titles.add(getAttributeDisplayName(name));
ids.add(name);
}
}
}
};
return RuleAction.createChoices("_gravity", "Change Gravity", //$NON-NLS-1$
new PropertyCallback(targets, "Change Gravity", ANDROID_URI,
attributeName),
provider,
first.getStringAttr(ANDROID_URI, attributeName), ICON_GRAVITY,
43, false);
}
return null;
}
@Override
public void addLayoutActions(
@NonNull List<RuleAction> actions,
final @NonNull INode parentNode,
final @NonNull List<? extends INode> children) {
super.addLayoutActions(actions, parentNode, children);
final List<? extends INode> targets = children == null || children.size() == 0 ?
Collections.singletonList(parentNode)
: children;
final INode first = targets.get(0);
// Shared action callback
IMenuCallback actionCallback = new IMenuCallback() {
@Override
public void action(
@NonNull RuleAction action,
@NonNull List<? extends INode> selectedNodes,
final @Nullable String valueId,
final @Nullable Boolean newValue) {
final String actionId = action.getId();
final String undoLabel;
if (actionId.equals(ACTION_FILL_WIDTH)) {
undoLabel = "Change Width Fill";
} else if (actionId.equals(ACTION_FILL_HEIGHT)) {
undoLabel = "Change Height Fill";
} else {
return;
}
parentNode.editXml(undoLabel, new INodeHandler() {
@Override
public void handle(@NonNull INode n) {
String attribute = actionId.equals(ACTION_FILL_WIDTH)
? ATTR_LAYOUT_WIDTH : ATTR_LAYOUT_HEIGHT;
String value;
if (newValue) {
if (supportsMatchParent()) {
value = VALUE_MATCH_PARENT;
} else {
value = VALUE_FILL_PARENT;
}
} else {
value = VALUE_WRAP_CONTENT;
}
for (INode child : targets) {
child.setAttribute(ANDROID_URI, attribute, value);
}
}
});
}
};
actions.add(RuleAction.createToggle(ACTION_FILL_WIDTH, "Toggle Fill Width",
isFilled(first, ATTR_LAYOUT_WIDTH), actionCallback, ICON_FILL_WIDTH, 10, false));
actions.add(RuleAction.createToggle(ACTION_FILL_HEIGHT, "Toggle Fill Height",
isFilled(first, ATTR_LAYOUT_HEIGHT), actionCallback, ICON_FILL_HEIGHT, 20, false));
}
// ==== Paste support ====
/**
* The default behavior for pasting in a layout is to simulate a drop in the
* top-left corner of the view.
* <p/>
* Note that we explicitly do not call super() here -- the BaseViewRule.onPaste handler
* will call onPasteBeforeChild() instead.
* <p/>
* Derived layouts should override this behavior if not appropriate.
*/
@Override
public void onPaste(@NonNull INode targetNode, @Nullable Object targetView,
@NonNull IDragElement[] elements) {
DropFeedback feedback = onDropEnter(targetNode, targetView, elements);
if (feedback != null) {
Point p = targetNode.getBounds().getTopLeft();
feedback = onDropMove(targetNode, elements, feedback, p);
if (feedback != null) {
onDropLeave(targetNode, elements, feedback);
onDropped(targetNode, elements, feedback, p);
}
}
}
/**
* The default behavior for pasting in a layout with a specific child target
* is to simulate a drop right above the top left of the given child target.
* <p/>
* This method is invoked by BaseView when onPaste() is called --
* views don't generally accept children and instead use the target node as
* a hint to paste "before" it.
*
* @param parentNode the parent node we're pasting into
* @param parentView the view object for the parent layout, or null
* @param targetNode the first selected node
* @param elements the elements being pasted
*/
public void onPasteBeforeChild(INode parentNode, Object parentView, INode targetNode,
IDragElement[] elements) {
DropFeedback feedback = onDropEnter(parentNode, parentView, elements);
if (feedback != null) {
Point parentP = parentNode.getBounds().getTopLeft();
Point targetP = targetNode.getBounds().getTopLeft();
if (parentP.y < targetP.y) {
targetP.y -= 1;
}
feedback = onDropMove(parentNode, elements, feedback, targetP);
if (feedback != null) {
onDropLeave(parentNode, elements, feedback);
onDropped(parentNode, elements, feedback, targetP);
}
}
}
// ==== Utility methods used by derived layouts ====
/**
* Draws the bounds of the given elements and all its children elements in the canvas
* with the specified offset.
*
* @param gc the graphics context
* @param element the element to be drawn
* @param offsetX a horizontal delta to add to the current bounds of the element when
* drawing it
* @param offsetY a vertical delta to add to the current bounds of the element when
* drawing it
*/
public void drawElement(IGraphics gc, IDragElement element, int offsetX, int offsetY) {
Rect b = element.getBounds();
if (b.isValid()) {
gc.drawRect(b.x + offsetX, b.y + offsetY, b.x + offsetX + b.w, b.y + offsetY + b.h);
}
for (IDragElement inner : element.getInnerElements()) {
drawElement(gc, inner, offsetX, offsetY);
}
}
/**
* Collect all the "android:id" IDs from the dropped elements. When moving
* objects within the same canvas, that's all there is to do. However if the
* objects are moved to a different canvas or are copied then set
* createNewIds to true to find the existing IDs under targetNode and create
* a map with new non-conflicting unique IDs as needed. Returns a map String
* old-id => tuple (String new-id, String fqcn) where fqcn is the FQCN of
* the element.
*/
protected static Map<String, Pair<String, String>> getDropIdMap(INode targetNode,
IDragElement[] elements, boolean createNewIds) {
Map<String, Pair<String, String>> idMap = new HashMap<String, Pair<String, String>>();
if (createNewIds) {
collectIds(idMap, elements);
// Need to remap ids if necessary
idMap = remapIds(targetNode, idMap);
}
return idMap;
}
/**
* Fills idMap with a map String id => tuple (String id, String fqcn) where
* fqcn is the FQCN of the element (in case we want to generate new IDs
* based on the element type.)
*
* @see #getDropIdMap
*/
protected static Map<String, Pair<String, String>> collectIds(
Map<String, Pair<String, String>> idMap,
IDragElement[] elements) {
for (IDragElement element : elements) {
IDragAttribute attr = element.getAttribute(ANDROID_URI, ATTR_ID);
if (attr != null) {
String id = attr.getValue();
if (id != null && id.length() > 0) {
idMap.put(id, Pair.of(id, element.getFqcn()));
}
}
collectIds(idMap, element.getInnerElements());
}
return idMap;
}
/**
* Used by #getDropIdMap to find new IDs in case of conflict.
*/
protected static Map<String, Pair<String, String>> remapIds(INode node,
Map<String, Pair<String, String>> idMap) {
// Visit the document to get a list of existing ids
Set<String> existingIdSet = new HashSet<String>();
collectExistingIds(node.getRoot(), existingIdSet);
Map<String, Pair<String, String>> new_map = new HashMap<String, Pair<String, String>>();
for (Map.Entry<String, Pair<String, String>> entry : idMap.entrySet()) {
String key = entry.getKey();
Pair<String, String> value = entry.getValue();
String id = normalizeId(key);
if (!existingIdSet.contains(id)) {
// Not a conflict. Use as-is.
new_map.put(key, value);
if (!key.equals(id)) {
new_map.put(id, value);
}
} else {
// There is a conflict. Get a new id.
String new_id = findNewId(value.getSecond(), existingIdSet);
value = Pair.of(new_id, value.getSecond());
new_map.put(id, value);
new_map.put(id.replaceFirst("@\\+", "@"), value); //$NON-NLS-1$ //$NON-NLS-2$
}
}
return new_map;
}
/**
* Used by #remapIds to find a new ID for a conflicting element.
*/
protected static String findNewId(String fqcn, Set<String> existingIdSet) {
// Get the last component of the FQCN (e.g. "android.view.Button" =>
// "Button")
String name = fqcn.substring(fqcn.lastIndexOf('.') + 1);
for (int i = 1; i < 1000000; i++) {
String id = String.format("@+id/%s%02d", name, i); //$NON-NLS-1$
if (!existingIdSet.contains(id)) {
existingIdSet.add(id);
return id;
}
}
// We'll never reach here.
return null;
}
/**
* Used by #getDropIdMap to find existing IDs recursively.
*/
protected static void collectExistingIds(INode root, Set<String> existingIdSet) {
if (root == null) {
return;
}
String id = root.getStringAttr(ANDROID_URI, ATTR_ID);
if (id != null) {
id = normalizeId(id);
if (!existingIdSet.contains(id)) {
existingIdSet.add(id);
}
}
for (INode child : root.getChildren()) {
collectExistingIds(child, existingIdSet);
}
}
/**
* Transforms @id/name into @+id/name to treat both forms the same way.
*/
protected static String normalizeId(String id) {
if (id.indexOf("@+") == -1) { //$NON-NLS-1$
id = id.replaceFirst("@", "@+"); //$NON-NLS-1$ //$NON-NLS-2$
}
return id;
}
/**
* For use by {@link BaseLayoutRule#addAttributes} A filter should return a
* valid replacement string.
*/
protected static interface AttributeFilter {
String replace(String attributeUri, String attributeName, String attributeValue);
}
private static final String[] EXCLUDED_ATTRIBUTES = new String[] {
// Common
ATTR_LAYOUT_GRAVITY,
// from AbsoluteLayout
ATTR_LAYOUT_X,
ATTR_LAYOUT_Y,
// from RelativeLayout
ATTR_LAYOUT_ABOVE,
ATTR_LAYOUT_BELOW,
ATTR_LAYOUT_TO_LEFT_OF,
ATTR_LAYOUT_TO_RIGHT_OF,
ATTR_LAYOUT_ALIGN_BASELINE,
ATTR_LAYOUT_ALIGN_TOP,
ATTR_LAYOUT_ALIGN_BOTTOM,
ATTR_LAYOUT_ALIGN_LEFT,
ATTR_LAYOUT_ALIGN_RIGHT,
ATTR_LAYOUT_ALIGN_PARENT_TOP,
ATTR_LAYOUT_ALIGN_PARENT_BOTTOM,
ATTR_LAYOUT_ALIGN_PARENT_LEFT,
ATTR_LAYOUT_ALIGN_PARENT_RIGHT,
ATTR_LAYOUT_ALIGN_WITH_PARENT_MISSING,
ATTR_LAYOUT_CENTER_HORIZONTAL,
ATTR_LAYOUT_CENTER_IN_PARENT,
ATTR_LAYOUT_CENTER_VERTICAL,
// From GridLayout
ATTR_LAYOUT_ROW,
ATTR_LAYOUT_ROW_SPAN,
ATTR_LAYOUT_COLUMN,
ATTR_LAYOUT_COLUMN_SPAN
};
/**
* Default attribute filter used by the various layouts to filter out some properties
* we don't want to offer.
*/
public static final AttributeFilter DEFAULT_ATTR_FILTER = new AttributeFilter() {
Set<String> mExcludes;
@Override
public String replace(String uri, String name, String value) {
if (!ANDROID_URI.equals(uri)) {
return value;
}
if (mExcludes == null) {
mExcludes = new HashSet<String>(EXCLUDED_ATTRIBUTES.length);
mExcludes.addAll(Arrays.asList(EXCLUDED_ATTRIBUTES));
}
return mExcludes.contains(name) ? null : value;
}
};
/**
* Copies all the attributes from oldElement to newNode. Uses the idMap to
* transform the value of all attributes of Format.REFERENCE. If filter is
* non-null, it's a filter that can rewrite the attribute string.
*/
protected static void addAttributes(INode newNode, IDragElement oldElement,
Map<String, Pair<String, String>> idMap, AttributeFilter filter) {
for (IDragAttribute attr : oldElement.getAttributes()) {
String uri = attr.getUri();
String name = attr.getName();
String value = attr.getValue();
IAttributeInfo attrInfo = newNode.getAttributeInfo(uri, name);
if (attrInfo != null) {
if (attrInfo.getFormats().contains(IAttributeInfo.Format.REFERENCE)) {
if (idMap.containsKey(value)) {
value = idMap.get(value).getFirst();
}
}
}
if (filter != null) {
value = filter.replace(uri, name, value);
}
if (value != null && value.length() > 0) {
newNode.setAttribute(uri, name, value);
}
}
}
/**
* Adds all the children elements of oldElement to newNode, recursively.
* Attributes are adjusted by calling addAttributes with idMap as necessary,
* with no closure filter.
*/
protected static void addInnerElements(INode newNode, IDragElement oldElement,
Map<String, Pair<String, String>> idMap) {
for (IDragElement element : oldElement.getInnerElements()) {
String fqcn = element.getFqcn();
INode childNode = newNode.appendChild(fqcn);
addAttributes(childNode, element, idMap, null /* filter */);
addInnerElements(childNode, element, idMap);
}
}
/**
* Insert the given elements into the given node at the given position
*
* @param targetNode the node to insert into
* @param elements the elements to insert
* @param createNewIds if true, generate new ids when there is a conflict
* @param initialInsertPos index among targetnode's children which to insert the
* children
*/
public static void insertAt(final INode targetNode, final IDragElement[] elements,
final boolean createNewIds, final int initialInsertPos) {
// Collect IDs from dropped elements and remap them to new IDs
// if this is a copy or from a different canvas.
final Map<String, Pair<String, String>> idMap = getDropIdMap(targetNode, elements,
createNewIds);
targetNode.editXml("Insert Elements", new INodeHandler() {
@Override
public void handle(@NonNull INode node) {
// Now write the new elements.
int insertPos = initialInsertPos;
for (IDragElement element : elements) {
String fqcn = element.getFqcn();
INode newChild = targetNode.insertChildAt(fqcn, insertPos);
// insertPos==-1 means to insert at the end. Otherwise
// increment the insertion position.
if (insertPos >= 0) {
insertPos++;
}
// Copy all the attributes, modifying them as needed.
addAttributes(newChild, element, idMap, DEFAULT_ATTR_FILTER);
addInnerElements(newChild, element, idMap);
}
}
});
}
// ---- Resizing ----
/** Creates a new {@link ResizeState} object to track resize state */
protected ResizeState createResizeState(INode layout, Object layoutView, INode node) {
return new ResizeState(this, layout, layoutView, node);
}
@Override
public DropFeedback onResizeBegin(@NonNull INode child, @NonNull INode parent,
@Nullable SegmentType horizontalEdge, @Nullable SegmentType verticalEdge,
@Nullable Object childView, @Nullable Object parentView) {
ResizeState state = createResizeState(parent, parentView, child);
state.horizontalEdgeType = horizontalEdge;
state.verticalEdgeType = verticalEdge;
// Compute preferred (wrap_content) size such that we can offer guidelines to
// snap to the preferred size
Map<INode, Rect> sizes = mRulesEngine.measureChildren(parent,
new IClientRulesEngine.AttributeFilter() {
@Override
public String getAttribute(@NonNull INode node, @Nullable String namespace,
@NonNull String localName) {
// Change attributes to wrap_content
if (ATTR_LAYOUT_WIDTH.equals(localName)
&& SdkConstants.NS_RESOURCES.equals(namespace)) {
return VALUE_WRAP_CONTENT;
}
if (ATTR_LAYOUT_HEIGHT.equals(localName)
&& SdkConstants.NS_RESOURCES.equals(namespace)) {
return VALUE_WRAP_CONTENT;
}
return null;
}
});
if (sizes != null) {
state.wrapBounds = sizes.get(child);
}
return new DropFeedback(state, new IFeedbackPainter() {
@Override
public void paint(@NonNull IGraphics gc, @NonNull INode node,
@NonNull DropFeedback feedback) {
ResizeState resizeState = (ResizeState) feedback.userData;
if (resizeState != null && resizeState.bounds != null) {
paintResizeFeedback(gc, node, resizeState);
}
}
});
}
protected void paintResizeFeedback(IGraphics gc, INode node, ResizeState resizeState) {
gc.useStyle(DrawingStyle.RESIZE_PREVIEW);
Rect b = resizeState.bounds;
gc.drawRect(b);
if (resizeState.horizontalFillSegment != null) {
gc.useStyle(DrawingStyle.GUIDELINE);
Segment s = resizeState.horizontalFillSegment;
gc.drawLine(s.from, s.at, s.to, s.at);
}
if (resizeState.verticalFillSegment != null) {
gc.useStyle(DrawingStyle.GUIDELINE);
Segment s = resizeState.verticalFillSegment;
gc.drawLine(s.at, s.from, s.at, s.to);
}
if (resizeState.wrapBounds != null) {
gc.useStyle(DrawingStyle.GUIDELINE);
int wrapWidth = resizeState.wrapBounds.w;
int wrapHeight = resizeState.wrapBounds.h;
// Show the "wrap_content" guideline.
// If we are showing both the wrap_width and wrap_height lines
// then we show at most the rectangle formed by the two lines;
// otherwise we show the entire width of the line
if (resizeState.horizontalEdgeType != null) {
int y = -1;
switch (resizeState.horizontalEdgeType) {
case TOP:
y = b.y + b.h - wrapHeight;
break;
case BOTTOM:
y = b.y + wrapHeight;
break;
default: assert false : resizeState.horizontalEdgeType;
}
if (resizeState.verticalEdgeType != null) {
switch (resizeState.verticalEdgeType) {
case LEFT:
gc.drawLine(b.x + b.w - wrapWidth, y, b.x + b.w, y);
break;
case RIGHT:
gc.drawLine(b.x, y, b.x + wrapWidth, y);
break;
default: assert false : resizeState.verticalEdgeType;
}
} else {
gc.drawLine(b.x, y, b.x + b.w, y);
}
}
if (resizeState.verticalEdgeType != null) {
int x = -1;
switch (resizeState.verticalEdgeType) {
case LEFT:
x = b.x + b.w - wrapWidth;
break;
case RIGHT:
x = b.x + wrapWidth;
break;
default: assert false : resizeState.verticalEdgeType;
}
if (resizeState.horizontalEdgeType != null) {
switch (resizeState.horizontalEdgeType) {
case TOP:
gc.drawLine(x, b.y + b.h - wrapHeight, x, b.y + b.h);
break;
case BOTTOM:
gc.drawLine(x, b.y, x, b.y + wrapHeight);
break;
default: assert false : resizeState.horizontalEdgeType;
}
} else {
gc.drawLine(x, b.y, x, b.y + b.h);
}
}
}
}
/**
* Returns the maximum number of pixels will be considered a "match" when snapping
* resize or move positions to edges or other constraints
*
* @return the maximum number of pixels to consider for snapping
*/
public static final int getMaxMatchDistance() {
// TODO - make constant once we're happy with the feel
return 20;
}
@Override
public void onResizeUpdate(@Nullable DropFeedback feedback, @NonNull INode child,
@NonNull INode parent, @NonNull Rect newBounds, int modifierMask) {
ResizeState state = (ResizeState) feedback.userData;
state.bounds = newBounds;
state.modifierMask = modifierMask;
// Match on wrap bounds
state.wrapWidth = state.wrapHeight = false;
if (state.wrapBounds != null) {
Rect b = state.wrapBounds;
int maxMatchDistance = getMaxMatchDistance();
if (state.horizontalEdgeType != null) {
if (Math.abs(newBounds.h - b.h) < maxMatchDistance) {
state.wrapHeight = true;
if (state.horizontalEdgeType == SegmentType.TOP) {
newBounds.y += newBounds.h - b.h;
}
newBounds.h = b.h;
}
}
if (state.verticalEdgeType != null) {
if (Math.abs(newBounds.w - b.w) < maxMatchDistance) {
state.wrapWidth = true;
if (state.verticalEdgeType == SegmentType.LEFT) {
newBounds.x += newBounds.w - b.w;
}
newBounds.w = b.w;
}
}
}
// Match on fill bounds
state.horizontalFillSegment = null;
state.fillHeight = false;
if (state.horizontalEdgeType == SegmentType.BOTTOM && !state.wrapHeight) {
Rect parentBounds = parent.getBounds();
state.horizontalFillSegment = new Segment(parentBounds.y2(), newBounds.x,
newBounds.x2(),
null /*node*/, null /*id*/, SegmentType.BOTTOM, MarginType.NO_MARGIN);
if (Math.abs(newBounds.y2() - parentBounds.y2()) < getMaxMatchDistance()) {
state.fillHeight = true;
newBounds.h = parentBounds.y2() - newBounds.y;
}
}
state.verticalFillSegment = null;
state.fillWidth = false;
if (state.verticalEdgeType == SegmentType.RIGHT && !state.wrapWidth) {
Rect parentBounds = parent.getBounds();
state.verticalFillSegment = new Segment(parentBounds.x2(), newBounds.y,
newBounds.y2(),
null /*node*/, null /*id*/, SegmentType.RIGHT, MarginType.NO_MARGIN);
if (Math.abs(newBounds.x2() - parentBounds.x2()) < getMaxMatchDistance()) {
state.fillWidth = true;
newBounds.w = parentBounds.x2() - newBounds.x;
}
}
feedback.tooltip = getResizeUpdateMessage(state, child, parent,
newBounds, state.horizontalEdgeType, state.verticalEdgeType);
}
@Override
public void onResizeEnd(@Nullable DropFeedback feedback, @NonNull INode child,
final @NonNull INode parent, final @NonNull Rect newBounds) {
final Rect oldBounds = child.getBounds();
if (oldBounds.w != newBounds.w || oldBounds.h != newBounds.h) {
final ResizeState state = (ResizeState) feedback.userData;
child.editXml("Resize", new INodeHandler() {
@Override
public void handle(@NonNull INode n) {
setNewSizeBounds(state, n, parent, oldBounds, newBounds,
state.horizontalEdgeType, state.verticalEdgeType);
}
});
}
}
/**
* Returns the message to display to the user during the resize operation
*
* @param resizeState the current resize state
* @param child the child node being resized
* @param parent the parent of the resized node
* @param newBounds the new bounds to resize the child to, in pixels
* @param horizontalEdge the horizontal edge being resized
* @param verticalEdge the vertical edge being resized
* @return the message to display for the current resize bounds
*/
protected String getResizeUpdateMessage(ResizeState resizeState, INode child, INode parent,
Rect newBounds, SegmentType horizontalEdge, SegmentType verticalEdge) {
String width = resizeState.getWidthAttribute();
String 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);
}
}
/**
* Performs the edit on the node to complete a resizing operation. The actual edit
* part is pulled out such that subclasses can change/add to the edits and be part of
* the same undo event
*
* @param resizeState the current resize state
* @param node the child node being resized
* @param layout the parent of the resized node
* @param newBounds the new bounds to resize the child to, in pixels
* @param horizontalEdge the horizontal edge being resized
* @param verticalEdge the vertical edge being resized
*/
protected void setNewSizeBounds(ResizeState resizeState, INode node, INode layout,
Rect oldBounds, Rect newBounds, SegmentType horizontalEdge, SegmentType verticalEdge) {
if (verticalEdge != null
&& (newBounds.w != oldBounds.w || resizeState.wrapWidth || resizeState.fillWidth)) {
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, resizeState.getWidthAttribute());
}
if (horizontalEdge != null
&& (newBounds.h != oldBounds.h || resizeState.wrapHeight || resizeState.fillHeight)) {
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_HEIGHT, resizeState.getHeightAttribute());
}
}
}