/*
* Copyright (C) 2011 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.relative;
import static com.android.ide.common.api.MarginType.NO_MARGIN;
import static com.android.ide.common.api.SegmentType.BASELINE;
import static com.android.ide.common.api.SegmentType.BOTTOM;
import static com.android.ide.common.api.SegmentType.CENTER_HORIZONTAL;
import static com.android.ide.common.api.SegmentType.CENTER_VERTICAL;
import static com.android.ide.common.api.SegmentType.LEFT;
import static com.android.ide.common.api.SegmentType.RIGHT;
import static com.android.ide.common.api.SegmentType.TOP;
import static com.android.SdkConstants.ATTR_ID;
import static java.lang.Math.abs;
import com.android.SdkConstants;
import static com.android.SdkConstants.ANDROID_URI;
import com.android.ide.common.api.DropFeedback;
import com.android.ide.common.api.IClientRulesEngine;
import com.android.ide.common.api.INode;
import com.android.ide.common.api.Rect;
import com.android.ide.common.api.Segment;
import com.android.ide.common.api.SegmentType;
import com.android.ide.common.layout.BaseLayoutRule;
import java.util.Collections;
import java.util.Set;
/**
* A {@link ResizeHandler} is a {@link GuidelineHandler} which handles resizing of individual
* edges in a RelativeLayout.
*/
public class ResizeHandler extends GuidelineHandler {
private final SegmentType mHorizontalEdgeType;
private final SegmentType mVerticalEdgeType;
/**
* Creates a new {@link ResizeHandler}
*
* @param layout the layout containing the resized node
* @param resized the node being resized
* @param rulesEngine the applicable {@link IClientRulesEngine}
* @param horizontalEdgeType the type of horizontal edge being resized, or null
* @param verticalEdgeType the type of vertical edge being resized, or null
*/
public ResizeHandler(INode layout, INode resized,
IClientRulesEngine rulesEngine,
SegmentType horizontalEdgeType, SegmentType verticalEdgeType) {
super(layout, rulesEngine);
assert horizontalEdgeType != null || verticalEdgeType != null;
assert horizontalEdgeType != BASELINE && verticalEdgeType != BASELINE;
assert horizontalEdgeType != CENTER_HORIZONTAL && verticalEdgeType != CENTER_HORIZONTAL;
assert horizontalEdgeType != CENTER_VERTICAL && verticalEdgeType != CENTER_VERTICAL;
mHorizontalEdgeType = horizontalEdgeType;
mVerticalEdgeType = verticalEdgeType;
Set<INode> nodes = Collections.singleton(resized);
mDraggedNodes = nodes;
mHorizontalDeps = mDependencyGraph.dependsOn(nodes, false /* vertical */);
mVerticalDeps = mDependencyGraph.dependsOn(nodes, true /* vertical */);
if (horizontalEdgeType != null) {
if (horizontalEdgeType == TOP) {
mMoveTop = true;
} else if (horizontalEdgeType == BOTTOM) {
mMoveBottom = true;
}
}
if (verticalEdgeType != null) {
if (verticalEdgeType == LEFT) {
mMoveLeft = true;
} else if (verticalEdgeType == RIGHT) {
mMoveRight = true;
}
}
for (INode child : layout.getChildren()) {
if (child != resized) {
String id = child.getStringAttr(ANDROID_URI, ATTR_ID);
addBounds(child, id,
!mHorizontalDeps.contains(child),
!mVerticalDeps.contains(child));
}
}
addBounds(layout, layout.getStringAttr(ANDROID_URI, ATTR_ID), true, true);
}
@Override
protected void snapVertical(Segment vEdge, int x, Rect newBounds) {
int maxDistance = BaseLayoutRule.getMaxMatchDistance();
if (vEdge.edgeType == LEFT) {
int margin = mSnap ? 0 : abs(newBounds.x - x);
if (margin > maxDistance) {
mLeftMargin = margin;
} else {
newBounds.w += newBounds.x - x;
newBounds.x = x;
}
} else if (vEdge.edgeType == RIGHT) {
int margin = mSnap ? 0 : abs(newBounds.x - (x - newBounds.w));
if (margin > maxDistance) {
mRightMargin = margin;
} else {
newBounds.w = x - newBounds.x;
}
} else {
assert false : vEdge;
}
}
@Override
protected void snapHorizontal(Segment hEdge, int y, Rect newBounds) {
int maxDistance = BaseLayoutRule.getMaxMatchDistance();
if (hEdge.edgeType == TOP) {
int margin = mSnap ? 0 : abs(newBounds.y - y);
if (margin > maxDistance) {
mTopMargin = margin;
} else {
newBounds.h += newBounds.y - y;
newBounds.y = y;
}
} else if (hEdge.edgeType == BOTTOM) {
int margin = mSnap ? 0 : abs(newBounds.y - (y - newBounds.h));
if (margin > maxDistance) {
mBottomMargin = margin;
} else {
newBounds.h = y - newBounds.y;
}
} else {
assert false : hEdge;
}
}
@Override
protected boolean isEdgeTypeCompatible(SegmentType edge, SegmentType dragged, int delta) {
boolean compatible = super.isEdgeTypeCompatible(edge, dragged, delta);
// When resizing and not snapping (e.g. using margins to pick a specific pixel
// width) we cannot use -negative- margins to jump back to a closer edge; we
// must always use positive margins, so mark closer edges that result in a negative
// margin as not compatible.
if (compatible && !mSnap) {
switch (dragged) {
case LEFT:
case TOP:
return delta <= 0;
default:
return delta >= 0;
}
}
return compatible;
}
/**
* Updates the handler for the given mouse resize
*
* @param feedback the feedback handler
* @param child the node being resized
* @param newBounds the new bounds of the resize rectangle
* @param modifierMask the keyboard modifiers pressed during the drag
*/
public void updateResize(DropFeedback feedback, INode child, Rect newBounds,
int modifierMask) {
mSnap = (modifierMask & DropFeedback.MODIFIER2) == 0;
mBounds = newBounds;
clearSuggestions();
Rect b = newBounds;
Segment hEdge = null;
Segment vEdge = null;
String childId = child.getStringAttr(ANDROID_URI, ATTR_ID);
// TODO: MarginType=NO_MARGIN may not be right. Consider resizing a widget
// that has margins and how that should be handled.
if (mHorizontalEdgeType == TOP) {
hEdge = new Segment(b.y, b.x, b.x2(), child, childId, mHorizontalEdgeType, NO_MARGIN);
} else if (mHorizontalEdgeType == BOTTOM) {
hEdge = new Segment(b.y2(), b.x, b.x2(), child, childId, mHorizontalEdgeType,
NO_MARGIN);
} else {
assert mHorizontalEdgeType == null;
}
if (mVerticalEdgeType == LEFT) {
vEdge = new Segment(b.x, b.y, b.y2(), child, childId, mVerticalEdgeType, NO_MARGIN);
} else if (mVerticalEdgeType == RIGHT) {
vEdge = new Segment(b.x2(), b.y, b.y2(), child, childId, mVerticalEdgeType, NO_MARGIN);
} else {
assert mVerticalEdgeType == null;
}
mTopMargin = mBottomMargin = mLeftMargin = mRightMargin = 0;
if (hEdge != null && mHorizontalEdges.size() > 0) {
// Compute horizontal matches
mHorizontalSuggestions = findClosest(hEdge, mHorizontalEdges);
Match match = pickBestMatch(mHorizontalSuggestions);
if (match != null
&& (!mSnap || Math.abs(match.delta) < BaseLayoutRule.getMaxMatchDistance())) {
if (mHorizontalDeps.contains(match.edge.node)) {
match.cycle = true;
}
snapHorizontal(hEdge, match.edge.at, newBounds);
if (hEdge.edgeType == TOP) {
mCurrentTopMatch = match;
} else if (hEdge.edgeType == BOTTOM) {
mCurrentBottomMatch = match;
} else {
assert hEdge.edgeType == CENTER_HORIZONTAL
|| hEdge.edgeType == BASELINE : hEdge;
mCurrentTopMatch = match;
}
}
}
if (vEdge != null && mVerticalEdges.size() > 0) {
mVerticalSuggestions = findClosest(vEdge, mVerticalEdges);
Match match = pickBestMatch(mVerticalSuggestions);
if (match != null
&& (!mSnap || Math.abs(match.delta) < BaseLayoutRule.getMaxMatchDistance())) {
if (mVerticalDeps.contains(match.edge.node)) {
match.cycle = true;
}
// Snap
snapVertical(vEdge, match.edge.at, newBounds);
if (vEdge.edgeType == LEFT) {
mCurrentLeftMatch = match;
} else if (vEdge.edgeType == RIGHT) {
mCurrentRightMatch = match;
} else {
assert vEdge.edgeType == CENTER_VERTICAL;
mCurrentLeftMatch = match;
}
}
}
checkCycles(feedback);
}
}