/*
* 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_GRAVITY;
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_RESOURCE_PREFIX;
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.VALUE_TRUE;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.ide.common.api.DropFeedback;
import com.android.ide.common.api.IDragElement;
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.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.SegmentType;
import com.android.ide.common.layout.relative.ConstraintPainter;
import com.android.ide.common.layout.relative.DeletionHandler;
import com.android.ide.common.layout.relative.GuidelinePainter;
import com.android.ide.common.layout.relative.MoveHandler;
import com.android.ide.common.layout.relative.ResizeHandler;
import com.android.utils.Pair;
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.RelativeLayout and all its derived
* classes.
*/
public class RelativeLayoutRule extends BaseLayoutRule {
private static final String ACTION_SHOW_STRUCTURE = "_structure"; //$NON-NLS-1$
private static final String ACTION_SHOW_CONSTRAINTS = "_constraints"; //$NON-NLS-1$
private static final String ACTION_CENTER_VERTICAL = "_centerVert"; //$NON-NLS-1$
private static final String ACTION_CENTER_HORIZONTAL = "_centerHoriz"; //$NON-NLS-1$
private static final URL ICON_CENTER_VERTICALLY =
RelativeLayoutRule.class.getResource("centerVertically.png"); //$NON-NLS-1$
private static final URL ICON_CENTER_HORIZONTALLY =
RelativeLayoutRule.class.getResource("centerHorizontally.png"); //$NON-NLS-1$
private static final URL ICON_SHOW_STRUCTURE =
BaseLayoutRule.class.getResource("structure.png"); //$NON-NLS-1$
private static final URL ICON_SHOW_CONSTRAINTS =
BaseLayoutRule.class.getResource("constraints.png"); //$NON-NLS-1$
public static boolean sShowStructure = false;
public static boolean sShowConstraints = true;
// ==== Selection ====
@Override
public List<String> getSelectionHint(@NonNull INode parentNode, @NonNull INode childNode) {
List<String> infos = new ArrayList<String>(18);
addAttr(ATTR_LAYOUT_ABOVE, childNode, infos);
addAttr(ATTR_LAYOUT_BELOW, childNode, infos);
addAttr(ATTR_LAYOUT_TO_LEFT_OF, childNode, infos);
addAttr(ATTR_LAYOUT_TO_RIGHT_OF, childNode, infos);
addAttr(ATTR_LAYOUT_ALIGN_BASELINE, childNode, infos);
addAttr(ATTR_LAYOUT_ALIGN_TOP, childNode, infos);
addAttr(ATTR_LAYOUT_ALIGN_BOTTOM, childNode, infos);
addAttr(ATTR_LAYOUT_ALIGN_LEFT, childNode, infos);
addAttr(ATTR_LAYOUT_ALIGN_RIGHT, childNode, infos);
addAttr(ATTR_LAYOUT_ALIGN_PARENT_TOP, childNode, infos);
addAttr(ATTR_LAYOUT_ALIGN_PARENT_BOTTOM, childNode, infos);
addAttr(ATTR_LAYOUT_ALIGN_PARENT_LEFT, childNode, infos);
addAttr(ATTR_LAYOUT_ALIGN_PARENT_RIGHT, childNode, infos);
addAttr(ATTR_LAYOUT_ALIGN_WITH_PARENT_MISSING, childNode, infos);
addAttr(ATTR_LAYOUT_CENTER_HORIZONTAL, childNode, infos);
addAttr(ATTR_LAYOUT_CENTER_IN_PARENT, childNode, infos);
addAttr(ATTR_LAYOUT_CENTER_VERTICAL, childNode, infos);
return infos;
}
private void addAttr(String propertyName, INode childNode, List<String> infos) {
String a = childNode.getStringAttr(ANDROID_URI, propertyName);
if (a != null && a.length() > 0) {
// Display the layout parameters without the leading layout_ prefix
// and id references without the @+id/ prefix
if (propertyName.startsWith(ATTR_LAYOUT_RESOURCE_PREFIX)) {
propertyName = propertyName.substring(ATTR_LAYOUT_RESOURCE_PREFIX.length());
}
a = stripIdPrefix(a);
String s = propertyName + ": " + a;
infos.add(s);
}
}
@Override
public void paintSelectionFeedback(@NonNull IGraphics graphics, @NonNull INode parentNode,
@NonNull List<? extends INode> childNodes, @Nullable Object view) {
super.paintSelectionFeedback(graphics, parentNode, childNodes, view);
boolean showDependents = true;
if (sShowStructure) {
childNodes = Arrays.asList(parentNode.getChildren());
// Avoid painting twice - both as incoming and outgoing
showDependents = false;
} else if (!sShowConstraints) {
return;
}
ConstraintPainter.paintSelectionFeedback(graphics, parentNode, childNodes, showDependents);
}
// ==== Drag'n'drop support ====
@Override
public DropFeedback onDropEnter(@NonNull INode targetNode, @Nullable Object targetView,
@Nullable IDragElement[] elements) {
return new DropFeedback(new MoveHandler(targetNode, elements, mRulesEngine),
new GuidelinePainter());
}
@Override
public DropFeedback onDropMove(@NonNull INode targetNode, @NonNull IDragElement[] elements,
@Nullable DropFeedback feedback, @NonNull Point p) {
if (elements == null || elements.length == 0 || feedback == null) {
return null;
}
MoveHandler state = (MoveHandler) feedback.userData;
int offsetX = p.x + (feedback.dragBounds != null ? feedback.dragBounds.x : 0);
int offsetY = p.y + (feedback.dragBounds != null ? feedback.dragBounds.y : 0);
state.updateMove(feedback, elements, offsetX, offsetY, feedback.modifierMask);
// Or maybe only do this if the results changed...
feedback.requestPaint = true;
return feedback;
}
@Override
public void onDropLeave(@NonNull INode targetNode, @NonNull IDragElement[] elements,
@Nullable DropFeedback feedback) {
}
@Override
public void onDropped(final @NonNull INode targetNode, final @NonNull IDragElement[] elements,
final @Nullable DropFeedback feedback, final @NonNull Point p) {
if (feedback == null) {
return;
}
final MoveHandler state = (MoveHandler) feedback.userData;
final Map<String, Pair<String, String>> idMap = getDropIdMap(targetNode, elements,
feedback.isCopy || !feedback.sameCanvas);
targetNode.editXml("Dropped", new INodeHandler() {
@Override
public void handle(@NonNull INode n) {
int index = -1;
// Remove cycles
state.removeCycles();
// Now write the new elements.
INode previous = null;
for (IDragElement element : elements) {
String fqcn = element.getFqcn();
// index==-1 means to insert at the end.
// Otherwise increment the insertion position.
if (index >= 0) {
index++;
}
INode newChild = targetNode.insertChildAt(fqcn, index);
// Copy all the attributes, modifying them as needed.
addAttributes(newChild, element, idMap, BaseLayoutRule.DEFAULT_ATTR_FILTER);
addInnerElements(newChild, element, idMap);
if (previous == null) {
state.applyConstraints(newChild);
previous = newChild;
} else {
// Arrange the nodes next to each other, depending on which
// edge we are attaching to. For example, if attaching to the
// top edge, arrange the subsequent nodes in a column below it.
//
// TODO: Try to do something smarter here where we detect
// constraints between the dragged edges, and we preserve these.
// We have to do this carefully though because if the
// constraints go through some other nodes not part of the
// selection, this doesn't work right, and you might be
// dragging several connected components, which we'd then
// need to stitch together such that they are all visible.
state.attachPrevious(previous, newChild);
previous = newChild;
}
}
}
});
}
@Override
public void onChildInserted(@NonNull INode node, @NonNull INode parent,
@NonNull InsertType insertType) {
// TODO: Handle more generically some way to ensure that widgets with no
// intrinsic size get some minimum size until they are attached on multiple
// opposing sides.
//String fqcn = node.getFqcn();
//if (fqcn.equals(FQCN_EDIT_TEXT)) {
// node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, "100dp"); //$NON-NLS-1$
//}
}
@Override
public void onRemovingChildren(@NonNull List<INode> deleted, @NonNull INode parent,
boolean moved) {
super.onRemovingChildren(deleted, parent, moved);
if (!moved) {
DeletionHandler handler = new DeletionHandler(deleted, Collections.<INode>emptyList(),
parent);
handler.updateConstraints();
}
}
// ==== Resize Support ====
@Override
public DropFeedback onResizeBegin(@NonNull INode child, @NonNull INode parent,
@Nullable SegmentType horizontalEdgeType, @Nullable SegmentType verticalEdgeType,
@Nullable Object childView, @Nullable Object parentView) {
ResizeHandler state = new ResizeHandler(parent, child, mRulesEngine,
horizontalEdgeType, verticalEdgeType);
return new DropFeedback(state, new GuidelinePainter());
}
@Override
public void onResizeUpdate(@Nullable DropFeedback feedback, @NonNull INode child,
@NonNull INode parent, @NonNull Rect newBounds,
int modifierMask) {
if (feedback == null) {
return;
}
ResizeHandler state = (ResizeHandler) feedback.userData;
state.updateResize(feedback, child, newBounds, modifierMask);
}
@Override
public void onResizeEnd(@Nullable DropFeedback feedback, @NonNull INode child,
@NonNull INode parent, final @NonNull Rect newBounds) {
if (feedback == null) {
return;
}
final ResizeHandler state = (ResizeHandler) feedback.userData;
child.editXml("Resize", new INodeHandler() {
@Override
public void handle(@NonNull INode n) {
state.removeCycles();
state.applyConstraints(n);
}
});
}
// ==== Layout Actions Bar ====
@Override
public void addLayoutActions(
@NonNull List<RuleAction> actions,
final @NonNull INode parentNode,
final @NonNull List<? extends INode> children) {
super.addLayoutActions(actions, parentNode, children);
actions.add(createGravityAction(Collections.<INode>singletonList(parentNode),
ATTR_GRAVITY));
actions.add(RuleAction.createSeparator(25));
actions.add(createMarginAction(parentNode, children));
IMenuCallback callback = new IMenuCallback() {
@Override
public void action(@NonNull RuleAction action,
@NonNull List<? extends INode> selectedNodes,
final @Nullable String valueId,
final @Nullable Boolean newValue) {
final String id = action.getId();
if (id.equals(ACTION_CENTER_VERTICAL)|| id.equals(ACTION_CENTER_HORIZONTAL)) {
parentNode.editXml("Center", new INodeHandler() {
@Override
public void handle(@NonNull INode n) {
if (id.equals(ACTION_CENTER_VERTICAL)) {
for (INode child : children) {
centerVertically(child);
}
} else if (id.equals(ACTION_CENTER_HORIZONTAL)) {
for (INode child : children) {
centerHorizontally(child);
}
}
mRulesEngine.redraw();
}
});
} else if (id.equals(ACTION_SHOW_CONSTRAINTS)) {
sShowConstraints = !sShowConstraints;
mRulesEngine.redraw();
} else {
assert id.equals(ACTION_SHOW_STRUCTURE);
sShowStructure = !sShowStructure;
mRulesEngine.redraw();
}
}
};
// Centering actions
if (children != null && children.size() > 0) {
actions.add(RuleAction.createSeparator(150));
actions.add(RuleAction.createAction(ACTION_CENTER_VERTICAL, "Center Vertically",
callback, ICON_CENTER_VERTICALLY, 160, false));
actions.add(RuleAction.createAction(ACTION_CENTER_HORIZONTAL, "Center Horizontally",
callback, ICON_CENTER_HORIZONTALLY, 170, false));
}
actions.add(RuleAction.createSeparator(80));
actions.add(RuleAction.createToggle(ACTION_SHOW_CONSTRAINTS, "Show Constraints",
sShowConstraints, callback, ICON_SHOW_CONSTRAINTS, 180, false));
actions.add(RuleAction.createToggle(ACTION_SHOW_STRUCTURE, "Show All Relationships",
sShowStructure, callback, ICON_SHOW_STRUCTURE, 190, false));
}
private void centerHorizontally(INode node) {
// Clear horizontal-oriented attributes from the node
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_ALIGN_PARENT_LEFT, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_ALIGN_LEFT, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_TO_RIGHT_OF, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_CENTER_HORIZONTAL, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_ALIGN_PARENT_RIGHT, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_ALIGN_RIGHT, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_TO_LEFT_OF, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_CENTER_HORIZONTAL, null);
if (VALUE_TRUE.equals(node.getStringAttr(ANDROID_URI, ATTR_LAYOUT_CENTER_IN_PARENT))) {
// Already done
} else if (VALUE_TRUE.equals(node.getStringAttr(ANDROID_URI,
ATTR_LAYOUT_CENTER_VERTICAL))) {
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_CENTER_VERTICAL, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_CENTER_IN_PARENT, VALUE_TRUE);
} else {
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_CENTER_HORIZONTAL, VALUE_TRUE);
}
}
private void centerVertically(INode node) {
// Clear vertical-oriented attributes from the node
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_ALIGN_PARENT_TOP, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_ALIGN_TOP, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_BELOW, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_ALIGN_PARENT_BOTTOM, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_ALIGN_BOTTOM, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_ABOVE, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_CENTER_VERTICAL, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_ALIGN_BASELINE, null);
// Center vertically
if (VALUE_TRUE.equals(node.getStringAttr(ANDROID_URI, ATTR_LAYOUT_CENTER_IN_PARENT))) {
// ALready done
} else if (VALUE_TRUE.equals(node.getStringAttr(ANDROID_URI,
ATTR_LAYOUT_CENTER_HORIZONTAL))) {
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_CENTER_HORIZONTAL, null);
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_CENTER_IN_PARENT, VALUE_TRUE);
} else {
node.setAttribute(ANDROID_URI, ATTR_LAYOUT_CENTER_VERTICAL, VALUE_TRUE);
}
}
}