/*
* 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.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_RESOURCE_PREFIX;
import static com.android.SdkConstants.ID_PREFIX;
import static com.android.SdkConstants.NEW_ID_PREFIX;
import com.android.annotations.NonNull;
import com.android.ide.common.api.DrawingStyle;
import com.android.ide.common.api.DropFeedback;
import com.android.ide.common.api.IFeedbackPainter;
import com.android.ide.common.api.IGraphics;
import com.android.ide.common.api.INode;
import com.android.ide.common.api.Point;
import com.android.ide.common.api.Rect;
import com.android.ide.common.api.SegmentType;
import com.android.ide.common.layout.relative.DependencyGraph.Constraint;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* The {@link GuidelinePainter} is responsible for painting guidelines during an operation
* which uses a {@link GuidelineHandler} such as a resize operation.
*/
public final class GuidelinePainter implements IFeedbackPainter {
// ---- Implements IFeedbackPainter ----
@Override
public void paint(@NonNull IGraphics gc, @NonNull INode node, @NonNull DropFeedback feedback) {
GuidelineHandler state = (GuidelineHandler) feedback.userData;
for (INode dragged : state.mDraggedNodes) {
gc.useStyle(DrawingStyle.DRAGGED);
Rect bounds = dragged.getBounds();
if (bounds.isValid()) {
gc.fillRect(bounds);
}
}
Set<INode> horizontalDeps = state.mHorizontalDeps;
Set<INode> verticalDeps = state.mVerticalDeps;
Set<INode> deps = new HashSet<INode>(horizontalDeps.size() + verticalDeps.size());
deps.addAll(horizontalDeps);
deps.addAll(verticalDeps);
if (deps.size() > 0) {
gc.useStyle(DrawingStyle.DEPENDENCY);
for (INode n : deps) {
// Don't highlight the selected nodes themselves
if (state.mDraggedNodes.contains(n)) {
continue;
}
Rect bounds = n.getBounds();
gc.fillRect(bounds);
}
}
if (state.mBounds != null) {
if (state instanceof MoveHandler) {
gc.useStyle(DrawingStyle.DROP_PREVIEW);
} else {
// Resizing
if (state.haveSuggestions()) {
gc.useStyle(DrawingStyle.RESIZE_PREVIEW);
} else {
gc.useStyle(DrawingStyle.RESIZE_FAIL);
}
}
gc.drawRect(state.mBounds);
// Draw baseline preview too
if (feedback.dragBaseline != -1) {
int y = state.mBounds.y + feedback.dragBaseline;
gc.drawLine(state.mBounds.x, y, state.mBounds.x2(), y);
}
}
List<String> strings = new ArrayList<String>();
showMatch(gc, state.mCurrentLeftMatch, state, strings,
state.mLeftMargin, ATTR_LAYOUT_MARGIN_LEFT);
showMatch(gc, state.mCurrentRightMatch, state, strings,
state.mRightMargin, ATTR_LAYOUT_MARGIN_RIGHT);
showMatch(gc, state.mCurrentTopMatch, state, strings,
state.mTopMargin, ATTR_LAYOUT_MARGIN_TOP);
showMatch(gc, state.mCurrentBottomMatch, state, strings,
state.mBottomMargin, ATTR_LAYOUT_MARGIN_BOTTOM);
if (strings.size() > 0) {
// Update the drag tooltip
StringBuilder sb = new StringBuilder(200);
for (String s : strings) {
if (sb.length() > 0) {
sb.append('\n');
}
sb.append(s);
}
feedback.tooltip = sb.toString();
// Set the tooltip orientation to ensure that it does not interfere with
// the constraint arrows
if (state.mCurrentLeftMatch != null) {
feedback.tooltipX = SegmentType.RIGHT;
} else if (state.mCurrentRightMatch != null) {
feedback.tooltipX = SegmentType.LEFT;
}
if (state.mCurrentTopMatch != null) {
feedback.tooltipY = SegmentType.BOTTOM;
} else if (state.mCurrentBottomMatch != null) {
feedback.tooltipY = SegmentType.TOP;
}
} else {
feedback.tooltip = null;
}
if (state.mHorizontalCycle != null) {
paintCycle(gc, state, state.mHorizontalCycle);
}
if (state.mVerticalCycle != null) {
paintCycle(gc, state, state.mVerticalCycle);
}
}
/** Paints a particular match constraint */
private void showMatch(IGraphics gc, Match m, GuidelineHandler state, List<String> strings,
int margin, String marginAttribute) {
if (m == null) {
return;
}
ConstraintPainter.paintConstraint(gc, state.mBounds, m);
// Display the constraint. Remove the @id/ and @+id/ prefixes to make the text
// shorter and easier to read. This doesn't use stripPrefix() because the id is
// usually not a prefix of the value (for example, 'layout_alignBottom=@+id/foo').
String constraint = m.getConstraint(false /* generateId */);
String description = constraint.replace(NEW_ID_PREFIX, "").replace(ID_PREFIX, "");
if (description.startsWith(ATTR_LAYOUT_RESOURCE_PREFIX)) {
description = description.substring(ATTR_LAYOUT_RESOURCE_PREFIX.length());
}
if (margin > 0) {
int dp = state.getRulesEngine().pxToDp(margin);
description = String.format("%1$s, margin=%2$d dp", description, dp);
}
strings.add(description);
}
/** Paints a constraint cycle */
void paintCycle(IGraphics gc, GuidelineHandler state, List<Constraint> cycle) {
gc.useStyle(DrawingStyle.CYCLE);
assert cycle.size() > 0;
INode from = cycle.get(0).from.node;
Rect fromBounds = from.getBounds();
if (state.mDraggedNodes.contains(from)) {
fromBounds = state.mBounds;
}
Point fromCenter = fromBounds.center();
INode to = null;
List<Point> points = new ArrayList<Point>();
points.add(fromCenter);
for (Constraint constraint : cycle) {
assert constraint.from.node == from;
to = constraint.to.node;
assert from != null && to != null;
Point toCenter = to.getBounds().center();
points.add(toCenter);
// Also go through the dragged node bounds
boolean isDragged = state.mDraggedNodes.contains(to);
if (isDragged) {
toCenter = state.mBounds.center();
points.add(toCenter);
}
from = to;
fromCenter = toCenter;
}
points.add(fromCenter);
points.add(points.get(0));
for (int i = 1, n = points.size(); i < n; i++) {
gc.drawLine(points.get(i-1), points.get(i));
}
}
}