| /* |
| * 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.refactoring; |
| |
| import static com.android.SdkConstants.ANDROID_URI; |
| import static com.android.SdkConstants.ATTR_BACKGROUND; |
| import static com.android.SdkConstants.ATTR_COLUMN_COUNT; |
| 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_RIGHT; |
| import static com.android.SdkConstants.ATTR_LAYOUT_ALIGN_TOP; |
| import static com.android.SdkConstants.ATTR_LAYOUT_COLUMN; |
| import static com.android.SdkConstants.ATTR_LAYOUT_COLUMN_SPAN; |
| import static com.android.SdkConstants.ATTR_LAYOUT_GRAVITY; |
| import static com.android.SdkConstants.ATTR_LAYOUT_HEIGHT; |
| import static com.android.SdkConstants.ATTR_LAYOUT_RESOURCE_PREFIX; |
| import static com.android.SdkConstants.ATTR_LAYOUT_ROW; |
| import static com.android.SdkConstants.ATTR_LAYOUT_ROW_SPAN; |
| import static com.android.SdkConstants.ATTR_LAYOUT_WIDTH; |
| import static com.android.SdkConstants.ATTR_ORIENTATION; |
| import static com.android.SdkConstants.FQCN_GRID_LAYOUT; |
| import static com.android.SdkConstants.FQCN_SPACE; |
| import static com.android.SdkConstants.GRAVITY_VALUE_FILL; |
| import static com.android.SdkConstants.GRAVITY_VALUE_FILL_HORIZONTAL; |
| import static com.android.SdkConstants.GRAVITY_VALUE_FILL_VERTICAL; |
| import static com.android.SdkConstants.ID_PREFIX; |
| import static com.android.SdkConstants.LINEAR_LAYOUT; |
| import static com.android.SdkConstants.NEW_ID_PREFIX; |
| import static com.android.SdkConstants.RADIO_GROUP; |
| import static com.android.SdkConstants.RELATIVE_LAYOUT; |
| import static com.android.SdkConstants.SPACE; |
| import static com.android.SdkConstants.TABLE_LAYOUT; |
| import static com.android.SdkConstants.TABLE_ROW; |
| import static com.android.SdkConstants.VALUE_FILL_PARENT; |
| import static com.android.SdkConstants.VALUE_HORIZONTAL; |
| import static com.android.SdkConstants.VALUE_MATCH_PARENT; |
| import static com.android.SdkConstants.VALUE_VERTICAL; |
| import static com.android.SdkConstants.VALUE_WRAP_CONTENT; |
| import static com.android.ide.common.layout.GravityHelper.GRAVITY_HORIZ_MASK; |
| import static com.android.ide.common.layout.GravityHelper.GRAVITY_VERT_MASK; |
| |
| import com.android.ide.common.api.IViewMetadata.FillPreference; |
| import com.android.ide.common.layout.BaseLayoutRule; |
| import com.android.ide.common.layout.GravityHelper; |
| import com.android.ide.common.layout.GridLayoutRule; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.AttributeDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.ViewElementDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.CanvasViewInfo; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.DomUtilities; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gre.ViewMetadataRepository; |
| import com.android.ide.eclipse.adt.internal.project.SupportLibraryHelper; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.text.edits.InsertEdit; |
| import org.eclipse.text.edits.MalformedTreeException; |
| import org.eclipse.text.edits.MultiTextEdit; |
| import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * Helper class which performs the bulk of the layout conversion to grid layout |
| * <p> |
| * Future enhancements: |
| * <ul> |
| * <li>Render the layout at multiple screen sizes and analyze how the widget bounds |
| * change and use this to infer gravity |
| * <li> Use the layout_width and layout_height attributes on views to infer column and |
| * row flexibility (and as mentioned above, possibly layout_weight). |
| * move and stretch and use that to add in additional constraints |
| * <li> Take into account existing margins and add/subtract those from the |
| * bounds computations and either clear or update them. |
| * <li>Try to reorder elements into their natural order |
| * <li> Try to preserve spacing? Right now everything gets converted into a compact |
| * grid with no spacing between the views; consider inserting {@code <Space>} views |
| * with dimensions based on existing distances. |
| * </ul> |
| */ |
| @SuppressWarnings("restriction") // DOM model access |
| class GridLayoutConverter { |
| private final MultiTextEdit mRootEdit; |
| private final boolean mFlatten; |
| private final Element mLayout; |
| private final ChangeLayoutRefactoring mRefactoring; |
| private final CanvasViewInfo mRootView; |
| |
| private List<View> mViews; |
| private String mNamespace; |
| private int mColumnCount; |
| |
| /** Creates a new {@link GridLayoutConverter} */ |
| GridLayoutConverter(ChangeLayoutRefactoring refactoring, |
| Element layout, boolean flatten, MultiTextEdit rootEdit, CanvasViewInfo rootView) { |
| mRefactoring = refactoring; |
| mLayout = layout; |
| mFlatten = flatten; |
| mRootEdit = rootEdit; |
| mRootView = rootView; |
| } |
| |
| /** Performs conversion from any layout to a RelativeLayout */ |
| public void convertToGridLayout() { |
| if (mRootView == null) { |
| return; |
| } |
| |
| // Locate the view for the layout |
| CanvasViewInfo layoutView = findViewForElement(mRootView, mLayout); |
| if (layoutView == null || layoutView.getChildren().size() == 0) { |
| // No children. THAT was an easy conversion! |
| return; |
| } |
| |
| // Study the layout and get information about how to place individual elements |
| GridModel gridModel = new GridModel(layoutView, mLayout, mFlatten); |
| mViews = gridModel.getViews(); |
| mColumnCount = gridModel.computeColumnCount(); |
| |
| deleteRemovedElements(gridModel.getDeletedElements()); |
| mNamespace = mRefactoring.getAndroidNamespacePrefix(); |
| |
| processGravities(); |
| |
| // Insert space views if necessary |
| insertStretchableSpans(); |
| |
| // Create/update relative layout constraints |
| assignGridAttributes(); |
| |
| removeUndefinedAttrs(); |
| |
| if (mColumnCount > 0) { |
| mRefactoring.setAttribute(mRootEdit, mLayout, ANDROID_URI, |
| mNamespace, ATTR_COLUMN_COUNT, Integer.toString(mColumnCount)); |
| } |
| } |
| |
| private void insertStretchableSpans() { |
| // Look at the rows and columns and determine if we need to have a stretchable |
| // row and/or a stretchable column in the layout. |
| // In a GridLayout, a row or column is stretchable if it defines a gravity (regardless |
| // of what the gravity is -- in other words, a column is not just stretchable if it |
| // has gravity=fill but also if it has gravity=left). Furthermore, ALL the elements |
| // in the row/column have to be stretchable for the overall row/column to be |
| // considered stretchable. |
| |
| // Map from row index to boolean for "is the row fixed/inflexible?" |
| Map<Integer, Boolean> rowFixed = new HashMap<Integer, Boolean>(); |
| Map<Integer, Boolean> columnFixed = new HashMap<Integer, Boolean>(); |
| for (View view : mViews) { |
| if (view.mElement == mLayout) { |
| continue; |
| } |
| |
| int gravity = GravityHelper.getGravity(view.mGravity, 0); |
| if ((gravity & GRAVITY_HORIZ_MASK) == 0) { |
| columnFixed.put(view.mCol, true); |
| } else if (!columnFixed.containsKey(view.mCol)) { |
| columnFixed.put(view.mCol, false); |
| } |
| if ((gravity & GRAVITY_VERT_MASK) == 0) { |
| rowFixed.put(view.mRow, true); |
| } else if (!rowFixed.containsKey(view.mRow)) { |
| rowFixed.put(view.mRow, false); |
| } |
| } |
| |
| boolean hasStretchableRow = false; |
| boolean hasStretchableColumn = false; |
| for (boolean fixed : rowFixed.values()) { |
| if (!fixed) { |
| hasStretchableRow = true; |
| } |
| } |
| for (boolean fixed : columnFixed.values()) { |
| if (!fixed) { |
| hasStretchableColumn = true; |
| } |
| } |
| |
| if (!hasStretchableRow || !hasStretchableColumn) { |
| // Insert <Space> to hold stretchable space |
| // TODO: May also have to increment column count! |
| int offset = 0; // WHERE? |
| |
| String gridLayout = mLayout.getTagName(); |
| if (mLayout instanceof IndexedRegion) { |
| IndexedRegion region = (IndexedRegion) mLayout; |
| int end = region.getEndOffset(); |
| // TODO: Look backwards for the "</" |
| // (and can it ever be <foo/>) ? |
| end -= (gridLayout.length() + 3); // 3: <, /, > |
| offset = end; |
| } |
| |
| int row = rowFixed.size(); |
| int column = columnFixed.size(); |
| StringBuilder sb = new StringBuilder(64); |
| String spaceTag = SPACE; |
| IFile file = mRefactoring.getFile(); |
| if (file != null) { |
| spaceTag = SupportLibraryHelper.getTagFor(file.getProject(), FQCN_SPACE); |
| if (spaceTag.equals(FQCN_SPACE)) { |
| spaceTag = SPACE; |
| } |
| } |
| |
| sb.append('<').append(spaceTag).append(' '); |
| String gravity; |
| if (!hasStretchableRow && !hasStretchableColumn) { |
| gravity = GRAVITY_VALUE_FILL; |
| } else if (!hasStretchableRow) { |
| gravity = GRAVITY_VALUE_FILL_VERTICAL; |
| } else { |
| assert !hasStretchableColumn; |
| gravity = GRAVITY_VALUE_FILL_HORIZONTAL; |
| } |
| |
| sb.append(mNamespace).append(':'); |
| sb.append(ATTR_LAYOUT_GRAVITY).append('=').append('"').append(gravity); |
| sb.append('"').append(' '); |
| |
| sb.append(mNamespace).append(':'); |
| sb.append(ATTR_LAYOUT_ROW).append('=').append('"').append(Integer.toString(row)); |
| sb.append('"').append(' '); |
| |
| sb.append(mNamespace).append(':'); |
| sb.append(ATTR_LAYOUT_COLUMN).append('=').append('"').append(Integer.toString(column)); |
| sb.append('"').append('/').append('>'); |
| |
| String space = sb.toString(); |
| InsertEdit replace = new InsertEdit(offset, space); |
| mRootEdit.addChild(replace); |
| |
| mColumnCount++; |
| } |
| } |
| |
| private void removeUndefinedAttrs() { |
| ViewElementDescriptor descriptor = mRefactoring.getElementDescriptor(FQCN_GRID_LAYOUT); |
| if (descriptor == null) { |
| return; |
| } |
| |
| Set<String> defined = new HashSet<String>(); |
| AttributeDescriptor[] layoutAttributes = descriptor.getLayoutAttributes(); |
| for (AttributeDescriptor attribute : layoutAttributes) { |
| defined.add(attribute.getXmlLocalName()); |
| } |
| |
| for (View view : mViews) { |
| Element child = view.mElement; |
| |
| List<Attr> attributes = mRefactoring.findLayoutAttributes(child); |
| for (Attr attribute : attributes) { |
| String name = attribute.getLocalName(); |
| if (!defined.contains(name)) { |
| // Remove it |
| try { |
| mRefactoring.removeAttribute(mRootEdit, child, attribute.getNamespaceURI(), |
| name); |
| } catch (MalformedTreeException mte) { |
| // Sometimes refactoring has modified attribute; not |
| // removing |
| // it is non-fatal so just warn instead of letting |
| // refactoring |
| // operation abort |
| AdtPlugin.log(IStatus.WARNING, |
| "Could not remove unsupported attribute %1$s; " + //$NON-NLS-1$ |
| "already modified during refactoring?", //$NON-NLS-1$ |
| attribute.getLocalName()); |
| } |
| } |
| } |
| } |
| } |
| |
| /** Removes any elements targeted for deletion */ |
| private void deleteRemovedElements(List<Element> delete) { |
| if (mFlatten && delete.size() > 0) { |
| for (Element element : delete) { |
| mRefactoring.removeElementTags(mRootEdit, element, delete, |
| false /*changeIndentation*/); |
| } |
| } |
| } |
| |
| /** |
| * Creates refactoring edits which adds or updates the grid attributes |
| */ |
| private void assignGridAttributes() { |
| // We always convert to horizontal grid layouts for now |
| mRefactoring.setAttribute(mRootEdit, mLayout, ANDROID_URI, |
| mNamespace, ATTR_ORIENTATION, VALUE_HORIZONTAL); |
| |
| assignCellAttributes(); |
| } |
| |
| /** |
| * Assign cell attributes to the table, skipping those that will be implied |
| * by the grid model |
| */ |
| private void assignCellAttributes() { |
| int implicitRow = 0; |
| int implicitColumn = 0; |
| int nextRow = 0; |
| for (View view : mViews) { |
| Element element = view.getElement(); |
| if (element == mLayout) { |
| continue; |
| } |
| |
| int row = view.getRow(); |
| int column = view.getColumn(); |
| |
| if (column != implicitColumn && (implicitColumn > 0 || implicitRow > 0)) { |
| mRefactoring.setAttribute(mRootEdit, element, ANDROID_URI, |
| mNamespace, ATTR_LAYOUT_COLUMN, Integer.toString(column)); |
| if (column < implicitColumn) { |
| implicitRow++; |
| } |
| implicitColumn = column; |
| } |
| if (row != implicitRow) { |
| mRefactoring.setAttribute(mRootEdit, element, ANDROID_URI, |
| mNamespace, ATTR_LAYOUT_ROW, Integer.toString(row)); |
| implicitRow = row; |
| } |
| |
| int rowSpan = view.getRowSpan(); |
| int columnSpan = view.getColumnSpan(); |
| assert columnSpan >= 1; |
| |
| if (rowSpan > 1) { |
| mRefactoring.setAttribute(mRootEdit, element, ANDROID_URI, |
| mNamespace, ATTR_LAYOUT_ROW_SPAN, Integer.toString(rowSpan)); |
| } |
| if (columnSpan > 1) { |
| mRefactoring.setAttribute(mRootEdit, element, ANDROID_URI, |
| mNamespace, ATTR_LAYOUT_COLUMN_SPAN, |
| Integer.toString(columnSpan)); |
| } |
| nextRow = Math.max(nextRow, row + rowSpan); |
| |
| // wrap_content is redundant in GridLayouts |
| Attr width = element.getAttributeNodeNS(ANDROID_URI, ATTR_LAYOUT_WIDTH); |
| if (width != null && VALUE_WRAP_CONTENT.equals(width.getValue())) { |
| mRefactoring.removeAttribute(mRootEdit, width); |
| } |
| Attr height = element.getAttributeNodeNS(ANDROID_URI, ATTR_LAYOUT_HEIGHT); |
| if (height != null && VALUE_WRAP_CONTENT.equals(height.getValue())) { |
| mRefactoring.removeAttribute(mRootEdit, height); |
| } |
| |
| // Fix up children moved from LinearLayouts that have "invalid" sizes that |
| // was intended for layout weight handling in their old parent |
| if (LINEAR_LAYOUT.equals(element.getParentNode().getNodeName())) { |
| convert0dipToWrapContent(element); |
| } |
| |
| implicitColumn += columnSpan; |
| if (implicitColumn >= mColumnCount) { |
| implicitColumn = 0; |
| assert nextRow > implicitRow; |
| implicitRow = nextRow; |
| } |
| } |
| } |
| |
| private void processGravities() { |
| for (View view : mViews) { |
| Element element = view.getElement(); |
| if (element == mLayout) { |
| continue; |
| } |
| |
| Attr width = element.getAttributeNodeNS(ANDROID_URI, ATTR_LAYOUT_WIDTH); |
| Attr height = element.getAttributeNodeNS(ANDROID_URI, ATTR_LAYOUT_HEIGHT); |
| String gravity = element.getAttributeNS(ANDROID_URI, ATTR_LAYOUT_GRAVITY); |
| String newGravity = null; |
| if (width != null && (VALUE_MATCH_PARENT.equals(width.getValue()) || |
| VALUE_FILL_PARENT.equals(width.getValue()))) { |
| mRefactoring.removeAttribute(mRootEdit, width); |
| newGravity = gravity = GRAVITY_VALUE_FILL_HORIZONTAL; |
| } |
| if (height != null && (VALUE_MATCH_PARENT.equals(height.getValue()) || |
| VALUE_FILL_PARENT.equals(height.getValue()))) { |
| mRefactoring.removeAttribute(mRootEdit, height); |
| if (newGravity == GRAVITY_VALUE_FILL_HORIZONTAL) { |
| newGravity = GRAVITY_VALUE_FILL; |
| } else { |
| newGravity = GRAVITY_VALUE_FILL_VERTICAL; |
| } |
| gravity = newGravity; |
| } |
| |
| if (gravity == null || gravity.length() == 0) { |
| ElementDescriptor descriptor = view.mInfo.getUiViewNode().getDescriptor(); |
| if (descriptor instanceof ViewElementDescriptor) { |
| ViewElementDescriptor viewDescriptor = (ViewElementDescriptor) descriptor; |
| String fqcn = viewDescriptor.getFullClassName(); |
| FillPreference fill = ViewMetadataRepository.get().getFillPreference(fqcn); |
| gravity = GridLayoutRule.computeDefaultGravity(fill); |
| if (gravity != null) { |
| newGravity = gravity; |
| } |
| } |
| } |
| |
| if (newGravity != null) { |
| mRefactoring.setAttribute(mRootEdit, element, ANDROID_URI, |
| mNamespace, ATTR_LAYOUT_GRAVITY, newGravity); |
| } |
| |
| view.mGravity = newGravity != null ? newGravity : gravity; |
| } |
| } |
| |
| |
| /** Converts 0dip values in layout_width and layout_height to wrap_content instead */ |
| private void convert0dipToWrapContent(Element child) { |
| // Must convert layout_height="0dip" to layout_height="wrap_content". |
| // (And since wrap_content is the default, what we really do is remove |
| // the attribute completely.) |
| // 0dip is a special trick used in linear layouts in the presence of |
| // weights where 0dip ensures that the height of the view is not taken |
| // into account when distributing the weights. However, when converted |
| // to RelativeLayout this will instead cause the view to actually be assigned |
| // 0 height. |
| Attr height = child.getAttributeNodeNS(ANDROID_URI, ATTR_LAYOUT_HEIGHT); |
| // 0dip, 0dp, 0px, etc |
| if (height != null && height.getValue().startsWith("0")) { //$NON-NLS-1$ |
| mRefactoring.removeAttribute(mRootEdit, height); |
| } |
| Attr width = child.getAttributeNodeNS(ANDROID_URI, ATTR_LAYOUT_WIDTH); |
| if (width != null && width.getValue().startsWith("0")) { //$NON-NLS-1$ |
| mRefactoring.removeAttribute(mRootEdit, width); |
| } |
| } |
| |
| /** |
| * Searches a view hierarchy and locates the {@link CanvasViewInfo} for the given |
| * {@link Element} |
| * |
| * @param info the root {@link CanvasViewInfo} to search below |
| * @param element the target element |
| * @return the {@link CanvasViewInfo} which corresponds to the given element |
| */ |
| private CanvasViewInfo findViewForElement(CanvasViewInfo info, Element element) { |
| if (getElement(info) == element) { |
| return info; |
| } |
| |
| for (CanvasViewInfo child : info.getChildren()) { |
| CanvasViewInfo result = findViewForElement(child, element); |
| if (result != null) { |
| return result; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** Returns the {@link Element} for the given {@link CanvasViewInfo} */ |
| private static Element getElement(CanvasViewInfo info) { |
| Node node = info.getUiViewNode().getXmlNode(); |
| if (node instanceof Element) { |
| return (Element) node; |
| } |
| |
| return null; |
| } |
| |
| |
| /** Holds layout information about an individual view */ |
| private static class View { |
| private final Element mElement; |
| private int mRow = -1; |
| private int mCol = -1; |
| private int mRowSpan = -1; |
| private int mColSpan = -1; |
| private int mX1; |
| private int mY1; |
| private int mX2; |
| private int mY2; |
| private CanvasViewInfo mInfo; |
| private String mGravity; |
| |
| public View(CanvasViewInfo view, Element element) { |
| mInfo = view; |
| mElement = element; |
| |
| Rectangle b = mInfo.getAbsRect(); |
| mX1 = b.x; |
| mX2 = b.x + b.width; |
| mY1 = b.y; |
| mY2 = b.y + b.height; |
| } |
| |
| /** |
| * Returns the element for this view |
| * |
| * @return the element for the view |
| */ |
| public Element getElement() { |
| return mElement; |
| } |
| |
| /** |
| * The assigned row for this view |
| * |
| * @return the assigned row |
| */ |
| public int getRow() { |
| return mRow; |
| } |
| |
| /** |
| * The assigned column for this view |
| * |
| * @return the assigned column |
| */ |
| public int getColumn() { |
| return mCol; |
| } |
| |
| /** |
| * The assigned row span for this view |
| * |
| * @return the assigned row span |
| */ |
| public int getRowSpan() { |
| return mRowSpan; |
| } |
| |
| /** |
| * The assigned column span for this view |
| * |
| * @return the assigned column span |
| */ |
| public int getColumnSpan() { |
| return mColSpan; |
| } |
| |
| /** |
| * The left edge of the view to be used for placement |
| * |
| * @return the left edge x coordinate |
| */ |
| public int getLeftEdge() { |
| return mX1; |
| } |
| |
| /** |
| * The top edge of the view to be used for placement |
| * |
| * @return the top edge y coordinate |
| */ |
| public int getTopEdge() { |
| return mY1; |
| } |
| |
| /** |
| * The right edge of the view to be used for placement |
| * |
| * @return the right edge x coordinate |
| */ |
| public int getRightEdge() { |
| return mX2; |
| } |
| |
| /** |
| * The bottom edge of the view to be used for placement |
| * |
| * @return the bottom edge y coordinate |
| */ |
| public int getBottomEdge() { |
| return mY2; |
| } |
| |
| @Override |
| public String toString() { |
| return "View(" + VisualRefactoring.getId(mElement) + ": " + mX1 + "," + mY1 + ")"; |
| } |
| } |
| |
| /** Grid model for the views found in the view hierarchy, partitioned into rows and columns */ |
| private static class GridModel { |
| private final List<View> mViews = new ArrayList<View>(); |
| private final List<Element> mDelete = new ArrayList<Element>(); |
| private final Map<Element, View> mElementToView = new HashMap<Element, View>(); |
| private Element mLayout; |
| private boolean mFlatten; |
| |
| GridModel(CanvasViewInfo view, Element layout, boolean flatten) { |
| mLayout = layout; |
| mFlatten = flatten; |
| |
| scan(view, true); |
| analyzeKnownLayouts(); |
| initializeColumns(); |
| initializeRows(); |
| mDelete.remove(getElement(view)); |
| } |
| |
| /** |
| * Returns the {@link View} objects to be placed in the grid |
| * |
| * @return list of {@link View} objects, never null but possibly empty |
| */ |
| public List<View> getViews() { |
| return mViews; |
| } |
| |
| /** |
| * Returns the list of elements that are scheduled for deletion in the |
| * flattening operation |
| * |
| * @return elements to be deleted, never null but possibly empty |
| */ |
| public List<Element> getDeletedElements() { |
| return mDelete; |
| } |
| |
| /** |
| * Compute and return column count |
| * |
| * @return the column count |
| */ |
| public int computeColumnCount() { |
| int columnCount = 0; |
| for (View view : mViews) { |
| if (view.getElement() == mLayout) { |
| continue; |
| } |
| |
| int column = view.getColumn(); |
| int columnSpan = view.getColumnSpan(); |
| if (column + columnSpan > columnCount) { |
| columnCount = column + columnSpan; |
| } |
| } |
| return columnCount; |
| } |
| |
| /** |
| * Initializes the column and columnSpan attributes of the views |
| */ |
| private void initializeColumns() { |
| // Now initialize table view row, column and spans |
| Map<Integer, List<View>> mColumnViews = new HashMap<Integer, List<View>>(); |
| for (View view : mViews) { |
| if (view.mElement == mLayout) { |
| continue; |
| } |
| int x = view.getLeftEdge(); |
| List<View> list = mColumnViews.get(x); |
| if (list == null) { |
| list = new ArrayList<View>(); |
| mColumnViews.put(x, list); |
| } |
| list.add(view); |
| } |
| |
| List<Integer> columnOffsets = new ArrayList<Integer>(mColumnViews.keySet()); |
| Collections.sort(columnOffsets); |
| |
| int columnIndex = 0; |
| for (Integer column : columnOffsets) { |
| List<View> views = mColumnViews.get(column); |
| if (views != null) { |
| for (View view : views) { |
| view.mCol = columnIndex; |
| } |
| } |
| columnIndex++; |
| } |
| // Initialize column spans |
| for (View view : mViews) { |
| if (view.mElement == mLayout) { |
| continue; |
| } |
| int index = Collections.binarySearch(columnOffsets, view.getRightEdge()); |
| int column; |
| if (index == -1) { |
| // Smaller than the first element; just use the first column |
| column = 0; |
| } else if (index < 0) { |
| column = -(index + 2); |
| } else { |
| column = index; |
| } |
| |
| if (column < view.mCol) { |
| column = view.mCol; |
| } |
| |
| view.mColSpan = column - view.mCol + 1; |
| } |
| } |
| |
| /** |
| * Initializes the row and rowSpan attributes of the views |
| */ |
| private void initializeRows() { |
| Map<Integer, List<View>> mRowViews = new HashMap<Integer, List<View>>(); |
| for (View view : mViews) { |
| if (view.mElement == mLayout) { |
| continue; |
| } |
| int y = view.getTopEdge(); |
| List<View> list = mRowViews.get(y); |
| if (list == null) { |
| list = new ArrayList<View>(); |
| mRowViews.put(y, list); |
| } |
| list.add(view); |
| } |
| |
| List<Integer> rowOffsets = new ArrayList<Integer>(mRowViews.keySet()); |
| Collections.sort(rowOffsets); |
| |
| int rowIndex = 0; |
| for (Integer row : rowOffsets) { |
| List<View> views = mRowViews.get(row); |
| if (views != null) { |
| for (View view : views) { |
| view.mRow = rowIndex; |
| } |
| } |
| rowIndex++; |
| } |
| |
| // Initialize row spans |
| for (View view : mViews) { |
| if (view.mElement == mLayout) { |
| continue; |
| } |
| int index = Collections.binarySearch(rowOffsets, view.getBottomEdge()); |
| int row; |
| if (index == -1) { |
| // Smaller than the first element; just use the first row |
| row = 0; |
| } else if (index < 0) { |
| row = -(index + 2); |
| } else { |
| row = index; |
| } |
| |
| if (row < view.mRow) { |
| row = view.mRow; |
| } |
| |
| view.mRowSpan = row - view.mRow + 1; |
| } |
| } |
| |
| /** |
| * Walks over a given view hierarchy and locates views to be placed in |
| * the grid layout (or deleted if we are flattening the hierarchy) |
| * |
| * @param view the view to analyze |
| * @param isRoot whether this view is the root (which cannot be removed) |
| * @return the {@link View} object for the {@link CanvasViewInfo} |
| * hierarchy we just analyzed, or null |
| */ |
| private View scan(CanvasViewInfo view, boolean isRoot) { |
| View added = null; |
| if (!mFlatten || !isRemovableLayout(view)) { |
| added = add(view); |
| if (!isRoot) { |
| return added; |
| } |
| } else { |
| mDelete.add(getElement(view)); |
| } |
| |
| // Build up a table model of the view |
| for (CanvasViewInfo child : view.getChildren()) { |
| Element childElement = getElement(child); |
| |
| // See if this view shares the edge with the removed |
| // parent layout, and if so, record that such that we can |
| // later handle attachments to the removed parent edges |
| |
| if (mFlatten && isRemovableLayout(child)) { |
| // When flattening, we want to disregard all layouts and instead |
| // add their children! |
| for (CanvasViewInfo childView : child.getChildren()) { |
| scan(childView, false); |
| } |
| mDelete.add(childElement); |
| } else { |
| scan(child, false); |
| } |
| } |
| |
| return added; |
| } |
| |
| /** Adds the given {@link CanvasViewInfo} into our internal view list */ |
| private View add(CanvasViewInfo info) { |
| Element element = getElement(info); |
| View view = new View(info, element); |
| mViews.add(view); |
| mElementToView.put(element, view); |
| return view; |
| } |
| |
| private void analyzeKnownLayouts() { |
| Set<Element> parents = new HashSet<Element>(); |
| for (View view : mViews) { |
| Node parent = view.getElement().getParentNode(); |
| if (parent instanceof Element) { |
| parents.add((Element) parent); |
| } |
| } |
| |
| List<Collection<View>> rowGroups = new ArrayList<Collection<View>>(); |
| List<Collection<View>> columnGroups = new ArrayList<Collection<View>>(); |
| for (Element parent : parents) { |
| String tagName = parent.getTagName(); |
| if (tagName.equals(LINEAR_LAYOUT) || tagName.equals(TABLE_LAYOUT) || |
| tagName.equals(TABLE_ROW) || tagName.equals(RADIO_GROUP)) { |
| Set<View> group = new HashSet<View>(); |
| for (Element child : DomUtilities.getChildren(parent)) { |
| View view = mElementToView.get(child); |
| if (view != null) { |
| group.add(view); |
| } |
| } |
| if (group.size() > 1) { |
| boolean isVertical = VALUE_VERTICAL.equals(parent.getAttributeNS( |
| ANDROID_URI, ATTR_ORIENTATION)); |
| if (tagName.equals(TABLE_LAYOUT)) { |
| isVertical = true; |
| } else if (tagName.equals(TABLE_ROW)) { |
| isVertical = false; |
| } |
| if (isVertical) { |
| columnGroups.add(group); |
| } else { |
| rowGroups.add(group); |
| } |
| } |
| } else if (tagName.equals(RELATIVE_LAYOUT)) { |
| List<Element> children = DomUtilities.getChildren(parent); |
| for (Element child : children) { |
| View view = mElementToView.get(child); |
| if (view == null) { |
| continue; |
| } |
| NamedNodeMap attributes = child.getAttributes(); |
| for (int i = 0, n = attributes.getLength(); i < n; i++) { |
| Attr attr = (Attr) attributes.item(i); |
| String name = attr.getLocalName(); |
| if (name.startsWith(ATTR_LAYOUT_RESOURCE_PREFIX)) { |
| boolean alignVertical = |
| name.equals(ATTR_LAYOUT_ALIGN_TOP) || |
| name.equals(ATTR_LAYOUT_ALIGN_BOTTOM) || |
| name.equals(ATTR_LAYOUT_ALIGN_BASELINE); |
| boolean alignHorizontal = |
| name.equals(ATTR_LAYOUT_ALIGN_LEFT) || |
| name.equals(ATTR_LAYOUT_ALIGN_RIGHT); |
| if (!alignVertical && !alignHorizontal) { |
| continue; |
| } |
| String value = attr.getValue(); |
| if (value.startsWith(ID_PREFIX) |
| || value.startsWith(NEW_ID_PREFIX)) { |
| String targetName = BaseLayoutRule.stripIdPrefix(value); |
| Element target = null; |
| for (Element c : children) { |
| String id = VisualRefactoring.getId(c); |
| if (targetName.equals(BaseLayoutRule.stripIdPrefix(id))) { |
| target = c; |
| break; |
| } |
| } |
| View targetView = mElementToView.get(target); |
| if (targetView != null) { |
| List<View> group = new ArrayList<View>(2); |
| group.add(view); |
| group.add(targetView); |
| if (alignHorizontal) { |
| columnGroups.add(group); |
| } else { |
| assert alignVertical; |
| rowGroups.add(group); |
| } |
| } |
| } |
| } |
| } |
| } |
| } else { |
| // TODO: Consider looking for interesting metadata from other layouts |
| } |
| } |
| |
| // Assign the same top or left coordinates to the groups to ensure that they |
| // all get positioned in the same row or column |
| for (Collection<View> rowGroup : rowGroups) { |
| // Find the smallest one |
| Iterator<View> iterator = rowGroup.iterator(); |
| int smallest = iterator.next().mY1; |
| while (iterator.hasNext()) { |
| smallest = Math.min(smallest, iterator.next().mY1); |
| } |
| for (View view : rowGroup) { |
| view.mY2 -= (view.mY1 - smallest); |
| view.mY1 = smallest; |
| } |
| } |
| for (Collection<View> columnGroup : columnGroups) { |
| Iterator<View> iterator = columnGroup.iterator(); |
| int smallest = iterator.next().mX1; |
| while (iterator.hasNext()) { |
| smallest = Math.min(smallest, iterator.next().mX1); |
| } |
| for (View view : columnGroup) { |
| view.mX2 -= (view.mX1 - smallest); |
| view.mX1 = smallest; |
| } |
| } |
| } |
| |
| /** |
| * Returns true if the given {@link CanvasViewInfo} represents an element we |
| * should remove in a flattening conversion. We don't want to remove non-layout |
| * views, or layout views that for example contain drawables on their own. |
| */ |
| private boolean isRemovableLayout(CanvasViewInfo child) { |
| // The element being converted is NOT removable! |
| Element element = getElement(child); |
| if (element == mLayout) { |
| return false; |
| } |
| |
| ElementDescriptor descriptor = child.getUiViewNode().getDescriptor(); |
| String name = descriptor.getXmlLocalName(); |
| if (name.equals(LINEAR_LAYOUT) || name.equals(RELATIVE_LAYOUT) |
| || name.equals(TABLE_LAYOUT) || name.equals(TABLE_ROW)) { |
| // Don't delete layouts that provide a background image or gradient |
| if (element.hasAttributeNS(ANDROID_URI, ATTR_BACKGROUND)) { |
| AdtPlugin.log(IStatus.WARNING, |
| "Did not flatten layout %1$s because it defines a '%2$s' attribute", |
| VisualRefactoring.getId(element), ATTR_BACKGROUND); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| return false; |
| } |
| } |
| } |
