/*
* Copyright (C) 2010 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;
import static com.android.SdkConstants.ANDROID_URI;
import static com.android.SdkConstants.ATTR_CLASS;
import static com.android.SdkConstants.ATTR_HINT;
import static com.android.SdkConstants.ATTR_ID;
import static com.android.SdkConstants.ATTR_LAYOUT_HEIGHT;
import static com.android.SdkConstants.ATTR_LAYOUT_RESOURCE_PREFIX;
import static com.android.SdkConstants.ATTR_LAYOUT_WIDTH;
import static com.android.SdkConstants.ATTR_STYLE;
import static com.android.SdkConstants.ATTR_TEXT;
import static com.android.SdkConstants.DOT_LAYOUT_PARAMS;
import static com.android.SdkConstants.ID_PREFIX;
import static com.android.SdkConstants.NEW_ID_PREFIX;
import static com.android.SdkConstants.VALUE_FALSE;
import static com.android.SdkConstants.VALUE_FILL_PARENT;
import static com.android.SdkConstants.VALUE_MATCH_PARENT;
import static com.android.SdkConstants.VALUE_TRUE;
import static com.android.SdkConstants.VALUE_WRAP_CONTENT;
import static com.android.SdkConstants.VIEW_FRAGMENT;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.ide.common.api.AbstractViewRule;
import com.android.ide.common.api.IAttributeInfo;
import com.android.ide.common.api.IAttributeInfo.Format;
import com.android.ide.common.api.IClientRulesEngine;
import com.android.ide.common.api.IDragElement;
import com.android.ide.common.api.IMenuCallback;
import com.android.ide.common.api.INode;
import com.android.ide.common.api.IViewMetadata;
import com.android.ide.common.api.IViewRule;
import com.android.ide.common.api.RuleAction;
import com.android.ide.common.api.RuleAction.ActionProvider;
import com.android.ide.common.api.RuleAction.ChoiceProvider;
import com.android.resources.ResourceType;
import com.android.utils.Pair;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* Common IViewRule processing to all view and layout classes.
*/
public class BaseViewRule extends AbstractViewRule {
/** List of recently edited properties */
private static List<String> sRecent = new LinkedList<String>();
/** Maximum number of recent properties to track and list */
private final static int MAX_RECENT_COUNT = 12;
// Strings used as internal ids, group ids and prefixes for actions
private static final String FALSE_ID = "false"; //$NON-NLS-1$
private static final String TRUE_ID = "true"; //$NON-NLS-1$
private static final String PROP_PREFIX = "@prop@"; //$NON-NLS-1$
private static final String CLEAR_ID = "clear"; //$NON-NLS-1$
private static final String ZCUSTOM = "zcustom"; //$NON-NLS-1$
protected IClientRulesEngine mRulesEngine;
// Cache of attributes. Key is FQCN of a node mixed with its view hierarchy
// parent. Values are a custom map as needed by getContextMenu.
private Map<String, Map<String, Prop>> mAttributesMap =
new HashMap<String, Map<String, Prop>>();
@Override
public boolean onInitialize(@NonNull String fqcn, @NonNull IClientRulesEngine engine) {
mRulesEngine = engine;
// This base rule can handle any class so we don't need to filter on
// FQCN. Derived classes should do so if they can handle some
// subclasses.
// If onInitialize returns false, it means it can't handle the given
// FQCN and will be unloaded.
return true;
}
/**
* Returns the {@link IClientRulesEngine} associated with this {@link IViewRule}
*
* @return the {@link IClientRulesEngine} associated with this {@link IViewRule}
*/
public IClientRulesEngine getRulesEngine() {
return mRulesEngine;
}
// === Context Menu ===
/**
* Generate custom actions for the context menu: <br/>
* - Explicit layout_width and layout_height attributes.
* - List of all other simple toggle attributes.
*/
@Override
public void addContextMenuActions(@NonNull List<RuleAction> actions,
final @NonNull INode selectedNode) {
String width = null;
String currentWidth = selectedNode.getStringAttr(ANDROID_URI, ATTR_LAYOUT_WIDTH);
String fillParent = getFillParentValueName();
boolean canMatchParent = supportsMatchParent();
if (canMatchParent && VALUE_FILL_PARENT.equals(currentWidth)) {
currentWidth = VALUE_MATCH_PARENT;
} else if (!canMatchParent && VALUE_MATCH_PARENT.equals(currentWidth)) {
currentWidth = VALUE_FILL_PARENT;
} else if (!VALUE_WRAP_CONTENT.equals(currentWidth) && !fillParent.equals(currentWidth)) {
width = currentWidth;
}
String height = null;
String currentHeight = selectedNode.getStringAttr(ANDROID_URI, ATTR_LAYOUT_HEIGHT);
if (canMatchParent && VALUE_FILL_PARENT.equals(currentHeight)) {
currentHeight = VALUE_MATCH_PARENT;
} else if (!canMatchParent && VALUE_MATCH_PARENT.equals(currentHeight)) {
currentHeight = VALUE_FILL_PARENT;
} else if (!VALUE_WRAP_CONTENT.equals(currentHeight)
&& !fillParent.equals(currentHeight)) {
height = currentHeight;
}
final String newWidth = width;
final String newHeight = height;
final IMenuCallback onChange = new IMenuCallback() {
@Override
public void action(
final @NonNull RuleAction action,
final @NonNull List<? extends INode> selectedNodes,
final @Nullable String valueId, final @Nullable Boolean newValue) {
String fullActionId = action.getId();
boolean isProp = fullActionId.startsWith(PROP_PREFIX);
final String actionId = isProp ?
fullActionId.substring(PROP_PREFIX.length()) : fullActionId;
if (fullActionId.equals(ATTR_LAYOUT_WIDTH)) {
final String newAttrValue = getValue(valueId, newWidth);
if (newAttrValue != null) {
for (INode node : selectedNodes) {
node.editXml("Change Attribute " + ATTR_LAYOUT_WIDTH,
new PropertySettingNodeHandler(ANDROID_URI,
ATTR_LAYOUT_WIDTH, newAttrValue));
}
editedProperty(ATTR_LAYOUT_WIDTH);
}
return;
} else if (fullActionId.equals(ATTR_LAYOUT_HEIGHT)) {
// Ask the user
final String newAttrValue = getValue(valueId, newHeight);
if (newAttrValue != null) {
for (INode node : selectedNodes) {
node.editXml("Change Attribute " + ATTR_LAYOUT_HEIGHT,
new PropertySettingNodeHandler(ANDROID_URI,
ATTR_LAYOUT_HEIGHT, newAttrValue));
}
editedProperty(ATTR_LAYOUT_HEIGHT);
}
return;
} else if (fullActionId.equals(ATTR_ID)) {
// Ids must be set individually so open the id dialog for each
// selected node (though allow cancel to break the loop)
for (INode node : selectedNodes) {
if (!mRulesEngine.rename(node)) {
break;
}
}
editedProperty(ATTR_ID);
return;
} else if (isProp) {
INode firstNode = selectedNodes.get(0);
String key = getPropertyMapKey(selectedNode);
Map<String, Prop> props = mAttributesMap.get(key);
final Prop prop = (props != null) ? props.get(actionId) : null;
if (prop != null) {
editedProperty(actionId);
// For custom values (requiring an input dialog) input the
// value outside the undo-block.
// Input the value as a text, unless we know it's the "text" or
// "style" attributes (where we know we want to ask for specific
// resource types).
String uri = ANDROID_URI;
String v = null;
if (prop.isStringEdit()) {
boolean isStyle = actionId.equals(ATTR_STYLE);
boolean isText = actionId.equals(ATTR_TEXT);
boolean isHint = actionId.equals(ATTR_HINT);
if (isStyle || isText || isHint) {
String resourceTypeName = isStyle
? ResourceType.STYLE.getName()
: ResourceType.STRING.getName();
String oldValue = selectedNodes.size() == 1
? (isStyle ? firstNode.getStringAttr(ATTR_STYLE, actionId)
: firstNode.getStringAttr(ANDROID_URI, actionId))
: ""; //$NON-NLS-1$
oldValue = ensureValidString(oldValue);
v = mRulesEngine.displayResourceInput(resourceTypeName, oldValue);
if (isStyle) {
uri = null;
}
} else if (actionId.equals(ATTR_CLASS) && selectedNodes.size() >= 1 &&
VIEW_FRAGMENT.equals(selectedNodes.get(0).getFqcn())) {
v = mRulesEngine.displayFragmentSourceInput();
uri = null;
} else {
v = inputAttributeValue(firstNode, actionId);
}
}
final String customValue = v;
for (INode n : selectedNodes) {
if (prop.isToggle()) {
// case of toggle
String value = ""; //$NON-NLS-1$
if (valueId.equals(TRUE_ID)) {
value = newValue ? "true" : ""; //$NON-NLS-1$ //$NON-NLS-2$
} else if (valueId.equals(FALSE_ID)) {
value = newValue ? "false" : "";//$NON-NLS-1$ //$NON-NLS-2$
}
n.setAttribute(uri, actionId, value);
} else if (prop.isFlag()) {
// case of a flag
String values = ""; //$NON-NLS-1$
if (!valueId.equals(CLEAR_ID)) {
values = n.getStringAttr(ANDROID_URI, actionId);
Set<String> newValues = new HashSet<String>();
if (values != null) {
newValues.addAll(Arrays.asList(
values.split("\\|"))); //$NON-NLS-1$
}
if (newValue) {
newValues.add(valueId);
} else {
newValues.remove(valueId);
}
List<String> sorted = new ArrayList<String>(newValues);
Collections.sort(sorted);
values = join('|', sorted);
// Special case
if (valueId.equals("normal")) { //$NON-NLS-1$
// For textStyle for example, if you have "bold|italic"
// and you select the "normal" property, this should
// not behave in the normal flag way and "or" itself in;
// it should replace the other two.
// This also applies to imeOptions.
values = valueId;
}
}
n.setAttribute(uri, actionId, values);
} else if (prop.isEnum()) {
// case of an enum
String value = ""; //$NON-NLS-1$
if (!valueId.equals(CLEAR_ID)) {
value = newValue ? valueId : ""; //$NON-NLS-1$
}
n.setAttribute(uri, actionId, value);
} else {
assert prop.isStringEdit();
// We've already received the value outside the undo block
if (customValue != null) {
n.setAttribute(uri, actionId, customValue);
}
}
}
}
}
}
/**
* Input the custom value for the given attribute. This will use the Reference
* Chooser if it is a reference value, otherwise a plain text editor.
*/
private String inputAttributeValue(final INode node, final String attribute) {
String oldValue = node.getStringAttr(ANDROID_URI, attribute);
oldValue = ensureValidString(oldValue);
IAttributeInfo attributeInfo = node.getAttributeInfo(ANDROID_URI, attribute);
if (attributeInfo != null
&& attributeInfo.getFormats().contains(Format.REFERENCE)) {
return mRulesEngine.displayReferenceInput(oldValue);
} else {
// A single resource type? If so use a resource chooser initialized
// to this specific type
/* This does not work well, because the metadata is a bit misleading:
* for example a Button's "text" property and a Button's "onClick" property
* both claim to be of type [string], but @string/ is NOT valid for
* onClick..
if (attributeInfo != null && attributeInfo.getFormats().length == 1) {
// Resource chooser
Format format = attributeInfo.getFormats()[0];
return mRulesEngine.displayResourceInput(format.name(), oldValue);
}
*/
// Fallback: just edit the raw XML string
String message = String.format("New %1$s Value:", attribute);
return mRulesEngine.displayInput(message, oldValue, null);
}
}
/**
* Returns the value (which will ask the user if the value is the special
* {@link #ZCUSTOM} marker
*/
private String getValue(String valueId, String defaultValue) {
if (valueId.equals(ZCUSTOM)) {
if (defaultValue == null) {
defaultValue = "";
}
String value = mRulesEngine.displayInput(
"Set custom layout attribute value (example: 50dp)",
defaultValue, null);
if (value != null && value.trim().length() > 0) {
return value.trim();
} else {
return null;
}
}
return valueId;
}
};
IAttributeInfo textAttribute = selectedNode.getAttributeInfo(ANDROID_URI, ATTR_TEXT);
if (textAttribute != null) {
actions.add(RuleAction.createAction(PROP_PREFIX + ATTR_TEXT, "Edit Text...", onChange,
null, 10, true));
}
String editIdLabel = selectedNode.getStringAttr(ANDROID_URI, ATTR_ID) != null ?
"Edit ID..." : "Assign ID...";
actions.add(RuleAction.createAction(ATTR_ID, editIdLabel, onChange, null, 20, true));
addCommonPropertyActions(actions, selectedNode, onChange, 21);
// Create width choice submenu
actions.add(RuleAction.createSeparator(32));
List<Pair<String, String>> widthChoices = new ArrayList<Pair<String,String>>(4);
widthChoices.add(Pair.of(VALUE_WRAP_CONTENT, "Wrap Content"));
if (canMatchParent) {
widthChoices.add(Pair.of(VALUE_MATCH_PARENT, "Match Parent"));
} else {
widthChoices.add(Pair.of(VALUE_FILL_PARENT, "Fill Parent"));
}
if (width != null) {
widthChoices.add(Pair.of(width, width));
}
widthChoices.add(Pair.of(ZCUSTOM, "Other..."));
actions.add(RuleAction.createChoices(
ATTR_LAYOUT_WIDTH, "Layout Width",
onChange,
null /* iconUrls */,
currentWidth,
null, 35,
true, // supportsMultipleNodes
widthChoices));
// Create height choice submenu
List<Pair<String, String>> heightChoices = new ArrayList<Pair<String,String>>(4);
heightChoices.add(Pair.of(VALUE_WRAP_CONTENT, "Wrap Content"));
if (canMatchParent) {
heightChoices.add(Pair.of(VALUE_MATCH_PARENT, "Match Parent"));
} else {
heightChoices.add(Pair.of(VALUE_FILL_PARENT, "Fill Parent"));
}
if (height != null) {
heightChoices.add(Pair.of(height, height));
}
heightChoices.add(Pair.of(ZCUSTOM, "Other..."));
actions.add(RuleAction.createChoices(
ATTR_LAYOUT_HEIGHT, "Layout Height",
onChange,
null /* iconUrls */,
currentHeight,
null, 40,
true,
heightChoices));
actions.add(RuleAction.createSeparator(45));
RuleAction properties = RuleAction.createChoices("properties", "Other Properties", //$NON-NLS-1$
onChange /*callback*/, null /*icon*/, 50,
true /*supportsMultipleNodes*/, new ActionProvider() {
@Override
public @NonNull List<RuleAction> getNestedActions(@NonNull INode node) {
List<RuleAction> propertyActionTypes = new ArrayList<RuleAction>();
propertyActionTypes.add(RuleAction.createChoices(
"recent", "Recent", //$NON-NLS-1$
onChange /*callback*/, null /*icon*/, 10,
true /*supportsMultipleNodes*/, new ActionProvider() {
@Override
public @NonNull List<RuleAction> getNestedActions(@NonNull INode n) {
List<RuleAction> propertyActions = new ArrayList<RuleAction>();
addRecentPropertyActions(propertyActions, n, onChange);
return propertyActions;
}
}));
propertyActionTypes.add(RuleAction.createSeparator(20));
addInheritedProperties(propertyActionTypes, node, onChange, 30);
propertyActionTypes.add(RuleAction.createSeparator(50));
propertyActionTypes.add(RuleAction.createChoices(
"layoutparams", "Layout Parameters", //$NON-NLS-1$
onChange /*callback*/, null /*icon*/, 60,
true /*supportsMultipleNodes*/, new ActionProvider() {
@Override
public @NonNull List<RuleAction> getNestedActions(@NonNull INode n) {
List<RuleAction> propertyActions = new ArrayList<RuleAction>();
addPropertyActions(propertyActions, n, onChange, null, true);
return propertyActions;
}
}));
propertyActionTypes.add(RuleAction.createSeparator(70));
propertyActionTypes.add(RuleAction.createChoices(
"allprops", "All By Name", //$NON-NLS-1$
onChange /*callback*/, null /*icon*/, 80,
true /*supportsMultipleNodes*/, new ActionProvider() {
@Override
public @NonNull List<RuleAction> getNestedActions(@NonNull INode n) {
List<RuleAction> propertyActions = new ArrayList<RuleAction>();
addPropertyActions(propertyActions, n, onChange, null, false);
return propertyActions;
}
}));
return propertyActionTypes;
}
});
actions.add(properties);
}
@Override
@Nullable
public String getDefaultActionId(@NonNull final INode selectedNode) {
IAttributeInfo textAttribute = selectedNode.getAttributeInfo(ANDROID_URI, ATTR_TEXT);
if (textAttribute != null) {
return PROP_PREFIX + ATTR_TEXT;
}
return null;
}
private static String getPropertyMapKey(INode node) {
// Compute the key for mAttributesMap. This depends on the type of this
// node and its parent in the view hierarchy.
StringBuilder sb = new StringBuilder();
sb.append(node.getFqcn());
sb.append('_');
INode parent = node.getParent();
if (parent != null) {
sb.append(parent.getFqcn());
}
return sb.toString();
}
/**
* Adds menu items for the inherited attributes, one pull-right menu for each super class
* that defines attributes.
*
* @param propertyActionTypes the actions list to add into
* @param node the node to apply the attributes to
* @param onChange the callback to use for setting attributes
* @param sortPriority the initial sort attribute for the first menu item
*/
private void addInheritedProperties(List<RuleAction> propertyActionTypes, INode node,
final IMenuCallback onChange, int sortPriority) {
List<String> attributeSources = node.getAttributeSources();
for (final String definedBy : attributeSources) {
String sourceClass = definedBy;
// Strip package prefixes when necessary
int index = sourceClass.length();
if (sourceClass.endsWith(DOT_LAYOUT_PARAMS)) {
index = sourceClass.length() - DOT_LAYOUT_PARAMS.length() - 1;
}
int lastDot = sourceClass.lastIndexOf('.', index);
if (lastDot != -1) {
sourceClass = sourceClass.substring(lastDot + 1);
}
String label;
if (definedBy.equals(node.getFqcn())) {
label = String.format("Defined by %1$s", sourceClass);
} else {
label = String.format("Inherited from %1$s", sourceClass);
}
propertyActionTypes.add(RuleAction.createChoices("def_" + definedBy,
label,
onChange /*callback*/, null /*icon*/, sortPriority++,
true /*supportsMultipleNodes*/, new ActionProvider() {
@Override
public @NonNull List<RuleAction> getNestedActions(@NonNull INode n) {
List<RuleAction> propertyActions = new ArrayList<RuleAction>();
addPropertyActions(propertyActions, n, onChange, definedBy, false);
return propertyActions;
}
}));
}
}
/**
* Creates a list of properties that are commonly edited for views of the
* selected node's type
*/
private void addCommonPropertyActions(List<RuleAction> actions, INode selectedNode,
IMenuCallback onChange, int sortPriority) {
Map<String, Prop> properties = getPropertyMetadata(selectedNode);
IViewMetadata metadata = mRulesEngine.getMetadata(selectedNode.getFqcn());
if (metadata != null) {
List<String> attributes = metadata.getTopAttributes();
if (attributes.size() > 0) {
for (String attribute : attributes) {
// Text and ID are handled manually in the menu construction code because
// we want to place them consistently and customize the action label
if (ATTR_TEXT.equals(attribute) || ATTR_ID.equals(attribute)) {
continue;
}
Prop property = properties.get(attribute);
if (property != null) {
String title = property.getTitle();
if (title.endsWith("...")) {
title = String.format("Edit %1$s", property.getTitle());
}
actions.add(createPropertyAction(property, attribute, title,
selectedNode, onChange, sortPriority));
sortPriority++;
}
}
}
}
}
/**
* Record that the given property was just edited; adds it to the front of
* the recently edited property list
*
* @param property the name of the property
*/
static void editedProperty(String property) {
if (sRecent.contains(property)) {
sRecent.remove(property);
} else if (sRecent.size() > MAX_RECENT_COUNT) {
sRecent.remove(sRecent.size() - 1);
}
sRecent.add(0, property);
}
/**
* Creates a list of recently modified properties that apply to the given selected node
*/
private void addRecentPropertyActions(List<RuleAction> actions, INode selectedNode,
IMenuCallback onChange) {
int sortPriority = 10;
Map<String, Prop> properties = getPropertyMetadata(selectedNode);
for (String attribute : sRecent) {
Prop property = properties.get(attribute);
if (property != null) {
actions.add(createPropertyAction(property, attribute, property.getTitle(),
selectedNode, onChange, sortPriority));
sortPriority += 10;
}
}
}
/**
* Creates a list of nested actions representing the property-setting
* actions for the given selected node
*/
private void addPropertyActions(List<RuleAction> actions, INode selectedNode,
IMenuCallback onChange, String definedBy, boolean layoutParamsOnly) {
Map<String, Prop> properties = getPropertyMetadata(selectedNode);
int sortPriority = 10;
for (Map.Entry<String, Prop> entry : properties.entrySet()) {
String id = entry.getKey();
Prop property = entry.getValue();
if (layoutParamsOnly) {
// If we have definedBy information, that is most accurate; all layout
// params will be defined by a class whose name ends with
// .LayoutParams:
if (definedBy != null) {
if (!definedBy.endsWith(DOT_LAYOUT_PARAMS)) {
continue;
}
} else if (!id.startsWith(ATTR_LAYOUT_RESOURCE_PREFIX)) {
continue;
}
}
if (definedBy != null && !definedBy.equals(property.getDefinedBy())) {
continue;
}
actions.add(createPropertyAction(property, id, property.getTitle(),
selectedNode, onChange, sortPriority));
sortPriority += 10;
}
// The properties are coming out of map key order which isn't right, so sort
// alphabetically instead
Collections.sort(actions, new Comparator<RuleAction>() {
@Override
public int compare(RuleAction action1, RuleAction action2) {
return action1.getTitle().compareTo(action2.getTitle());
}
});
}
private RuleAction createPropertyAction(Prop p, String id, String title, INode selectedNode,
IMenuCallback onChange, int sortPriority) {
if (p.isToggle()) {
// Toggles are handled as a multiple-choice between true, false
// and nothing (clear)
String value = selectedNode.getStringAttr(ANDROID_URI, id);
if (value != null) {
value = value.toLowerCase(Locale.US);
}
if (VALUE_TRUE.equals(value)) {
value = TRUE_ID;
} else if (VALUE_FALSE.equals(value)) {
value = FALSE_ID;
} else {
value = CLEAR_ID;
}
return RuleAction.createChoices(PROP_PREFIX + id, title,
onChange, BOOLEAN_CHOICE_PROVIDER,
value,
null, sortPriority,
true);
} else if (p.getChoices() != null) {
// Enum or flags. Their possible values are the multiple-choice
// items, with an extra "clear" option to remove everything.
String current = selectedNode.getStringAttr(ANDROID_URI, id);
if (current == null || current.length() == 0) {
current = CLEAR_ID;
}
return RuleAction.createChoices(PROP_PREFIX + id, title,
onChange, new EnumPropertyChoiceProvider(p),
current,
null, sortPriority,
true);
} else {
return RuleAction.createAction(
PROP_PREFIX + id,
title,
onChange,
null, sortPriority,
true);
}
}
private Map<String, Prop> getPropertyMetadata(final INode selectedNode) {
String key = getPropertyMapKey(selectedNode);
Map<String, Prop> props = mAttributesMap.get(key);
if (props == null) {
// Prepare the property map
props = new HashMap<String, Prop>();
for (IAttributeInfo attrInfo : selectedNode.getDeclaredAttributes()) {
String id = attrInfo != null ? attrInfo.getName() : null;
if (id == null || id.equals(ATTR_LAYOUT_WIDTH) || id.equals(ATTR_LAYOUT_HEIGHT)) {
// Layout width/height are already handled at the root level
continue;
}
if (attrInfo == null) {
continue;
}
EnumSet<Format> formats = attrInfo.getFormats();
String title = getAttributeDisplayName(id);
String definedBy = attrInfo != null ? attrInfo.getDefinedBy() : null;
if (formats.contains(IAttributeInfo.Format.BOOLEAN)) {
props.put(id, new Prop(title, true, definedBy));
} else if (formats.contains(IAttributeInfo.Format.ENUM)) {
// Convert each enum into a map id=>title
Map<String, String> values = new HashMap<String, String>();
if (attrInfo != null) {
for (String e : attrInfo.getEnumValues()) {
values.put(e, getAttributeDisplayName(e));
}
}
props.put(id, new Prop(title, false, false, values, definedBy));
} else if (formats.contains(IAttributeInfo.Format.FLAG)) {
// Convert each flag into a map id=>title
Map<String, String> values = new HashMap<String, String>();
if (attrInfo != null) {
for (String e : attrInfo.getFlagValues()) {
values.put(e, getAttributeDisplayName(e));
}
}
props.put(id, new Prop(title, false, true, values, definedBy));
} else {
props.put(id, new Prop(title + "...", false, definedBy));
}
}
mAttributesMap.put(key, props);
}
return props;
}
/**
* A {@link ChoiceProvder} which provides alternatives suitable for choosing
* values for a boolean property: true, false, or "default".
*/
private static ChoiceProvider BOOLEAN_CHOICE_PROVIDER = new ChoiceProvider() {
@Override
public void addChoices(@NonNull List<String> titles, @NonNull List<URL> iconUrls,
@NonNull List<String> ids) {
titles.add("True");
ids.add(TRUE_ID);
titles.add("False");
ids.add(FALSE_ID);
titles.add(RuleAction.SEPARATOR);
ids.add(RuleAction.SEPARATOR);
titles.add("Default");
ids.add(CLEAR_ID);
}
};
/**
* A {@link ChoiceProvider} which provides the various available
* attribute values available for a given {@link Prop} property descriptor.
*/
private static class EnumPropertyChoiceProvider implements ChoiceProvider {
private Prop mProperty;
public EnumPropertyChoiceProvider(Prop property) {
super();
mProperty = property;
}
@Override
public void addChoices(@NonNull List<String> titles, @NonNull List<URL> iconUrls,
@NonNull List<String> ids) {
for (Entry<String, String> entry : mProperty.getChoices().entrySet()) {
ids.add(entry.getKey());
titles.add(entry.getValue());
}
titles.add(RuleAction.SEPARATOR);
ids.add(RuleAction.SEPARATOR);
titles.add("Default");
ids.add(CLEAR_ID);
}
}
/**
* Returns true if the given node is "filled" (e.g. has layout width set to match
* parent or fill parent
*/
protected final boolean isFilled(INode node, String attribute) {
String value = node.getStringAttr(ANDROID_URI, attribute);
return VALUE_MATCH_PARENT.equals(value) || VALUE_FILL_PARENT.equals(value);
}
/**
* Returns fill_parent or match_parent, depending on whether the minimum supported
* platform supports match_parent or not
*
* @return match_parent or fill_parent depending on which is supported by the project
*/
protected final String getFillParentValueName() {
return supportsMatchParent() ? VALUE_MATCH_PARENT : VALUE_FILL_PARENT;
}
/**
* Returns true if the project supports match_parent instead of just fill_parent
*
* @return true if the project supports match_parent instead of just fill_parent
*/
protected final boolean supportsMatchParent() {
// fill_parent was renamed match_parent in API level 8
return mRulesEngine.getMinApiLevel() >= 8;
}
/** Join strings into a single string with the given delimiter */
static String join(char delimiter, Collection<String> strings) {
StringBuilder sb = new StringBuilder(100);
for (String s : strings) {
if (sb.length() > 0) {
sb.append(delimiter);
}
sb.append(s);
}
return sb.toString();
}
static Map<String, String> concatenate(Map<String, String> pre, Map<String, String> post) {
Map<String, String> result = new HashMap<String, String>(pre.size() + post.size());
result.putAll(pre);
result.putAll(post);
return result;
}
// Quick utility for building up maps declaratively to minimize the diffs
static Map<String, String> mapify(String... values) {
Map<String, String> map = new HashMap<String, String>(values.length / 2);
for (int i = 0; i < values.length; i += 2) {
String key = values[i];
if (key == null) {
continue;
}
String value = values[i + 1];
map.put(key, value);
}
return map;
}
/**
* Produces a display name for an attribute, usually capitalizing the attribute name
* and splitting up underscores into new words
*
* @param name the attribute name to convert
* @return a display name for the attribute name
*/
public static String getAttributeDisplayName(String name) {
if (name != null && name.length() > 0) {
StringBuilder sb = new StringBuilder();
boolean capitalizeNext = true;
for (int i = 0, n = name.length(); i < n; i++) {
char c = name.charAt(i);
if (capitalizeNext) {
c = Character.toUpperCase(c);
}
capitalizeNext = false;
if (c == '_') {
c = ' ';
capitalizeNext = true;
}
sb.append(c);
}
return sb.toString();
}
return name;
}
// ==== Paste support ====
/**
* Most views can't accept children so there's nothing to paste on them. In
* this case, defer the call to the parent layout and use the target node as
* an indication of where to paste.
*/
@Override
public void onPaste(@NonNull INode targetNode, @Nullable Object targetView,
@NonNull IDragElement[] elements) {
//
INode parent = targetNode.getParent();
if (parent != null) {
String parentFqcn = parent.getFqcn();
IViewRule parentRule = mRulesEngine.loadRule(parentFqcn);
if (parentRule instanceof BaseLayoutRule) {
((BaseLayoutRule) parentRule).onPasteBeforeChild(parent, targetView, targetNode,
elements);
}
}
}
/**
* Support class for the context menu code. Stores state about properties in
* the context menu.
*/
private static class Prop {
private final boolean mToggle;
private final boolean mFlag;
private final String mTitle;
private final Map<String, String> mChoices;
private String mDefinedBy;
public Prop(String title, boolean isToggle, boolean isFlag, Map<String, String> choices,
String definedBy) {
mTitle = title;
mToggle = isToggle;
mFlag = isFlag;
mChoices = choices;
mDefinedBy = definedBy;
}
public String getDefinedBy() {
return mDefinedBy;
}
public Prop(String title, boolean isToggle, String definedBy) {
this(title, isToggle, false, null, definedBy);
}
private boolean isToggle() {
return mToggle;
}
private boolean isFlag() {
return mFlag && mChoices != null;
}
private boolean isEnum() {
return !mFlag && mChoices != null;
}
private String getTitle() {
return mTitle;
}
private Map<String, String> getChoices() {
return mChoices;
}
private boolean isStringEdit() {
return mChoices == null && !mToggle;
}
}
/**
* Returns a source attribute value which points to a sample image. This is typically
* used to provide an initial image shown on ImageButtons, etc. There is no guarantee
* that the source pointed to by this method actually exists.
*
* @return a source attribute to use for sample images, never null
*/
protected final String getSampleImageSrc() {
// Builtin graphics available since v1:
return "@android:drawable/btn_star"; //$NON-NLS-1$
}
/**
* Strips the {@code @+id} or {@code @id} prefix off of the given id
*
* @param id attribute to be stripped
* @return the id name without the {@code @+id} or {@code @id} prefix
*/
@NonNull
public static String stripIdPrefix(@Nullable String id) {
if (id == null) {
return ""; //$NON-NLS-1$
} else if (id.startsWith(NEW_ID_PREFIX)) {
return id.substring(NEW_ID_PREFIX.length());
} else if (id.startsWith(ID_PREFIX)) {
return id.substring(ID_PREFIX.length());
}
return id;
}
private static String ensureValidString(String value) {
if (value == null) {
value = ""; //$NON-NLS-1$
}
return value;
}
}