Home | History | Annotate | Download | only in layout
      1 /*
      2  * Copyright (C) 2009 The Android Open Source Project
      3  *
      4  * Licensed under the Eclipse Public License, Version 1.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.eclipse.org/org/documents/epl-v10.php
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.ide.eclipse.adt.internal.editors.layout;
     18 
     19 import com.android.SdkConstants;
     20 import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.LayoutDescriptors;
     21 import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.ViewElementDescriptor;
     22 import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData;
     23 import com.android.ide.eclipse.adt.internal.sdk.Sdk;
     24 import com.android.sdklib.IAndroidTarget;
     25 
     26 import org.eclipse.core.resources.IProject;
     27 import org.w3c.dom.NamedNodeMap;
     28 import org.w3c.dom.Node;
     29 import org.w3c.dom.NodeList;
     30 
     31 import java.util.ArrayList;
     32 import java.util.Collection;
     33 import java.util.HashMap;
     34 import java.util.HashSet;
     35 import java.util.List;
     36 import java.util.Map;
     37 import java.util.Map.Entry;
     38 import java.util.Set;
     39 
     40 /**
     41  * This class computes the new screen size in "exploded rendering" mode.
     42  * It goes through the whole layout tree and figures out how many embedded layouts will have
     43  * extra padding and compute how that will affect the screen size.
     44  *
     45  * TODO
     46  * - find a better class name :)
     47  * - move the logic for each layout to the layout rule classes?
     48  * - support custom classes (by querying JDT for its super class and reverting to its behavior)
     49  */
     50 public final class ExplodedRenderingHelper {
     51     /** value of the padding in pixel.
     52      * TODO: make a preference?
     53      */
     54     public final static int PADDING_VALUE = 10;
     55 
     56     private final int[] mPadding = new int[] { 0, 0 };
     57     private Set<String> mLayoutNames;
     58 
     59     /**
     60      * Computes the padding. access the result through {@link #getWidthPadding()} and
     61      * {@link #getHeightPadding()}.
     62      * @param root the root node (ie the top layout).
     63      * @param iProject the project to which the layout belong.
     64      */
     65     public ExplodedRenderingHelper(Node root, IProject iProject) {
     66         // get the layout descriptors to get the name of all the layout classes.
     67         IAndroidTarget target = Sdk.getCurrent().getTarget(iProject);
     68         AndroidTargetData data = Sdk.getCurrent().getTargetData(target);
     69         LayoutDescriptors descriptors = data.getLayoutDescriptors();
     70 
     71         mLayoutNames = new HashSet<String>();
     72         List<ViewElementDescriptor> layoutDescriptors = descriptors.getLayoutDescriptors();
     73         for (ViewElementDescriptor desc : layoutDescriptors) {
     74             mLayoutNames.add(desc.getXmlLocalName());
     75         }
     76 
     77         computePadding(root, mPadding);
     78     }
     79 
     80     /**
     81      * (Unit tests only)
     82      * Computes the padding. access the result through {@link #getWidthPadding()} and
     83      * {@link #getHeightPadding()}.
     84      * @param root the root node (ie the top layout).
     85      * @param layoutNames the list of layout classes
     86      */
     87     public ExplodedRenderingHelper(Node root, Set<String> layoutNames) {
     88         mLayoutNames = layoutNames;
     89 
     90         computePadding(root, mPadding);
     91     }
     92 
     93     /**
     94      * Returns the number of extra padding in the X axis. This doesn't return a number of pixel
     95      * or dip, but how many paddings are pushing the screen dimension out.
     96      */
     97     public int getWidthPadding() {
     98         return mPadding[0];
     99     }
    100 
    101     /**
    102      * Returns the number of extra padding in the Y axis. This doesn't return a number of pixel
    103      * or dip, but how many paddings are pushing the screen dimension out.
    104      */
    105     public int getHeightPadding() {
    106         return mPadding[1];
    107     }
    108 
    109     /**
    110      * Computes the number of padding for a given view, and fills the given array of int.
    111      * <p/>index 0 is X axis, index 1 is Y axis
    112      * @param view the view to compute
    113      * @param padding the result padding (index 0 is X axis, index 1 is Y axis)
    114      */
    115     private void computePadding(Node view, int[] padding) {
    116         String localName = view.getLocalName();
    117 
    118         // first compute for each children
    119         NodeList children = view.getChildNodes();
    120         int count = children.getLength();
    121         if (count > 0) {
    122             // compute the padding for all the children.
    123             Map<Node, int[]> childrenPadding = new HashMap<Node, int[]>(count);
    124             for (int i = 0 ; i < count ; i++) {
    125                 Node child = children.item(i);
    126                 short type = child.getNodeType();
    127                 if (type == Node.ELEMENT_NODE) { // ignore TEXT/CDATA nodes.
    128                     int[] p = new int[] { 0, 0 };
    129                     childrenPadding.put(child, p);
    130                     computePadding(child, p);
    131                 }
    132             }
    133 
    134             // since the non ELEMENT_NODE children were filtered out, count must be updated.
    135             count = childrenPadding.size();
    136 
    137             // now combine/compare based on the parent.
    138             if (count == 1) {
    139                 int[] p = childrenPadding.get(childrenPadding.keySet().iterator().next());
    140                 padding[0] = p[0];
    141                 padding[1] = p[1];
    142             } else {
    143                 if ("LinearLayout".equals(localName)) { //$NON-NLS-1$
    144                     String orientation = getAttribute(view, "orientation", null);  //$NON-NLS-1$
    145 
    146                     // default value is horizontal
    147                     boolean horizontal = orientation == null ||
    148                             "horizontal".equals("vertical");  //$NON-NLS-1$  //$NON-NLS-2$
    149                     combineLinearLayout(childrenPadding.values(), padding, horizontal);
    150                 } else if ("TableLayout".equals(localName)) { //$NON-NLS-1$
    151                     combineLinearLayout(childrenPadding.values(), padding, false /*horizontal*/);
    152                 } else if ("TableRow".equals(localName)) { //$NON-NLS-1$
    153                     combineLinearLayout(childrenPadding.values(), padding, true /*true*/);
    154                 // TODO: properly support Relative Layouts.
    155 //                } else if ("RelativeLayout".equals(localName)) { //$NON-NLS-1$
    156 //                    combineRelativeLayout(childrenPadding, padding);
    157                 } else {
    158                     // unknown layout. For now, let's consider it's better to add the children
    159                     // margins in both dimensions than not at all.
    160                     for (int[] p : childrenPadding.values()) {
    161                         padding[0] += p[0];
    162                         padding[1] += p[1];
    163                     }
    164                 }
    165             }
    166         }
    167 
    168         // if the view itself is a layout, add its padding
    169         if (mLayoutNames.contains(localName)) {
    170             padding[0]++;
    171             padding[1]++;
    172         }
    173     }
    174 
    175     /**
    176      * Combines the padding of the children of a linear layout.
    177      * <p/>For this layout, the padding of the children are added in the direction of
    178      * the layout, while the max is taken for the other direction.
    179      * @param paddings the list of the padding for the children.
    180      * @param resultPadding the result padding array to fill.
    181      * @param horizontal whether this layout is horizontal (<code>true</code>) or vertical
    182      * (<code>false</code>)
    183      */
    184     private void combineLinearLayout(Collection<int[]> paddings, int[] resultPadding,
    185             boolean horizontal) {
    186         // The way the children are combined will depend on the direction.
    187         // For instance in a vertical layout, we add the y padding as they all add to the length
    188         // of the needed canvas, while we take the biggest x padding needed by the children
    189 
    190         // the axis in which we take the sum of the padding of the children
    191         int sumIndex = horizontal ? 0 : 1;
    192         // the axis in which we take the max of the padding of the children
    193         int maxIndex = horizontal ? 1 : 0;
    194 
    195         int max = -1;
    196         for (int[] p : paddings) {
    197             resultPadding[sumIndex] += p[sumIndex];
    198             if (max == -1 || max < p[maxIndex]) {
    199                 max = p[maxIndex];
    200             }
    201         }
    202         resultPadding[maxIndex] = max;
    203     }
    204 
    205     /**
    206      * Combine the padding of children of a relative layout.
    207      * @param childrenPadding a map of the children. This is guaranteed that the node object
    208      *  are of type ELEMENT_NODE
    209      * @param padding
    210      *
    211      * TODO: Not used yet. Still need (lots of) work.
    212      */
    213     private void combineRelativeLayout(Map<Node, int[]> childrenPadding, int[] padding) {
    214         /*
    215          * Combines the children of the layout.
    216          * The way this works: for each children, for each direction, look for all the chidrens
    217          * connected and compute the combined margin in that direction.
    218          *
    219          * There's a chance the returned value will be too much. this is due to the layout sometimes
    220          * dropping views which will not be dropped here. It's ok, as it's better to have too
    221          * much than not enough.
    222          * We could fix this by matching those UiElementNode with their bounds as returned
    223          * by the rendering (ie if bounds is 0/0 in h/w, then ignore the child)
    224          */
    225 
    226         // list of the UiElementNode
    227         Set<Node> nodeSet = childrenPadding.keySet();
    228         // map of Id -> node
    229         Map<String, Node> idNodeMap = computeIdNodeMap(nodeSet);
    230 
    231         for (Entry<Node, int[]> entry : childrenPadding.entrySet()) {
    232             Node node = entry.getKey();
    233 
    234             // first horizontal, to the left.
    235             int[] leftResult = getBiggestMarginInDirection(node, 0 /*horizontal*/,
    236                     "layout_toRightOf", "layout_toLeftOf", //$NON-NLS-1$ //$NON-NLS-2$
    237                     childrenPadding, nodeSet, idNodeMap,
    238                     false /*includeThisPadding*/);
    239 
    240             // then to the right
    241             int[] rightResult = getBiggestMarginInDirection(node, 0 /*horizontal*/,
    242                     "layout_toLeftOf", "layout_toRightOf", //$NON-NLS-1$ //$NON-NLS-2$
    243                     childrenPadding, nodeSet, idNodeMap,
    244                     false /*includeThisPadding*/);
    245 
    246             // compute total horizontal margins
    247             int[] thisPadding = childrenPadding.get(node);
    248             int combinedMargin =
    249                 (thisPadding != null ? thisPadding[0] : 0) +
    250                 (leftResult != null ? leftResult[0] : 0) +
    251                 (rightResult != null ? rightResult[0] : 0);
    252             if (combinedMargin > padding[0]) {
    253                 padding[0] = combinedMargin;
    254             }
    255 
    256             // first vertical, above.
    257             int[] topResult = getBiggestMarginInDirection(node, 1 /*horizontal*/,
    258                     "layout_below", "layout_above", //$NON-NLS-1$ //$NON-NLS-2$
    259                     childrenPadding, nodeSet, idNodeMap,
    260                     false /*includeThisPadding*/);
    261 
    262             // then below
    263             int[] bottomResult = getBiggestMarginInDirection(node, 1 /*horizontal*/,
    264                     "layout_above", "layout_below", //$NON-NLS-1$ //$NON-NLS-2$
    265                     childrenPadding, nodeSet, idNodeMap,
    266                     false /*includeThisPadding*/);
    267 
    268             // compute total horizontal margins
    269             combinedMargin =
    270                 (thisPadding != null ? thisPadding[1] : 0) +
    271                 (topResult != null ? topResult[1] : 0) +
    272                 (bottomResult != null ? bottomResult[1] : 0);
    273             if (combinedMargin > padding[1]) {
    274                 padding[1] = combinedMargin;
    275             }
    276         }
    277     }
    278 
    279     /**
    280      * Computes the biggest margin in a given direction.
    281      *
    282      * TODO: Not used yet. Still need (lots of) work.
    283      */
    284     private int[] getBiggestMarginInDirection(Node node, int resIndex, String relativeTo,
    285             String inverseRelation, Map<Node, int[]> childrenPadding,
    286             Set<Node> nodeSet, Map<String, Node> idNodeMap,
    287             boolean includeThisPadding) {
    288         NamedNodeMap attributes = node.getAttributes();
    289 
    290         String viewId = getAttribute(node, "id", attributes); //$NON-NLS-1$
    291 
    292         // first get the item this one is positioned relative to.
    293         String toLeftOfRef = getAttribute(node, relativeTo, attributes);
    294         Node toLeftOf = null;
    295         if (toLeftOfRef != null) {
    296             toLeftOf = idNodeMap.get(cleanUpIdReference(toLeftOfRef));
    297         }
    298 
    299         ArrayList<Node> list = null;
    300         if (viewId != null) {
    301             // now to the left for items being placed to the left of this one.
    302             list = getMatchingNode(nodeSet, cleanUpIdReference(viewId), inverseRelation);
    303         }
    304 
    305         // now process each children in the same direction.
    306         if (toLeftOf != null) {
    307             if (list == null) {
    308                 list = new ArrayList<Node>();
    309             }
    310 
    311             if (list.indexOf(toLeftOf) == -1) {
    312                 list.add(toLeftOf);
    313             }
    314         }
    315 
    316         int[] thisPadding = childrenPadding.get(node);
    317 
    318         if (list != null) {
    319              // since there's a combination to do, we'll return a new result object
    320             int[] result = null;
    321             for (Node nodeOnLeft : list) {
    322                 int[] tempRes = getBiggestMarginInDirection(nodeOnLeft, resIndex, relativeTo,
    323                         inverseRelation, childrenPadding, nodeSet, idNodeMap, true);
    324                 if (tempRes != null && (result == null || result[resIndex] < tempRes[resIndex])) {
    325                     result = tempRes;
    326                 }
    327             }
    328 
    329             // return the combined padding
    330             if (includeThisPadding == false || thisPadding[resIndex] == 0) {
    331                 // just return the one we got since this object adds no padding (or doesn't
    332                 // need to be comibined)
    333                 return result;
    334             } else if (result != null) { // if result is null, the main return below is used.
    335                 // add the result we got with the padding from the current node
    336                 int[] realRes = new int [2];
    337                 realRes[resIndex] = thisPadding[resIndex] + result[resIndex];
    338                 return realRes;
    339             }
    340         }
    341 
    342         // if we reach this, there were no other views to the left of this one, so just return
    343         // the view padding.
    344         return includeThisPadding ? thisPadding : null;
    345     }
    346 
    347     /**
    348      * Computes and returns a map of (id, node) for each node of a given {@link Set}.
    349      * <p/>
    350      * Nodes with no id are ignored and not put in the map.
    351      * @param nodes the nodes to fill the map with.
    352      * @return a newly allocated, non-null, map of (id, node)
    353      */
    354     private Map<String, Node> computeIdNodeMap(Set<Node> nodes) {
    355         Map<String, Node> map = new HashMap<String, Node>();
    356         for (Node node : nodes) {
    357             String viewId = getAttribute(node, "id", null); //$NON-NLS-1$
    358             if (viewId != null) {
    359                 map.put(cleanUpIdReference(viewId), node);
    360             }
    361         }
    362         return map;
    363     }
    364 
    365     /**
    366      * Cleans up a reference to an ID to return the ID itself only.
    367      * @param reference the reference to "clean up".
    368      * @return the id string only.
    369      */
    370     private String cleanUpIdReference(String reference) {
    371         // format is @id/foo or @+id/foo or @android:id/foo, or something similar.
    372         int slash = reference.indexOf('/');
    373         return reference.substring(slash);
    374     }
    375 
    376     /**
    377      * Returns a list of nodes for which a given attribute contains a reference to a given ID.
    378      *
    379      * @param nodes the list of nodes to search through
    380      * @param resId the requested ID
    381      * @param attribute the name of the attribute to test.
    382      * @return a newly allocated, non-null, list of nodes. Could be empty.
    383      */
    384     private ArrayList<Node> getMatchingNode(Set<Node> nodes, String resId,
    385             String attribute) {
    386         ArrayList<Node> list = new ArrayList<Node>();
    387 
    388         for (Node node : nodes) {
    389             String value = getAttribute(node, attribute, null);
    390             if (value != null) {
    391                 value = cleanUpIdReference(value);
    392                 if (value.equals(resId)) {
    393                     list.add(node);
    394                 }
    395             }
    396         }
    397 
    398         return list;
    399     }
    400 
    401     /**
    402      * Returns an attribute for a given node.
    403      * @param node the node to query
    404      * @param name the name of an attribute
    405      * @param attributes the option {@link NamedNodeMap} object to use to read the attributes from.
    406      */
    407     private static String getAttribute(Node node, String name, NamedNodeMap attributes) {
    408         if (attributes == null) {
    409             attributes = node.getAttributes();
    410         }
    411 
    412         if (attributes != null) {
    413             Node attribute = attributes.getNamedItemNS(SdkConstants.NS_RESOURCES, name);
    414             if (attribute != null) {
    415                 return attribute.getNodeValue();
    416             }
    417         }
    418 
    419         return null;
    420     }
    421 }
    422