/*
* 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.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.ide.common.api.SegmentType.UNKNOWN;
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_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_TO_LEFT_OF;
import static com.android.SdkConstants.ATTR_LAYOUT_TO_RIGHT_OF;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.ide.common.api.SegmentType;
import java.util.HashMap;
import java.util.Map;
/**
* Each constraint type corresponds to a type of constraint available for the
* RelativeLayout; for example, {@link #LAYOUT_ABOVE} corresponds to the layout_above constraint.
*/
enum ConstraintType {
LAYOUT_ABOVE(ATTR_LAYOUT_ABOVE,
null /* sourceX */, BOTTOM, null /* targetX */, TOP,
false /* targetParent */, true /* horizontalEdge */, false /* verticalEdge */,
true /* relativeToMargin */),
LAYOUT_BELOW(ATTR_LAYOUT_BELOW, null, TOP, null, BOTTOM, false, true, false, true),
ALIGN_TOP(ATTR_LAYOUT_ALIGN_TOP, null, TOP, null, TOP, false, true, false, false),
ALIGN_BOTTOM(ATTR_LAYOUT_ALIGN_BOTTOM, null, BOTTOM, null, BOTTOM, false, true, false, false),
ALIGN_LEFT(ATTR_LAYOUT_ALIGN_LEFT, LEFT, null, LEFT, null, false, false, true, false),
ALIGN_RIGHT(ATTR_LAYOUT_ALIGN_RIGHT, RIGHT, null, RIGHT, null, false, false, true, false),
LAYOUT_LEFT_OF(ATTR_LAYOUT_TO_LEFT_OF, RIGHT, null, LEFT, null, false, false, true, true),
LAYOUT_RIGHT_OF(ATTR_LAYOUT_TO_RIGHT_OF, LEFT, null, RIGHT, null, false, false, true, true),
ALIGN_PARENT_TOP(ATTR_LAYOUT_ALIGN_PARENT_TOP, null, TOP, null, TOP, true, true, false, false),
ALIGN_BASELINE(ATTR_LAYOUT_ALIGN_BASELINE, null, BASELINE, null, BASELINE, false, true, false,
false),
ALIGN_PARENT_LEFT(ATTR_LAYOUT_ALIGN_PARENT_LEFT, LEFT, null, LEFT, null, true, false, true,
false),
ALIGN_PARENT_RIGHT(ATTR_LAYOUT_ALIGN_PARENT_RIGHT, RIGHT, null, RIGHT, null, true, false, true,
false),
ALIGN_PARENT_BOTTOM(ATTR_LAYOUT_ALIGN_PARENT_BOTTOM, null, BOTTOM, null, BOTTOM, true, true,
false, false),
LAYOUT_CENTER_HORIZONTAL(ATTR_LAYOUT_CENTER_HORIZONTAL, CENTER_VERTICAL, null, CENTER_VERTICAL,
null, true, true, false, false),
LAYOUT_CENTER_VERTICAL(ATTR_LAYOUT_CENTER_VERTICAL, null, CENTER_HORIZONTAL, null,
CENTER_HORIZONTAL, true, false, true, false),
LAYOUT_CENTER_IN_PARENT(ATTR_LAYOUT_CENTER_IN_PARENT, CENTER_VERTICAL, CENTER_HORIZONTAL,
CENTER_VERTICAL, CENTER_HORIZONTAL, true, true, true, false);
private ConstraintType(String name, SegmentType sourceSegmentTypeX,
SegmentType sourceSegmentTypeY, SegmentType targetSegmentTypeX,
SegmentType targetSegmentTypeY, boolean targetParent, boolean horizontalEdge,
boolean verticalEdge, boolean relativeToMargin) {
assert horizontalEdge || verticalEdge;
this.name = name;
this.sourceSegmentTypeX = sourceSegmentTypeX != null ? sourceSegmentTypeX : UNKNOWN;
this.sourceSegmentTypeY = sourceSegmentTypeY != null ? sourceSegmentTypeY : UNKNOWN;
this.targetSegmentTypeX = targetSegmentTypeX != null ? targetSegmentTypeX : UNKNOWN;
this.targetSegmentTypeY = targetSegmentTypeY != null ? targetSegmentTypeY : UNKNOWN;
this.targetParent = targetParent;
this.horizontalEdge = horizontalEdge;
this.verticalEdge = verticalEdge;
this.relativeToMargin = relativeToMargin;
}
/** The attribute name of the constraint */
public final String name;
/** The horizontal position of the source of the constraint */
public final SegmentType sourceSegmentTypeX;
/** The vertical position of the source of the constraint */
public final SegmentType sourceSegmentTypeY;
/** The horizontal position of the target of the constraint */
public final SegmentType targetSegmentTypeX;
/** The vertical position of the target of the constraint */
public final SegmentType targetSegmentTypeY;
/**
* If true, the constraint targets the parent layout, otherwise it targets another
* view
*/
public final boolean targetParent;
/** If true, this constraint affects the horizontal dimension */
public final boolean horizontalEdge;
/** If true, this constraint affects the vertical dimension */
public final boolean verticalEdge;
/**
* Whether this constraint is relative to the margin bounds of the node rather than
* the node's actual bounds
*/
public final boolean relativeToMargin;
/** Map from attribute name to constraint type */
private static Map<String, ConstraintType> sNameToType;
/**
* Returns the {@link ConstraintType} corresponding to the given attribute name, or
* null if not found.
*
* @param attribute the name of the attribute to look up
* @return the corresponding {@link ConstraintType}
*/
@Nullable
public static ConstraintType fromAttribute(@NonNull String attribute) {
if (sNameToType == null) {
ConstraintType[] types = ConstraintType.values();
Map<String, ConstraintType> map = new HashMap<String, ConstraintType>(types.length);
for (ConstraintType type : types) {
map.put(type.name, type);
}
sNameToType = map;
}
return sNameToType.get(attribute);
}
/**
* Returns true if this constraint type represents a constraint where the target edge
* is one of the parent edges (actual edge, not center/baseline segments)
*
* @return true if the target segment is a parent edge
*/
public boolean isRelativeToParentEdge() {
return this == ALIGN_PARENT_LEFT || this == ALIGN_PARENT_RIGHT || this == ALIGN_PARENT_TOP
|| this == ALIGN_PARENT_BOTTOM;
}
/**
* Returns a {@link ConstraintType} for a potential match of edges.
*
* @param withParent if true, the target is the parent
* @param from the source edge
* @param to the target edge
* @return a {@link ConstraintType}, or null
*/
@Nullable
public static ConstraintType forMatch(boolean withParent, SegmentType from, SegmentType to) {
// Attached to parent edge?
if (withParent) {
switch (from) {
case TOP:
return ALIGN_PARENT_TOP;
case BOTTOM:
return ALIGN_PARENT_BOTTOM;
case LEFT:
return ALIGN_PARENT_LEFT;
case RIGHT:
return ALIGN_PARENT_RIGHT;
case CENTER_HORIZONTAL:
return LAYOUT_CENTER_VERTICAL;
case CENTER_VERTICAL:
return LAYOUT_CENTER_HORIZONTAL;
}
return null;
}
// Attached to some other node.
switch (from) {
case TOP:
switch (to) {
case TOP:
return ALIGN_TOP;
case BOTTOM:
return LAYOUT_BELOW;
case BASELINE:
return ALIGN_BASELINE;
}
break;
case BOTTOM:
switch (to) {
case TOP:
return LAYOUT_ABOVE;
case BOTTOM:
return ALIGN_BOTTOM;
case BASELINE:
return ALIGN_BASELINE;
}
break;
case LEFT:
switch (to) {
case LEFT:
return ALIGN_LEFT;
case RIGHT:
return LAYOUT_RIGHT_OF;
}
break;
case RIGHT:
switch (to) {
case LEFT:
return LAYOUT_LEFT_OF;
case RIGHT:
return ALIGN_RIGHT;
}
break;
case BASELINE:
return ALIGN_BASELINE;
}
return null;
}
}