| /* |
| * 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.IDragElement; |
| 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.layout.BaseLayoutRule; |
| import com.android.ide.common.layout.relative.DependencyGraph.ViewData; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** |
| * A {@link MoveHandler} is a {@link GuidelineHandler} which handles move and drop |
| * gestures, and offers guideline suggestions and snapping. |
| * <p> |
| * Unlike the {@link ResizeHandler}, the {@link MoveHandler} looks for matches for all |
| * different segment types -- the left edge, the right edge, the baseline, the center |
| * edges, and so on -- and picks the best among these. |
| */ |
| public class MoveHandler extends GuidelineHandler { |
| private int mDraggedBaseline; |
| |
| /** |
| * Creates a new {@link MoveHandler}. |
| * |
| * @param layout the layout element the handler is operating on |
| * @param elements the elements being dragged in the move operation |
| * @param rulesEngine the corresponding {@link IClientRulesEngine} |
| */ |
| public MoveHandler(INode layout, IDragElement[] elements, IClientRulesEngine rulesEngine) { |
| super(layout, rulesEngine); |
| |
| // Compute list of nodes being dragged within the layout, if any |
| List<INode> nodes = new ArrayList<INode>(); |
| for (IDragElement element : elements) { |
| ViewData view = mDependencyGraph.getView(element); |
| if (view != null) { |
| nodes.add(view.node); |
| } |
| } |
| mDraggedNodes = nodes; |
| |
| mHorizontalDeps = mDependencyGraph.dependsOn(nodes, false /* verticalEdge */); |
| mVerticalDeps = mDependencyGraph.dependsOn(nodes, true /* verticalEdge */); |
| |
| for (INode child : layout.getChildren()) { |
| Rect bc = child.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 (bc.equals(element.getBounds())) { |
| isDragged = true; |
| } |
| } |
| |
| if (!isDragged) { |
| String id = child.getStringAttr(ANDROID_URI, ATTR_ID); |
| // It's okay for id to be null; if you apply a constraint |
| // to a node with a missing id we will generate the id |
| |
| boolean addHorizontal = !mHorizontalDeps.contains(child); |
| boolean addVertical = !mVerticalDeps.contains(child); |
| |
| addBounds(child, id, addHorizontal, addVertical); |
| if (addHorizontal) { |
| addBaseLine(child, id); |
| } |
| } |
| } |
| } |
| |
| String id = layout.getStringAttr(ANDROID_URI, ATTR_ID); |
| addBounds(layout, id, true, true); |
| addCenter(layout, 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.x = x; |
| } |
| } else if (vEdge.edgeType == RIGHT) { |
| int margin = !mSnap ? 0 : abs(newBounds.x - (x - newBounds.w)); |
| if (margin > maxDistance) { |
| mRightMargin = margin; |
| } else { |
| newBounds.x = x - newBounds.w; |
| } |
| } else if (vEdge.edgeType == CENTER_VERTICAL) { |
| newBounds.x = x - newBounds.w / 2; |
| } else { |
| assert false : vEdge; |
| } |
| } |
| |
| // TODO: Consider unifying this with the snapping logic in ResizeHandler |
| @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.y = y; |
| } |
| } else if (hEdge.edgeType == BOTTOM) { |
| int margin = !mSnap ? 0 : abs(newBounds.y - (y - newBounds.h)); |
| if (margin > maxDistance) { |
| mBottomMargin = margin; |
| } else { |
| newBounds.y = y - newBounds.h; |
| } |
| } else if (hEdge.edgeType == CENTER_HORIZONTAL) { |
| int margin = !mSnap ? 0 : abs(newBounds.y - (y - newBounds.h / 2)); |
| if (margin > maxDistance) { |
| mTopMargin = margin; |
| // or bottomMargin? |
| } else { |
| newBounds.y = y - newBounds.h / 2; |
| } |
| } else if (hEdge.edgeType == BASELINE) { |
| newBounds.y = y - mDraggedBaseline; |
| } else { |
| assert false : hEdge; |
| } |
| } |
| |
| /** |
| * Updates the handler for the given mouse move |
| * |
| * @param feedback the feedback handler |
| * @param elements the elements being dragged |
| * @param offsetX the new mouse X coordinate |
| * @param offsetY the new mouse Y coordinate |
| * @param modifierMask the keyboard modifiers pressed during the drag |
| */ |
| public void updateMove(DropFeedback feedback, IDragElement[] elements, |
| int offsetX, int offsetY, int modifierMask) { |
| mSnap = (modifierMask & DropFeedback.MODIFIER2) == 0; |
| |
| Rect firstBounds = elements[0].getBounds(); |
| INode firstNode = null; |
| if (mDraggedNodes != null && mDraggedNodes.size() > 0) { |
| // TODO - this isn't quite right; this could be a different node than we have |
| // bounds for! |
| firstNode = mDraggedNodes.iterator().next(); |
| firstBounds = firstNode.getBounds(); |
| } |
| |
| mBounds = new Rect(offsetX, offsetY, firstBounds.w, firstBounds.h); |
| Rect layoutBounds = layout.getBounds(); |
| if (mBounds.x2() > layoutBounds.x2()) { |
| mBounds.x -= mBounds.x2() - layoutBounds.x2(); |
| } |
| if (mBounds.y2() > layoutBounds.y2()) { |
| mBounds.y -= mBounds.y2() - layoutBounds.y2(); |
| } |
| if (mBounds.x < layoutBounds.x) { |
| mBounds.x = layoutBounds.x; |
| } |
| if (mBounds.y < layoutBounds.y) { |
| mBounds.y = layoutBounds.y; |
| } |
| |
| clearSuggestions(); |
| |
| Rect b = mBounds; |
| Segment edge = new Segment(b.y, b.x, b.x2(), null, null, TOP, NO_MARGIN); |
| List<Match> horizontalMatches = findClosest(edge, mHorizontalEdges); |
| edge = new Segment(b.y2(), b.x, b.x2(), null, null, BOTTOM, NO_MARGIN); |
| addClosest(edge, mHorizontalEdges, horizontalMatches); |
| |
| edge = new Segment(b.x, b.y, b.y2(), null, null, LEFT, NO_MARGIN); |
| List<Match> verticalMatches = findClosest(edge, mVerticalEdges); |
| edge = new Segment(b.x2(), b.y, b.y2(), null, null, RIGHT, NO_MARGIN); |
| addClosest(edge, mVerticalEdges, verticalMatches); |
| |
| // Match center |
| edge = new Segment(b.centerX(), b.y, b.y2(), null, null, CENTER_VERTICAL, NO_MARGIN); |
| addClosest(edge, mCenterVertEdges, verticalMatches); |
| edge = new Segment(b.centerY(), b.x, b.x2(), null, null, CENTER_HORIZONTAL, NO_MARGIN); |
| addClosest(edge, mCenterHorizEdges, horizontalMatches); |
| |
| // Match baseline |
| if (firstNode != null) { |
| int baseline = firstNode.getBaseline(); |
| if (baseline != -1) { |
| mDraggedBaseline = baseline; |
| edge = new Segment(b.y + baseline, b.x, b.x2(), firstNode, null, BASELINE, |
| NO_MARGIN); |
| addClosest(edge, mHorizontalEdges, horizontalMatches); |
| } |
| } else { |
| int baseline = feedback.dragBaseline; |
| if (baseline != -1) { |
| mDraggedBaseline = baseline; |
| edge = new Segment(offsetY + baseline, b.x, b.x2(), null, null, BASELINE, |
| NO_MARGIN); |
| addClosest(edge, mHorizontalEdges, horizontalMatches); |
| } |
| } |
| |
| mHorizontalSuggestions = horizontalMatches; |
| mVerticalSuggestions = verticalMatches; |
| mTopMargin = mBottomMargin = mLeftMargin = mRightMargin = 0; |
| |
| Match match = pickBestMatch(mHorizontalSuggestions); |
| if (match != null) { |
| if (mHorizontalDeps.contains(match.edge.node)) { |
| match.cycle = true; |
| } |
| |
| // Reset top AND bottom bounds regardless of whether both are bound |
| mMoveTop = true; |
| mMoveBottom = true; |
| |
| // TODO: Consider doing the snap logic on all the possible matches |
| // BEFORE sorting, in case this affects the best-pick algorithm (since some |
| // edges snap and others don't). |
| snapHorizontal(match.with, match.edge.at, mBounds); |
| |
| if (match.with.edgeType == TOP) { |
| mCurrentTopMatch = match; |
| } else if (match.with.edgeType == BOTTOM) { |
| mCurrentBottomMatch = match; |
| } else { |
| assert match.with.edgeType == CENTER_HORIZONTAL |
| || match.with.edgeType == BASELINE : match.with.edgeType; |
| mCurrentTopMatch = match; |
| } |
| } |
| |
| match = pickBestMatch(mVerticalSuggestions); |
| if (match != null) { |
| if (mVerticalDeps.contains(match.edge.node)) { |
| match.cycle = true; |
| } |
| |
| // Reset left AND right bounds regardless of whether both are bound |
| mMoveLeft = true; |
| mMoveRight = true; |
| |
| snapVertical(match.with, match.edge.at, mBounds); |
| |
| if (match.with.edgeType == LEFT) { |
| mCurrentLeftMatch = match; |
| } else if (match.with.edgeType == RIGHT) { |
| mCurrentRightMatch = match; |
| } else { |
| assert match.with.edgeType == CENTER_VERTICAL; |
| mCurrentLeftMatch = match; |
| } |
| } |
| |
| checkCycles(feedback); |
| } |
| } |
