Home | History | Annotate | Download | only in layout
      1 /*
      2  * Copyright (C) 2010 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.common.layout;
     18 
     19 import static com.android.ide.common.layout.LayoutConstants.ANDROID_URI;
     20 import static com.android.ide.common.layout.LayoutConstants.ATTR_ID;
     21 import static com.android.ide.common.layout.LayoutConstants.ATTR_LAYOUT_HEIGHT;
     22 import static com.android.ide.common.layout.LayoutConstants.ATTR_LAYOUT_WIDTH;
     23 import static com.android.ide.common.layout.LayoutConstants.ATTR_ORIENTATION;
     24 import static com.android.ide.common.layout.LayoutConstants.VALUE_HORIZONTAL;
     25 import static com.android.ide.common.layout.LayoutConstants.VALUE_VERTICAL;
     26 
     27 import com.android.ide.common.api.DropFeedback;
     28 import com.android.ide.common.api.IAttributeInfo.Format;
     29 import com.android.ide.common.api.IDragElement;
     30 import com.android.ide.common.api.IMenuCallback;
     31 import com.android.ide.common.api.INode;
     32 import com.android.ide.common.api.IViewRule;
     33 import com.android.ide.common.api.Point;
     34 import com.android.ide.common.api.Rect;
     35 import com.android.ide.common.api.RuleAction;
     36 import com.android.ide.common.api.RuleAction.NestedAction;
     37 
     38 import java.util.ArrayList;
     39 import java.util.Arrays;
     40 import java.util.Collections;
     41 import java.util.List;
     42 import java.util.Locale;
     43 
     44 /** Test the {@link LinearLayoutRule} */
     45 public class LinearLayoutRuleTest extends LayoutTestBase {
     46     // Utility for other tests
     47     protected void dragIntoEmpty(Rect dragBounds) {
     48         boolean haveBounds = dragBounds.isValid();
     49 
     50         IViewRule rule = new LinearLayoutRule();
     51 
     52         INode targetNode = TestNode.create("android.widget.LinearLayout").id(
     53         "@+id/LinearLayout01").bounds(new Rect(0, 0, 240, 480));
     54         Point dropPoint = new Point(10, 5);
     55 
     56         IDragElement[] elements = TestDragElement.create(TestDragElement.create(
     57                 "android.widget.Button", dragBounds).id("@+id/Button01"));
     58 
     59         // Enter target
     60         DropFeedback feedback = rule.onDropEnter(targetNode, null/*targetView*/, elements);
     61         assertNotNull(feedback);
     62         assertFalse(feedback.invalidTarget);
     63         assertNotNull(feedback.painter);
     64 
     65         feedback = rule.onDropMove(targetNode, elements, feedback, dropPoint);
     66         assertNotNull(feedback);
     67         assertFalse(feedback.invalidTarget);
     68 
     69         // Paint feedback and make sure it's what we expect
     70         TestGraphics graphics = new TestGraphics();
     71         assertNotNull(feedback.painter);
     72         feedback.painter.paint(graphics, targetNode, feedback);
     73         assertEquals(
     74                 // Expect to see a recipient rectangle around the bounds of the
     75                 // LinearLayout,
     76                 // as well as a single vertical line as a drop preview located
     77                 // along the left
     78                 // edge (for this horizontal linear layout) showing insert
     79                 // position at index 0,
     80                 // and finally a rectangle for the bounds of the inserted button
     81                 // centered over
     82                 // the middle
     83                 "[useStyle(DROP_RECIPIENT), "
     84                         +
     85                         // Bounds rectangle
     86                         "drawRect(Rect[0,0,240,480]), "
     87                         + "useStyle(DROP_ZONE), drawLine(1,0,1,480), "
     88                         + "useStyle(DROP_ZONE_ACTIVE), " + "useStyle(DROP_PREVIEW), " +
     89                         // Insert position line
     90                         "drawLine(1,0,1,480)" + (haveBounds ?
     91                         // Outline of dragged node centered over position line
     92                         ", useStyle(DROP_PREVIEW), " + "drawRect(1,0,101,80)"
     93                                 // Nothing when we don't have bounds
     94                                 : "") + "]", graphics.getDrawn().toString());
     95 
     96         // Attempt a drop
     97         assertEquals(0, targetNode.getChildren().length);
     98         rule.onDropped(targetNode, elements, feedback, dropPoint);
     99         assertEquals(1, targetNode.getChildren().length);
    100         assertEquals("@+id/Button01", targetNode.getChildren()[0].getStringAttr(
    101                 ANDROID_URI, ATTR_ID));
    102     }
    103 
    104     // Utility for other tests
    105     protected INode dragInto(boolean vertical, Rect dragBounds, Point dragPoint,
    106             int insertIndex, int currentIndex,
    107             String... graphicsFragments) {
    108         INode linearLayout = TestNode.create("android.widget.LinearLayout").id(
    109                 "@+id/LinearLayout01").bounds(new Rect(0, 0, 240, 480)).set(ANDROID_URI,
    110                 ATTR_ORIENTATION,
    111                 vertical ? VALUE_VERTICAL : VALUE_HORIZONTAL)
    112                 .add(
    113                         TestNode.create("android.widget.Button").id("@+id/Button01").bounds(
    114                                 new Rect(0, 0, 100, 80)),
    115                         TestNode.create("android.widget.Button").id("@+id/Button02").bounds(
    116                                 new Rect(0, 100, 100, 80)),
    117                         TestNode.create("android.widget.Button").id("@+id/Button03").bounds(
    118                                 new Rect(0, 200, 100, 80)),
    119                         TestNode.create("android.widget.Button").id("@+id/Button04").bounds(
    120                                 new Rect(0, 300, 100, 80)));
    121 
    122         return super.dragInto(new LinearLayoutRule(), linearLayout, dragBounds, dragPoint, null,
    123                 insertIndex, currentIndex, graphicsFragments);
    124     }
    125 
    126     // Check that the context menu registers the expected menu items
    127     public void testContextMenu() {
    128         LinearLayoutRule rule = new LinearLayoutRule();
    129         initialize(rule, "android.widget.LinearLayout");
    130         INode node = TestNode.create("android.widget.Button").id("@+id/Button012");
    131 
    132         List<RuleAction> contextMenu = new ArrayList<RuleAction>();
    133         rule.addContextMenuActions(contextMenu, node);
    134         assertEquals(6, contextMenu.size());
    135         assertEquals("Edit ID...", contextMenu.get(0).getTitle());
    136         assertTrue(contextMenu.get(1) instanceof RuleAction.Separator);
    137         assertEquals("Layout Width", contextMenu.get(2).getTitle());
    138         assertEquals("Layout Height", contextMenu.get(3).getTitle());
    139         assertTrue(contextMenu.get(4) instanceof RuleAction.Separator);
    140         assertEquals("Other Properties", contextMenu.get(5).getTitle());
    141 
    142         RuleAction propertiesMenu = contextMenu.get(5);
    143         assertTrue(propertiesMenu.getClass().getName(),
    144                 propertiesMenu instanceof NestedAction);
    145     }
    146 
    147     public void testContextMenuCustom() {
    148         LinearLayoutRule rule = new LinearLayoutRule();
    149         initialize(rule, "android.widget.LinearLayout");
    150         INode node = TestNode.create("android.widget.LinearLayout").id("@+id/LinearLayout")
    151             .set(ANDROID_URI, ATTR_LAYOUT_WIDTH, "42dip")
    152             .set(ANDROID_URI, ATTR_LAYOUT_HEIGHT, "50sp");
    153 
    154         List<RuleAction> contextMenu = new ArrayList<RuleAction>();
    155         rule.addContextMenuActions(contextMenu, node);
    156         assertEquals(6, contextMenu.size());
    157         assertEquals("Layout Width", contextMenu.get(2).getTitle());
    158         RuleAction menuAction = contextMenu.get(2);
    159         assertTrue(menuAction instanceof RuleAction.Choices);
    160         RuleAction.Choices choices = (RuleAction.Choices) menuAction;
    161         List<String> titles = choices.getTitles();
    162         List<String> ids = choices.getIds();
    163         assertEquals("Wrap Content", titles.get(0));
    164         assertEquals("wrap_content", ids.get(0));
    165         assertEquals("Match Parent", titles.get(1));
    166         assertEquals("match_parent", ids.get(1));
    167         assertEquals("42dip", titles.get(2));
    168         assertEquals("42dip", ids.get(2));
    169         assertEquals("42dip", choices.getCurrent());
    170     }
    171 
    172     // Check that the context menu manipulates the orientation attribute
    173     public void testOrientation() {
    174         LinearLayoutRule rule = new LinearLayoutRule();
    175         initialize(rule, "android.widget.LinearLayout");
    176         TestNode node = TestNode.create("android.widget.LinearLayout").id("@+id/LinearLayout012");
    177         node.putAttributeInfo(ANDROID_URI, "orientation",
    178                 new TestAttributeInfo(ATTR_ORIENTATION, new Format[] { Format.ENUM },
    179                         "android.widget.LinearLayout",
    180                         new String[] {"horizontal", "vertical"}, null, null));
    181 
    182         assertNull(node.getStringAttr(ANDROID_URI, ATTR_ORIENTATION));
    183 
    184         List<RuleAction> contextMenu = new ArrayList<RuleAction>();
    185         rule.addContextMenuActions(contextMenu, node);
    186         assertEquals(7, contextMenu.size());
    187         RuleAction orientationAction = contextMenu.get(1);
    188         assertEquals("Orientation", orientationAction.getTitle());
    189 
    190         assertTrue(orientationAction.getClass().getName(),
    191                 orientationAction instanceof RuleAction.Choices);
    192 
    193         RuleAction.Choices choices = (RuleAction.Choices) orientationAction;
    194         IMenuCallback callback = choices.getCallback();
    195         callback.action(orientationAction, Collections.singletonList(node), VALUE_VERTICAL, true);
    196 
    197         String orientation = node.getStringAttr(ANDROID_URI,
    198                 ATTR_ORIENTATION);
    199         assertEquals(VALUE_VERTICAL, orientation);
    200         callback.action(orientationAction, Collections.singletonList(node), VALUE_HORIZONTAL,
    201                 true);
    202         orientation = node.getStringAttr(ANDROID_URI, ATTR_ORIENTATION);
    203         assertEquals(VALUE_HORIZONTAL, orientation);
    204     }
    205 
    206     // Check that the context menu manipulates the orientation attribute
    207     public void testProperties() {
    208         LinearLayoutRule rule = new LinearLayoutRule();
    209         initialize(rule, "android.widget.LinearLayout");
    210         TestNode node = TestNode.create("android.widget.LinearLayout").id("@+id/LinearLayout012");
    211         node.putAttributeInfo(ANDROID_URI, "orientation",
    212                 new TestAttributeInfo(ATTR_ORIENTATION, new Format[] { Format.ENUM },
    213                         "android.widget.LinearLayout",
    214                         new String[] {"horizontal", "vertical"}, null, null));
    215         node.setAttributeSources(Arrays.asList("android.widget.LinearLayout",
    216                 "android.view.ViewGroup", "android.view.View"));
    217         node.putAttributeInfo(ANDROID_URI, "gravity",
    218                 new TestAttributeInfo("gravity", new Format[] { Format.INTEGER },
    219                         "android.widget.LinearLayout", null, null, null));
    220 
    221 
    222         assertNull(node.getStringAttr(ANDROID_URI, ATTR_ORIENTATION));
    223 
    224         List<RuleAction> contextMenu = new ArrayList<RuleAction>();
    225         rule.addContextMenuActions(contextMenu, node);
    226         assertEquals(8, contextMenu.size());
    227 
    228         assertEquals("Orientation", contextMenu.get(1).getTitle());
    229         assertEquals("Edit Gravity...", contextMenu.get(2).getTitle());
    230 
    231         assertEquals("Other Properties", contextMenu.get(7).getTitle());
    232 
    233         RuleAction propertiesMenu = contextMenu.get(7);
    234         assertTrue(propertiesMenu.getClass().getName(),
    235                 propertiesMenu instanceof NestedAction);
    236         NestedAction nested = (NestedAction) propertiesMenu;
    237         List<RuleAction> nestedActions = nested.getNestedActions(node);
    238         assertEquals(9, nestedActions.size());
    239         assertEquals("Recent", nestedActions.get(0).getTitle());
    240         assertTrue(nestedActions.get(1) instanceof RuleAction.Separator);
    241         assertEquals("Defined by LinearLayout", nestedActions.get(2).getTitle());
    242         assertEquals("Inherited from ViewGroup", nestedActions.get(3).getTitle());
    243         assertEquals("Inherited from View", nestedActions.get(4).getTitle());
    244         assertTrue(nestedActions.get(5) instanceof RuleAction.Separator);
    245         assertEquals("Layout Parameters", nestedActions.get(6).getTitle());
    246         assertTrue(nestedActions.get(7) instanceof RuleAction.Separator);
    247         assertEquals("All By Name", nestedActions.get(8).getTitle());
    248 
    249         BaseViewRule.editedProperty(ATTR_ORIENTATION);
    250 
    251         RuleAction recentAction = nestedActions.get(0);
    252         assertTrue(recentAction instanceof NestedAction);
    253         NestedAction recentChoices = (NestedAction) recentAction;
    254         List<RuleAction> recentItems = recentChoices.getNestedActions(node);
    255 
    256         assertEquals(1, recentItems.size());
    257         assertEquals("Orientation", recentItems.get(0).getTitle());
    258 
    259         BaseViewRule.editedProperty("gravity");
    260         recentItems = recentChoices.getNestedActions(node);
    261         assertEquals(2, recentItems.size());
    262         assertEquals("Gravity...", recentItems.get(0).getTitle());
    263         assertEquals("Orientation", recentItems.get(1).getTitle());
    264 
    265         BaseViewRule.editedProperty(ATTR_ORIENTATION);
    266         recentItems = recentChoices.getNestedActions(node);
    267         assertEquals(2, recentItems.size());
    268         assertEquals("Orientation", recentItems.get(0).getTitle());
    269         assertEquals("Gravity...", recentItems.get(1).getTitle());
    270 
    271         // Lots of other properties -- flushes out properties that apply to this view
    272         for (int i = 0; i < 30; i++) {
    273             BaseViewRule.editedProperty("dummy_" + i);
    274         }
    275         recentItems = recentChoices.getNestedActions(node);
    276         assertEquals(0, recentItems.size());
    277 
    278         BaseViewRule.editedProperty("gravity");
    279         recentItems = recentChoices.getNestedActions(node);
    280         assertEquals(1, recentItems.size());
    281         assertEquals("Gravity...", recentItems.get(0).getTitle());
    282     }
    283 
    284     public void testDragInEmptyWithBounds() {
    285         dragIntoEmpty(new Rect(0, 0, 100, 80));
    286     }
    287 
    288     public void testDragInEmptyWithoutBounds() {
    289         dragIntoEmpty(new Rect(0, 0, 0, 0));
    290     }
    291 
    292     public void testDragInVerticalTop() {
    293         dragInto(true,
    294                 // Bounds of the dragged item
    295                 new Rect(0, 0, 105, 80),
    296                 // Drag point
    297                 new Point(30, -10),
    298                 // Expected insert location
    299                 0,
    300                 // Not dragging one of the existing children
    301                 -1,
    302                 // Bounds rectangle
    303                 "useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",
    304 
    305                 // Drop zones
    306                 "useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,90,240,90), "
    307                         + "drawLine(0,190,240,190), drawLine(0,290,240,290), "
    308                         + "drawLine(0,381,240,381)",
    309 
    310                 // Active nearest line
    311                 "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,0,240,0)",
    312 
    313                 // Preview of the dropped rectangle
    314                 "useStyle(DROP_PREVIEW), drawRect(0,-40,105,40)");
    315 
    316         // Without drag bounds it should be identical except no preview
    317         // rectangle
    318         dragInto(true,
    319                 new Rect(0, 0, 0, 0), // Invalid
    320                 new Point(30, -10), 0, -1,
    321                 "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,0,240,0)");
    322     }
    323 
    324     public void testDragInVerticalBottom() {
    325         dragInto(true,
    326                 // Bounds of the dragged item
    327                 new Rect(0, 0, 105, 80),
    328                 // Drag point
    329                 new Point(30, 500),
    330                 // Expected insert location
    331                 4,
    332                 // Not dragging one of the existing children
    333                 -1,
    334                 // Bounds rectangle
    335                 "useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",
    336 
    337                 // Drop zones
    338                 "useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,90,240,90), "
    339                         + "drawLine(0,190,240,190), drawLine(0,290,240,290), drawLine(0,381,240,381), ",
    340 
    341                 // Active nearest line
    342                 "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,381,240,381)",
    343 
    344                 // Preview of the dropped rectangle
    345                 "useStyle(DROP_PREVIEW), drawRect(0,381,105,461)");
    346 
    347         // Check without bounds too
    348         dragInto(true, new Rect(0, 0, 105, 80), new Point(30, 500), 4, -1,
    349                 "useStyle(DROP_PREVIEW), drawRect(0,381,105,461)");
    350     }
    351 
    352     public void testDragInVerticalMiddle() {
    353         dragInto(true,
    354                 // Bounds of the dragged item
    355                 new Rect(0, 0, 105, 80),
    356                 // Drag point
    357                 new Point(0, 170),
    358                 // Expected insert location
    359                 2,
    360                 // Not dragging one of the existing children
    361                 -1,
    362                 // Bounds rectangle
    363                 "useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",
    364 
    365                 // Drop zones
    366                 "useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,90,240,90), "
    367                         + "drawLine(0,190,240,190), drawLine(0,290,240,290)",
    368 
    369                 // Active nearest line
    370                 "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,190,240,190)",
    371 
    372                 // Preview of the dropped rectangle
    373                 "useStyle(DROP_PREVIEW), drawRect(0,150,105,230)");
    374 
    375         // Check without bounds too
    376         dragInto(true, new Rect(0, 0, 105, 80), new Point(0, 170), 2, -1,
    377                 "useStyle(DROP_PREVIEW), drawRect(0,150,105,230)");
    378     }
    379 
    380     public void testDragInVerticalMiddleSelfPos() {
    381         // Drag the 2nd button, down to the position between 3rd and 4th
    382         dragInto(true,
    383                 // Bounds of the dragged item
    384                 new Rect(0, 100, 100, 80),
    385                 // Drag point
    386                 new Point(0, 250),
    387                 // Expected insert location
    388                 2,
    389                 // Dragging 1st item
    390                 1,
    391                 // Bounds rectangle
    392 
    393                 "useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",
    394 
    395                 // Drop zones - these are different because we exclude drop
    396                 // zones around the
    397                 // dragged item itself (it doesn't make sense to insert directly
    398                 // before or after
    399                 // myself
    400                 "useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,290,240,290), "
    401                         + "drawLine(0,381,240,381)",
    402 
    403                 // Preview line along insert axis
    404                 "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,290,240,290)",
    405 
    406                 // Preview of dropped rectangle
    407                 "useStyle(DROP_PREVIEW), drawRect(0,250,100,330)");
    408 
    409         // Test dropping on self (no position change):
    410         dragInto(true,
    411                 // Bounds of the dragged item
    412                 new Rect(0, 100, 100, 80),
    413                 // Drag point
    414                 new Point(0, 210),
    415                 // Expected insert location
    416                 1,
    417                 // Dragging from same pos
    418                 1,
    419                 // Bounds rectangle
    420                 "useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",
    421 
    422                 // Drop zones - these are different because we exclude drop
    423                 // zones around the
    424                 // dragged item itself (it doesn't make sense to insert directly
    425                 // before or after
    426                 // myself
    427                 "useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,290,240,290), "
    428                         + "drawLine(0,381,240,381)",
    429 
    430                 // No active nearest line when you're over the self pos!
    431 
    432                 // Preview of the dropped rectangle
    433                 "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawRect(0,100,100,180)");
    434     }
    435 
    436     public void testDragToLastPosition() {
    437         // Drag a button to the last position -- and confirm that the preview rectangle
    438         // is now shown midway between the second to last and last positions, but fully
    439         // below the drop zone line:
    440         dragInto(true,
    441                 // Bounds of the dragged item
    442                 new Rect(0, 100, 100, 80),
    443                 // Drag point
    444                 new Point(0, 400),
    445                 // Expected insert location
    446                 3,
    447                 // Dragging 1st item
    448                 1,
    449 
    450                 // Bounds rectangle
    451                 "useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",
    452 
    453                 // Drop Zones
    454                 "useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,290,240,290), " +
    455                 "drawLine(0,381,240,381), ",
    456 
    457                 // Active Drop Zone
    458                 "useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,381,240,381)",
    459 
    460                 // Drop Preview
    461                 "useStyle(DROP_PREVIEW), drawRect(0,381,100,461)");
    462     }
    463 
    464     public void testFormatFloatValue() throws Exception {
    465         assertEquals("1", LinearLayoutRule.formatFloatAttribute(1.0f));
    466         assertEquals("2", LinearLayoutRule.formatFloatAttribute(2.0f));
    467         assertEquals("1.50", LinearLayoutRule.formatFloatAttribute(1.5f));
    468         assertEquals("1.50", LinearLayoutRule.formatFloatAttribute(1.50f));
    469         assertEquals("1.51", LinearLayoutRule.formatFloatAttribute(1.51f));
    470         assertEquals("1.51", LinearLayoutRule.formatFloatAttribute(1.514542f));
    471         assertEquals("1.52", LinearLayoutRule.formatFloatAttribute(1.516542f));
    472         assertEquals("-1.51", LinearLayoutRule.formatFloatAttribute(-1.51f));
    473         assertEquals("-1", LinearLayoutRule.formatFloatAttribute(-1f));
    474     }
    475 
    476     public void testFormatFloatValueLocale() throws Exception {
    477         // Ensure that the layout float values aren't affected by
    478         // locale settings, like using commas instead of of periods
    479         Locale originalDefaultLocale = Locale.getDefault();
    480 
    481         try {
    482             Locale.setDefault(Locale.FRENCH);
    483 
    484             // Ensure that this is a locale which uses a comma instead of a period:
    485             assertEquals("5,24", String.format("%.2f", 5.236f));
    486 
    487             // Ensure that the formatFloatAttribute is immune
    488             assertEquals("1.50", LinearLayoutRule.formatFloatAttribute(1.5f));
    489         } finally {
    490             Locale.setDefault(originalDefaultLocale);
    491         }
    492     }
    493 
    494     // Left to test:
    495     // Check inserting at last pos with multiple children
    496     // Check inserting with no bounds rectangle for dragged element
    497 }
    498