xref: /sdk/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/ResizeGesture.java

/*
 * 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.eclipse.adt.internal.editors.layout.gle2;

import com.android.ide.common.api.DropFeedback;
import com.android.ide.common.api.Rect;
import com.android.ide.common.api.ResizePolicy;
import com.android.ide.common.api.SegmentType;
import com.android.ide.eclipse.adt.internal.editors.layout.gle2.SelectionHandle.Position;
import com.android.ide.eclipse.adt.internal.editors.layout.gre.NodeProxy;
import com.android.ide.eclipse.adt.internal.editors.layout.gre.RulesEngine;
import com.android.utils.Pair;

import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.graphics.GC;

import java.util.Collections;
import java.util.List;

/**
 * A {@link ResizeGesture} is a gesture for resizing a selected widget. It is initiated
 * by a drag of a {@link SelectionHandle}.
 */
public class ResizeGesture extends Gesture {
    /** The {@link Overlay} drawn for the gesture feedback. */
    private ResizeOverlay mOverlay;

    /** The canvas associated with this gesture. */
    private LayoutCanvas mCanvas;

    /** The selection handle we're dragging to perform this resize */
    private SelectionHandle mHandle;

    private NodeProxy mParentNode;
    private NodeProxy mChildNode;
    private DropFeedback mFeedback;
    private ResizePolicy mResizePolicy;
    private SegmentType mHorizontalEdge;
    private SegmentType mVerticalEdge;

    /**
     * Creates a new marquee selection (selection swiping).
     *
     * @param canvas The canvas where selection is performed.
     * @param item The selected item the handle corresponds to
     * @param handle The handle being dragged to perform the resize
     */
    public ResizeGesture(LayoutCanvas canvas, SelectionItem item, SelectionHandle handle) {
        mCanvas = canvas;
        mHandle = handle;

        mChildNode = item.getNode();
        mParentNode = (NodeProxy) mChildNode.getParent();
        mResizePolicy = item.getResizePolicy();
        mHorizontalEdge = getHorizontalEdgeType(mHandle);
        mVerticalEdge = getVerticalEdgeType(mHandle);
    }

    @Override
    public void begin(ControlPoint pos, int startMask) {
        super.begin(pos, startMask);

        mCanvas.getSelectionOverlay().setHidden(true);

        RulesEngine rulesEngine = mCanvas.getRulesEngine();
        Rect newBounds = getNewBounds(pos);
        ViewHierarchy viewHierarchy = mCanvas.getViewHierarchy();
        CanvasViewInfo childInfo = viewHierarchy.findViewInfoFor(mChildNode);
        CanvasViewInfo parentInfo = viewHierarchy.findViewInfoFor(mParentNode);
        Object childView = childInfo != null ? childInfo.getViewObject() : null;
        Object parentView = parentInfo != null ? parentInfo.getViewObject() : null;
        mFeedback = rulesEngine.callOnResizeBegin(mChildNode, mParentNode, newBounds,
                mHorizontalEdge, mVerticalEdge, childView, parentView);
        update(pos);
        mCanvas.getGestureManager().updateMessage(mFeedback);
    }

    @Override
    public boolean keyPressed(KeyEvent event) {
        update(mCanvas.getGestureManager().getCurrentControlPoint());
        mCanvas.redraw();
        return true;
    }

    @Override
    public boolean keyReleased(KeyEvent event) {
        update(mCanvas.getGestureManager().getCurrentControlPoint());
        mCanvas.redraw();
        return true;
    }

    @Override
    public void update(ControlPoint pos) {
        super.update(pos);
        RulesEngine rulesEngine = mCanvas.getRulesEngine();
        Rect newBounds = getNewBounds(pos);
        int modifierMask = mCanvas.getGestureManager().getRuleModifierMask();
        rulesEngine.callOnResizeUpdate(mFeedback, mChildNode, mParentNode, newBounds,
                modifierMask);
        mCanvas.getGestureManager().updateMessage(mFeedback);
    }

    @Override
    public void end(ControlPoint pos, boolean canceled) {
        super.end(pos, canceled);

        if (!canceled) {
            RulesEngine rulesEngine = mCanvas.getRulesEngine();
            Rect newBounds = getNewBounds(pos);
            rulesEngine.callOnResizeEnd(mFeedback, mChildNode, mParentNode, newBounds);
        }

        mCanvas.getSelectionOverlay().setHidden(false);
    }

    @Override
    public Pair<Boolean, Boolean> getTooltipPosition() {
        return Pair.of(mHorizontalEdge != SegmentType.TOP, mVerticalEdge != SegmentType.LEFT);
    }

    /**
     * For the new mouse position, compute the resized bounds (the bounding rectangle that
     * the view should be resized to). This is not just a width or height, since in some
     * cases resizing will change the x/y position of the view as well (for example, in
     * RelativeLayout or in AbsoluteLayout).
     */
    private Rect getNewBounds(ControlPoint pos) {
        LayoutPoint p = pos.toLayout();
        LayoutPoint start = mStart.toLayout();
        Rect b = mChildNode.getBounds();
        Position direction = mHandle.getPosition();

        int x = b.x;
        int y = b.y;
        int w = b.w;
        int h = b.h;
        int deltaX = p.x - start.x;
        int deltaY = p.y - start.y;

        if (deltaX == 0 && deltaY == 0) {
            // No move - just use the existing bounds
            return b;
        }

        if (mResizePolicy.isAspectPreserving() && w != 0 && h != 0) {
            double aspectRatio = w / (double) h;
            int newW = Math.abs(b.w + (direction.isLeft() ? -deltaX : deltaX));
            int newH = Math.abs(b.h + (direction.isTop() ? -deltaY : deltaY));
            double newAspectRatio = newW / (double) newH;
            if (newH == 0 || newAspectRatio > aspectRatio) {
                deltaY = (int) (deltaX / aspectRatio);
            } else {
                deltaX = (int) (deltaY * aspectRatio);
            }
        }
        if (direction.isLeft()) {
            // The user is dragging the left edge, so the position is anchored on the
            // right.
            int x2 = b.x + b.w;
            int nx1 = b.x + deltaX;
            if (nx1 <= x2) {
                x = nx1;
                w = x2 - x;
            } else {
                w = 0;
                x = x2;
            }
        } else if (direction.isRight()) {
            // The user is dragging the right edge, so the position is anchored on the
            // left.
            int nx2 = b.x + b.w + deltaX;
            if (nx2 >= b.x) {
                w = nx2 - b.x;
            } else {
                w = 0;
            }
        } else {
            assert direction == Position.BOTTOM_MIDDLE || direction == Position.TOP_MIDDLE;
        }

        if (direction.isTop()) {
            // The user is dragging the top edge, so the position is anchored on the
            // bottom.
            int y2 = b.y + b.h;
            int ny1 = b.y + deltaY;
            if (ny1 < y2) {
                y = ny1;
                h = y2 - y;
            } else {
                h = 0;
                y = y2;
            }
        } else if (direction.isBottom()) {
            // The user is dragging the bottom edge, so the position is anchored on the
            // top.
            int ny2 = b.y + b.h + deltaY;
            if (ny2 >= b.y) {
                h = ny2 - b.y;
            } else {
                h = 0;
            }
        } else {
            assert direction == Position.LEFT_MIDDLE || direction == Position.RIGHT_MIDDLE;
        }

        return new Rect(x, y, w, h);
    }

    private static SegmentType getHorizontalEdgeType(SelectionHandle handle) {
        switch (handle.getPosition()) {
            case BOTTOM_LEFT:
            case BOTTOM_RIGHT:
            case BOTTOM_MIDDLE:
                return SegmentType.BOTTOM;
            case LEFT_MIDDLE:
            case RIGHT_MIDDLE:
                return null;
            case TOP_LEFT:
            case TOP_MIDDLE:
            case TOP_RIGHT:
                return SegmentType.TOP;
            default: assert false : handle.getPosition();
        }
        return null;
    }

    private static SegmentType getVerticalEdgeType(SelectionHandle handle) {
        switch (handle.getPosition()) {
            case TOP_LEFT:
            case LEFT_MIDDLE:
            case BOTTOM_LEFT:
                return SegmentType.LEFT;
            case BOTTOM_MIDDLE:
            case TOP_MIDDLE:
                return null;
            case TOP_RIGHT:
            case RIGHT_MIDDLE:
            case BOTTOM_RIGHT:
                return SegmentType.RIGHT;
            default: assert false : handle.getPosition();
        }
        return null;
    }


    @Override
    public List<Overlay> createOverlays() {
        mOverlay = new ResizeOverlay();
        return Collections.<Overlay> singletonList(mOverlay);
    }

    /**
     * An {@link Overlay} to paint the resize feedback. This just delegates to the
     * layout rule for the parent which is handling the resizing.
     */
    private class ResizeOverlay extends Overlay {
        @Override
        public void paint(GC gc) {
            if (mChildNode != null && mFeedback != null) {
                RulesEngine rulesEngine = mCanvas.getRulesEngine();
                rulesEngine.callDropFeedbackPaint(mCanvas.getGcWrapper(), mChildNode, mFeedback);
            }
        }
    }
}