eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/relative/DeletionHandler.java - platform/sdk - Git at Google

 /*
  * Copyright (C) 2012 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.ANDROID_URI;
 import static com.android.SdkConstants.ATTR_ID;
 import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN;
 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 static com.android.ide.common.layout.BaseViewRule.stripIdPrefix;
 import static com.android.ide.common.layout.relative.ConstraintType.LAYOUT_CENTER_HORIZONTAL;
 import static com.android.ide.common.layout.relative.ConstraintType.LAYOUT_CENTER_VERTICAL;

 import com.android.SdkConstants;
 import com.android.annotations.NonNull;
 import com.android.annotations.Nullable;
 import com.android.ide.common.api.INode;
 import com.android.ide.common.api.INode.IAttribute;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;

 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 /**
  * Handles deletions in a relative layout, transferring constraints across
  * deleted nodes
  * <p>
  * TODO: Consider adding the
  * {@link SdkConstants#ATTR_LAYOUT_ALIGN_WITH_PARENT_MISSING} attribute to a
  * node if it's pointing to a node which is deleted and which has no transitive
  * reference to another node.
  */
 public class DeletionHandler {
     private final INode mLayout;
     private final INode[] mChildren;
     private final List<INode> mDeleted;
     private final Set<String> mDeletedIds;
     private final Map<String, INode> mNodeMap;
     private final List<INode> mMoved;

     /**
      * Creates a new {@link DeletionHandler}
      *
      * @param deleted the deleted nodes
      * @param moved nodes that were moved (e.g. deleted, but also inserted elsewhere)
      * @param layout the parent layout of the deleted nodes
      */
     public DeletionHandler(@NonNull List<INode> deleted, @NonNull List<INode> moved,
             @NonNull INode layout) {
         mDeleted = deleted;
         mMoved = moved;
         mLayout = layout;

         mChildren = mLayout.getChildren();
         mNodeMap = Maps.newHashMapWithExpectedSize(mChildren.length);
         for (INode child : mChildren) {
             String id = child.getStringAttr(ANDROID_URI, ATTR_ID);
             if (id != null) {
                 mNodeMap.put(stripIdPrefix(id), child);
             }
         }

         mDeletedIds = Sets.newHashSetWithExpectedSize(mDeleted.size());
         for (INode node : mDeleted) {
             String id = node.getStringAttr(ANDROID_URI, ATTR_ID);
             if (id != null) {
                 mDeletedIds.add(stripIdPrefix(id));
             }
         }

         // Any widgets that remain (e.g. typically because they were moved) should
         // keep their incoming dependencies
         for (INode node : mMoved) {
             String id = node.getStringAttr(ANDROID_URI, ATTR_ID);
             if (id != null) {
                 mDeletedIds.remove(stripIdPrefix(id));
             }
         }
     }

     @Nullable
     private static String getId(@NonNull IAttribute attribute) {
         if (attribute.getName().startsWith(ATTR_LAYOUT_RESOURCE_PREFIX)
                 && ANDROID_URI.equals(attribute.getUri())
                 && !attribute.getName().startsWith(ATTR_LAYOUT_MARGIN)) {
             String id = attribute.getValue();
             // It might not be an id reference, so check manually rather than just
             // calling stripIdPrefix():
             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 null;
     }

     /**
      * Updates the constraints in the layout to handle deletion of a set of
      * nodes. This ensures that any constraints pointing to one of the deleted
      * nodes are changed properly to point to a non-deleted node with similar
      * constraints.
      */
     public void updateConstraints() {
         if (mChildren.length == mDeleted.size()) {
             // Deleting everything: Nothing to be done
             return;
         }

         // Now remove incoming edges to any views that were deleted. If possible,
         // don't just delete them but replace them with a transitive constraint, e.g.
         // if we have "A <= B <= C" and "B" is removed, then we end up with "A <= C",

         for (INode child : mChildren) {
             if (mDeleted.contains(child)) {
                 continue;
             }

             for (IAttribute attribute : child.getLiveAttributes()) {
                 String id = getId(attribute);
                 if (id != null) {
                     if (mDeletedIds.contains(id)) {
                         // Unset this reference to a deleted widget. It might be
                         // replaced if the pointed to node points to some other node
                         // on the same side, but it may use a different constraint name,
                         // or have none at all (e.g. parent).
                         String name = attribute.getName();
                         child.setAttribute(ANDROID_URI, name, null);

                         INode deleted = mNodeMap.get(id);
                         if (deleted != null) {
                             ConstraintType type = ConstraintType.fromAttribute(name);
                             if (type != null) {
                                 transfer(deleted, child, type, 0);
                             }
                         }
                     }
                 }
             }
         }
     }

     private void transfer(INode deleted, INode target, ConstraintType targetType, int depth) {
         if (depth == 20) {
             // Prevent really deep flow or unbounded recursion in case there is a bug in
             // the cycle detection code
             return;
         }

         assert mDeleted.contains(deleted);

         for (IAttribute attribute : deleted.getLiveAttributes()) {
             String name = attribute.getName();
             ConstraintType type = ConstraintType.fromAttribute(name);
             if (type == null) {
                 continue;
             }

             ConstraintType transfer = getCompatibleConstraint(type, targetType);
             if (transfer != null) {
                 String id = getId(attribute);
                 if (id != null) {
                     if (mDeletedIds.contains(id)) {
                         INode nextDeleted = mNodeMap.get(id);
                         if (nextDeleted != null) {
                             // Points to another deleted node: recurse
                             transfer(nextDeleted, target, targetType, depth + 1);
                         }
                     } else {
                         // Found an undeleted node destination: point to it directly.
                         // Note that we're using the
                         target.setAttribute(ANDROID_URI, transfer.name, attribute.getValue());
                     }
                 } else {
                     // Pointing to parent or center etc (non-id ref): replicate this on the target
                     target.setAttribute(ANDROID_URI, name, attribute.getValue());
                 }
             }
         }
     }

     /**
      * Determines if two constraints are in the same direction and if so returns
      * the constraint in the same direction. Rather than returning boolean true
      * or false, this returns the constraint which is sometimes modified. For
      * example, if you have a node which points left to a node which is centered
      * in parent, then the constraint is turned into center horizontal.
      */
     @Nullable
     private static ConstraintType getCompatibleConstraint(
             @NonNull ConstraintType first, @NonNull ConstraintType second) {
         if (first == second) {
             return first;
         }

         switch (second) {
             case ALIGN_LEFT:
             case LAYOUT_RIGHT_OF:
                 switch (first) {
                     case LAYOUT_CENTER_HORIZONTAL:
                     case LAYOUT_LEFT_OF:
                     case ALIGN_LEFT:
                         return first;
                     case LAYOUT_CENTER_IN_PARENT:
                         return LAYOUT_CENTER_HORIZONTAL;
                 }
                 return null;

             case ALIGN_RIGHT:
             case LAYOUT_LEFT_OF:
                 switch (first) {
                     case LAYOUT_CENTER_HORIZONTAL:
                     case ALIGN_RIGHT:
                     case LAYOUT_LEFT_OF:
                         return first;
                     case LAYOUT_CENTER_IN_PARENT:
                         return LAYOUT_CENTER_HORIZONTAL;
                 }
                 return null;

             case ALIGN_TOP:
             case LAYOUT_BELOW:
             case ALIGN_BASELINE:
                 switch (first) {
                     case LAYOUT_CENTER_VERTICAL:
                     case ALIGN_TOP:
                     case LAYOUT_BELOW:
                     case ALIGN_BASELINE:
                         return first;
                     case LAYOUT_CENTER_IN_PARENT:
                         return LAYOUT_CENTER_VERTICAL;
                 }
                 return null;
             case ALIGN_BOTTOM:
             case LAYOUT_ABOVE:
                 switch (first) {
                     case LAYOUT_CENTER_VERTICAL:
                     case ALIGN_BOTTOM:
                     case LAYOUT_ABOVE:
                     case ALIGN_BASELINE:
                         return first;
                     case LAYOUT_CENTER_IN_PARENT:
                         return LAYOUT_CENTER_VERTICAL;
                 }
                 return null;
         }

         return null;
     }
 }
	/*
	* Copyright (C) 2012 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.ANDROID_URI;
	import static com.android.SdkConstants.ATTR_ID;
	import static com.android.SdkConstants.ATTR_LAYOUT_MARGIN;
	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 static com.android.ide.common.layout.BaseViewRule.stripIdPrefix;
	import static com.android.ide.common.layout.relative.ConstraintType.LAYOUT_CENTER_HORIZONTAL;
	import static com.android.ide.common.layout.relative.ConstraintType.LAYOUT_CENTER_VERTICAL;

	import com.android.SdkConstants;
	import com.android.annotations.NonNull;
	import com.android.annotations.Nullable;
	import com.android.ide.common.api.INode;
	import com.android.ide.common.api.INode.IAttribute;
	import com.google.common.collect.Maps;
	import com.google.common.collect.Sets;

	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	/**
	* Handles deletions in a relative layout, transferring constraints across
	* deleted nodes
	* <p>
	* TODO: Consider adding the
	* {@link SdkConstants#ATTR_LAYOUT_ALIGN_WITH_PARENT_MISSING} attribute to a
	* node if it's pointing to a node which is deleted and which has no transitive
	* reference to another node.
	*/
	public class DeletionHandler {
	private final INode mLayout;
	private final INode[] mChildren;
	private final List<INode> mDeleted;
	private final Set<String> mDeletedIds;
	private final Map<String, INode> mNodeMap;
	private final List<INode> mMoved;

	/**
	* Creates a new {@link DeletionHandler}
	*
	* @param deleted the deleted nodes
	* @param moved nodes that were moved (e.g. deleted, but also inserted elsewhere)
	* @param layout the parent layout of the deleted nodes
	*/
	public DeletionHandler(@NonNull List<INode> deleted, @NonNull List<INode> moved,
	@NonNull INode layout) {
	mDeleted = deleted;
	mMoved = moved;
	mLayout = layout;

	mChildren = mLayout.getChildren();
	mNodeMap = Maps.newHashMapWithExpectedSize(mChildren.length);
	for (INode child : mChildren) {
	String id = child.getStringAttr(ANDROID_URI, ATTR_ID);
	if (id != null) {
	mNodeMap.put(stripIdPrefix(id), child);
	}
	}

	mDeletedIds = Sets.newHashSetWithExpectedSize(mDeleted.size());
	for (INode node : mDeleted) {
	String id = node.getStringAttr(ANDROID_URI, ATTR_ID);
	if (id != null) {
	mDeletedIds.add(stripIdPrefix(id));
	}
	}

	// Any widgets that remain (e.g. typically because they were moved) should
	// keep their incoming dependencies
	for (INode node : mMoved) {
	String id = node.getStringAttr(ANDROID_URI, ATTR_ID);
	if (id != null) {
	mDeletedIds.remove(stripIdPrefix(id));
	}
	}
	}

	@Nullable
	private static String getId(@NonNull IAttribute attribute) {
	if (attribute.getName().startsWith(ATTR_LAYOUT_RESOURCE_PREFIX)
	&& ANDROID_URI.equals(attribute.getUri())
	&& !attribute.getName().startsWith(ATTR_LAYOUT_MARGIN)) {
	String id = attribute.getValue();
	// It might not be an id reference, so check manually rather than just
	// calling stripIdPrefix():
	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 null;
	}

	/**
	* Updates the constraints in the layout to handle deletion of a set of
	* nodes. This ensures that any constraints pointing to one of the deleted
	* nodes are changed properly to point to a non-deleted node with similar
	* constraints.
	*/
	public void updateConstraints() {
	if (mChildren.length == mDeleted.size()) {
	// Deleting everything: Nothing to be done
	return;
	}

	// Now remove incoming edges to any views that were deleted. If possible,
	// don't just delete them but replace them with a transitive constraint, e.g.
	// if we have "A <= B <= C" and "B" is removed, then we end up with "A <= C",

	for (INode child : mChildren) {
	if (mDeleted.contains(child)) {
	continue;
	}

	for (IAttribute attribute : child.getLiveAttributes()) {
	String id = getId(attribute);
	if (id != null) {
	if (mDeletedIds.contains(id)) {
	// Unset this reference to a deleted widget. It might be
	// replaced if the pointed to node points to some other node
	// on the same side, but it may use a different constraint name,
	// or have none at all (e.g. parent).
	String name = attribute.getName();
	child.setAttribute(ANDROID_URI, name, null);

	INode deleted = mNodeMap.get(id);
	if (deleted != null) {
	ConstraintType type = ConstraintType.fromAttribute(name);
	if (type != null) {
	transfer(deleted, child, type, 0);
	}
	}
	}
	}
	}
	}
	}

	private void transfer(INode deleted, INode target, ConstraintType targetType, int depth) {
	if (depth == 20) {
	// Prevent really deep flow or unbounded recursion in case there is a bug in
	// the cycle detection code
	return;
	}

	assert mDeleted.contains(deleted);

	for (IAttribute attribute : deleted.getLiveAttributes()) {
	String name = attribute.getName();
	ConstraintType type = ConstraintType.fromAttribute(name);
	if (type == null) {
	continue;
	}

	ConstraintType transfer = getCompatibleConstraint(type, targetType);
	if (transfer != null) {
	String id = getId(attribute);
	if (id != null) {
	if (mDeletedIds.contains(id)) {
	INode nextDeleted = mNodeMap.get(id);
	if (nextDeleted != null) {
	// Points to another deleted node: recurse
	transfer(nextDeleted, target, targetType, depth + 1);
	}
	} else {
	// Found an undeleted node destination: point to it directly.
	// Note that we're using the
	target.setAttribute(ANDROID_URI, transfer.name, attribute.getValue());
	}
	} else {
	// Pointing to parent or center etc (non-id ref): replicate this on the target
	target.setAttribute(ANDROID_URI, name, attribute.getValue());
	}
	}
	}
	}

	/**
	* Determines if two constraints are in the same direction and if so returns
	* the constraint in the same direction. Rather than returning boolean true
	* or false, this returns the constraint which is sometimes modified. For
	* example, if you have a node which points left to a node which is centered
	* in parent, then the constraint is turned into center horizontal.
	*/
	@Nullable
	private static ConstraintType getCompatibleConstraint(
	@NonNull ConstraintType first, @NonNull ConstraintType second) {
	if (first == second) {
	return first;
	}

	switch (second) {
	case ALIGN_LEFT:
	case LAYOUT_RIGHT_OF:
	switch (first) {
	case LAYOUT_CENTER_HORIZONTAL:
	case LAYOUT_LEFT_OF:
	case ALIGN_LEFT:
	return first;
	case LAYOUT_CENTER_IN_PARENT:
	return LAYOUT_CENTER_HORIZONTAL;
	}
	return null;

	case ALIGN_RIGHT:
	case LAYOUT_LEFT_OF:
	switch (first) {
	case LAYOUT_CENTER_HORIZONTAL:
	case ALIGN_RIGHT:
	case LAYOUT_LEFT_OF:
	return first;
	case LAYOUT_CENTER_IN_PARENT:
	return LAYOUT_CENTER_HORIZONTAL;
	}
	return null;

	case ALIGN_TOP:
	case LAYOUT_BELOW:
	case ALIGN_BASELINE:
	switch (first) {
	case LAYOUT_CENTER_VERTICAL:
	case ALIGN_TOP:
	case LAYOUT_BELOW:
	case ALIGN_BASELINE:
	return first;
	case LAYOUT_CENTER_IN_PARENT:
	return LAYOUT_CENTER_VERTICAL;
	}
	return null;
	case ALIGN_BOTTOM:
	case LAYOUT_ABOVE:
	switch (first) {
	case LAYOUT_CENTER_VERTICAL:
	case ALIGN_BOTTOM:
	case LAYOUT_ABOVE:
	case ALIGN_BASELINE:
	return first;
	case LAYOUT_CENTER_IN_PARENT:
	return LAYOUT_CENTER_VERTICAL;
	}
	return null;
	}

	return null;
	}
	}