/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Eclipse Public License, Version 1.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.eclipse.org/org/documents/epl-v10.php
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.ide.common.layout;
import static com.android.SdkConstants.ANDROID_URI;
import static com.android.SdkConstants.ATTR_ID;
import static com.android.SdkConstants.ATTR_LAYOUT_HEIGHT;
import static com.android.SdkConstants.ATTR_LAYOUT_WIDTH;
import static com.android.SdkConstants.ATTR_ORIENTATION;
import static com.android.SdkConstants.VALUE_HORIZONTAL;
import static com.android.SdkConstants.VALUE_VERTICAL;
import com.android.ide.common.api.DropFeedback;
import com.android.ide.common.api.IAttributeInfo.Format;
import com.android.ide.common.api.IDragElement;
import com.android.ide.common.api.IMenuCallback;
import com.android.ide.common.api.INode;
import com.android.ide.common.api.IViewRule;
import com.android.ide.common.api.Point;
import com.android.ide.common.api.Rect;
import com.android.ide.common.api.RuleAction;
import com.android.ide.common.api.RuleAction.NestedAction;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/** Test the {@link LinearLayoutRule} */
public class LinearLayoutRuleTest extends LayoutTestBase {
// Utility for other tests
protected void dragIntoEmpty(Rect dragBounds) {
boolean haveBounds = dragBounds.isValid();
IViewRule rule = new LinearLayoutRule();
INode targetNode = TestNode.create("android.widget.LinearLayout").id(
"@+id/LinearLayout01").bounds(new Rect(0, 0, 240, 480));
Point dropPoint = new Point(10, 5);
IDragElement[] elements = TestDragElement.create(TestDragElement.create(
"android.widget.Button", dragBounds).id("@+id/Button01"));
// Enter target
DropFeedback feedback = rule.onDropEnter(targetNode, null/*targetView*/, elements);
assertNotNull(feedback);
assertFalse(feedback.invalidTarget);
assertNotNull(feedback.painter);
feedback = rule.onDropMove(targetNode, elements, feedback, dropPoint);
assertNotNull(feedback);
assertFalse(feedback.invalidTarget);
// Paint feedback and make sure it's what we expect
TestGraphics graphics = new TestGraphics();
assertNotNull(feedback.painter);
feedback.painter.paint(graphics, targetNode, feedback);
assertEquals(
// Expect to see a recipient rectangle around the bounds of the
// LinearLayout,
// as well as a single vertical line as a drop preview located
// along the left
// edge (for this horizontal linear layout) showing insert
// position at index 0,
// and finally a rectangle for the bounds of the inserted button
// centered over
// the middle
"[useStyle(DROP_RECIPIENT), "
+
// Bounds rectangle
"drawRect(Rect[0,0,240,480]), "
+ "useStyle(DROP_ZONE), drawLine(1,0,1,480), "
+ "useStyle(DROP_ZONE_ACTIVE), " + "useStyle(DROP_PREVIEW), " +
// Insert position line
"drawLine(1,0,1,480)" + (haveBounds ?
// Outline of dragged node centered over position line
", useStyle(DROP_PREVIEW), " + "drawRect(1,0,101,80)"
// Nothing when we don't have bounds
: "") + "]", graphics.getDrawn().toString());
// Attempt a drop
assertEquals(0, targetNode.getChildren().length);
rule.onDropped(targetNode, elements, feedback, dropPoint);
assertEquals(1, targetNode.getChildren().length);
assertEquals("@+id/Button01", targetNode.getChildren()[0].getStringAttr(
ANDROID_URI, ATTR_ID));
}
// Utility for other tests
protected INode dragInto(boolean vertical, Rect dragBounds, Point dragPoint,
int insertIndex, int currentIndex,
String... graphicsFragments) {
INode linearLayout = TestNode.create("android.widget.LinearLayout").id(
"@+id/LinearLayout01").bounds(new Rect(0, 0, 240, 480)).set(ANDROID_URI,
ATTR_ORIENTATION,
vertical ? VALUE_VERTICAL : VALUE_HORIZONTAL)
.add(
TestNode.create("android.widget.Button").id("@+id/Button01").bounds(
new Rect(0, 0, 100, 80)),
TestNode.create("android.widget.Button").id("@+id/Button02").bounds(
new Rect(0, 100, 100, 80)),
TestNode.create("android.widget.Button").id("@+id/Button03").bounds(
new Rect(0, 200, 100, 80)),
TestNode.create("android.widget.Button").id("@+id/Button04").bounds(
new Rect(0, 300, 100, 80)));
return super.dragInto(new LinearLayoutRule(), linearLayout, dragBounds, dragPoint, null,
insertIndex, currentIndex, graphicsFragments);
}
// Check that the context menu registers the expected menu items
public void testContextMenu() {
LinearLayoutRule rule = new LinearLayoutRule();
initialize(rule, "android.widget.LinearLayout");
INode node = TestNode.create("android.widget.Button").id("@+id/Button012");
List<RuleAction> contextMenu = new ArrayList<RuleAction>();
rule.addContextMenuActions(contextMenu, node);
assertEquals(6, contextMenu.size());
assertEquals("Edit ID...", contextMenu.get(0).getTitle());
assertTrue(contextMenu.get(1) instanceof RuleAction.Separator);
assertEquals("Layout Width", contextMenu.get(2).getTitle());
assertEquals("Layout Height", contextMenu.get(3).getTitle());
assertTrue(contextMenu.get(4) instanceof RuleAction.Separator);
assertEquals("Other Properties", contextMenu.get(5).getTitle());
RuleAction propertiesMenu = contextMenu.get(5);
assertTrue(propertiesMenu.getClass().getName(),
propertiesMenu instanceof NestedAction);
}
public void testContextMenuCustom() {
LinearLayoutRule rule = new LinearLayoutRule();
initialize(rule, "android.widget.LinearLayout");
INode node = TestNode.create("android.widget.LinearLayout").id("@+id/LinearLayout")
.set(ANDROID_URI, ATTR_LAYOUT_WIDTH, "42dip")
.set(ANDROID_URI, ATTR_LAYOUT_HEIGHT, "50sp");
List<RuleAction> contextMenu = new ArrayList<RuleAction>();
rule.addContextMenuActions(contextMenu, node);
assertEquals(6, contextMenu.size());
assertEquals("Layout Width", contextMenu.get(2).getTitle());
RuleAction menuAction = contextMenu.get(2);
assertTrue(menuAction instanceof RuleAction.Choices);
RuleAction.Choices choices = (RuleAction.Choices) menuAction;
List<String> titles = choices.getTitles();
List<String> ids = choices.getIds();
assertEquals("Wrap Content", titles.get(0));
assertEquals("wrap_content", ids.get(0));
assertEquals("Match Parent", titles.get(1));
assertEquals("match_parent", ids.get(1));
assertEquals("42dip", titles.get(2));
assertEquals("42dip", ids.get(2));
assertEquals("42dip", choices.getCurrent());
}
// Check that the context menu manipulates the orientation attribute
public void testOrientation() {
LinearLayoutRule rule = new LinearLayoutRule();
initialize(rule, "android.widget.LinearLayout");
TestNode node = TestNode.create("android.widget.LinearLayout").id("@+id/LinearLayout012");
node.putAttributeInfo(ANDROID_URI, "orientation",
new TestAttributeInfo(ATTR_ORIENTATION, Format.ENUM_SET,
"android.widget.LinearLayout",
new String[] {"horizontal", "vertical"}, null, null));
assertNull(node.getStringAttr(ANDROID_URI, ATTR_ORIENTATION));
List<RuleAction> contextMenu = new ArrayList<RuleAction>();
rule.addContextMenuActions(contextMenu, node);
assertEquals(7, contextMenu.size());
RuleAction orientationAction = contextMenu.get(1);
assertEquals("Orientation", orientationAction.getTitle());
assertTrue(orientationAction.getClass().getName(),
orientationAction instanceof RuleAction.Choices);
RuleAction.Choices choices = (RuleAction.Choices) orientationAction;
IMenuCallback callback = choices.getCallback();
callback.action(orientationAction, Collections.singletonList(node), VALUE_VERTICAL, true);
String orientation = node.getStringAttr(ANDROID_URI,
ATTR_ORIENTATION);
assertEquals(VALUE_VERTICAL, orientation);
callback.action(orientationAction, Collections.singletonList(node), VALUE_HORIZONTAL,
true);
orientation = node.getStringAttr(ANDROID_URI, ATTR_ORIENTATION);
assertEquals(VALUE_HORIZONTAL, orientation);
}
// Check that the context menu manipulates the orientation attribute
public void testProperties() {
LinearLayoutRule rule = new LinearLayoutRule();
initialize(rule, "android.widget.LinearLayout");
TestNode node = TestNode.create("android.widget.LinearLayout").id("@+id/LinearLayout012");
node.putAttributeInfo(ANDROID_URI, "orientation",
new TestAttributeInfo(ATTR_ORIENTATION, Format.ENUM_SET,
"android.widget.LinearLayout",
new String[] {"horizontal", "vertical"}, null, null));
node.setAttributeSources(Arrays.asList("android.widget.LinearLayout",
"android.view.ViewGroup", "android.view.View"));
node.putAttributeInfo(ANDROID_URI, "gravity",
new TestAttributeInfo("gravity", Format.INTEGER_SET,
"android.widget.LinearLayout", null, null, null));
assertNull(node.getStringAttr(ANDROID_URI, ATTR_ORIENTATION));
List<RuleAction> contextMenu = new ArrayList<RuleAction>();
rule.addContextMenuActions(contextMenu, node);
assertEquals(8, contextMenu.size());
assertEquals("Orientation", contextMenu.get(1).getTitle());
assertEquals("Edit Gravity...", contextMenu.get(2).getTitle());
assertEquals("Other Properties", contextMenu.get(7).getTitle());
RuleAction propertiesMenu = contextMenu.get(7);
assertTrue(propertiesMenu.getClass().getName(),
propertiesMenu instanceof NestedAction);
NestedAction nested = (NestedAction) propertiesMenu;
List<RuleAction> nestedActions = nested.getNestedActions(node);
assertEquals(9, nestedActions.size());
assertEquals("Recent", nestedActions.get(0).getTitle());
assertTrue(nestedActions.get(1) instanceof RuleAction.Separator);
assertEquals("Defined by LinearLayout", nestedActions.get(2).getTitle());
assertEquals("Inherited from ViewGroup", nestedActions.get(3).getTitle());
assertEquals("Inherited from View", nestedActions.get(4).getTitle());
assertTrue(nestedActions.get(5) instanceof RuleAction.Separator);
assertEquals("Layout Parameters", nestedActions.get(6).getTitle());
assertTrue(nestedActions.get(7) instanceof RuleAction.Separator);
assertEquals("All By Name", nestedActions.get(8).getTitle());
BaseViewRule.editedProperty(ATTR_ORIENTATION);
RuleAction recentAction = nestedActions.get(0);
assertTrue(recentAction instanceof NestedAction);
NestedAction recentChoices = (NestedAction) recentAction;
List<RuleAction> recentItems = recentChoices.getNestedActions(node);
assertEquals(1, recentItems.size());
assertEquals("Orientation", recentItems.get(0).getTitle());
BaseViewRule.editedProperty("gravity");
recentItems = recentChoices.getNestedActions(node);
assertEquals(2, recentItems.size());
assertEquals("Gravity...", recentItems.get(0).getTitle());
assertEquals("Orientation", recentItems.get(1).getTitle());
BaseViewRule.editedProperty(ATTR_ORIENTATION);
recentItems = recentChoices.getNestedActions(node);
assertEquals(2, recentItems.size());
assertEquals("Orientation", recentItems.get(0).getTitle());
assertEquals("Gravity...", recentItems.get(1).getTitle());
// Lots of other properties -- flushes out properties that apply to this view
for (int i = 0; i < 30; i++) {
BaseViewRule.editedProperty("dummy_" + i);
}
recentItems = recentChoices.getNestedActions(node);
assertEquals(0, recentItems.size());
BaseViewRule.editedProperty("gravity");
recentItems = recentChoices.getNestedActions(node);
assertEquals(1, recentItems.size());
assertEquals("Gravity...", recentItems.get(0).getTitle());
}
public void testDragInEmptyWithBounds() {
dragIntoEmpty(new Rect(0, 0, 100, 80));
}
public void testDragInEmptyWithoutBounds() {
dragIntoEmpty(new Rect(0, 0, 0, 0));
}
public void testDragInVerticalTop() {
dragInto(true,
// Bounds of the dragged item
new Rect(0, 0, 105, 80),
// Drag point
new Point(30, -10),
// Expected insert location
0,
// Not dragging one of the existing children
-1,
// Bounds rectangle
"useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",
// Drop zones
"useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,90,240,90), "
+ "drawLine(0,190,240,190), drawLine(0,290,240,290), "
+ "drawLine(0,381,240,381)",
// Active nearest line
"useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,0,240,0)",
// Preview of the dropped rectangle
"useStyle(DROP_PREVIEW), drawRect(0,-40,105,40)");
// Without drag bounds it should be identical except no preview
// rectangle
dragInto(true,
new Rect(0, 0, 0, 0), // Invalid
new Point(30, -10), 0, -1,
"useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,0,240,0)");
}
public void testDragInVerticalBottom() {
dragInto(true,
// Bounds of the dragged item
new Rect(0, 0, 105, 80),
// Drag point
new Point(30, 500),
// Expected insert location
4,
// Not dragging one of the existing children
-1,
// Bounds rectangle
"useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",
// Drop zones
"useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,90,240,90), "
+ "drawLine(0,190,240,190), drawLine(0,290,240,290), drawLine(0,381,240,381), ",
// Active nearest line
"useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,381,240,381)",
// Preview of the dropped rectangle
"useStyle(DROP_PREVIEW), drawRect(0,381,105,461)");
// Check without bounds too
dragInto(true, new Rect(0, 0, 105, 80), new Point(30, 500), 4, -1,
"useStyle(DROP_PREVIEW), drawRect(0,381,105,461)");
}
public void testDragInVerticalMiddle() {
dragInto(true,
// Bounds of the dragged item
new Rect(0, 0, 105, 80),
// Drag point
new Point(0, 170),
// Expected insert location
2,
// Not dragging one of the existing children
-1,
// Bounds rectangle
"useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",
// Drop zones
"useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,90,240,90), "
+ "drawLine(0,190,240,190), drawLine(0,290,240,290)",
// Active nearest line
"useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,190,240,190)",
// Preview of the dropped rectangle
"useStyle(DROP_PREVIEW), drawRect(0,150,105,230)");
// Check without bounds too
dragInto(true, new Rect(0, 0, 105, 80), new Point(0, 170), 2, -1,
"useStyle(DROP_PREVIEW), drawRect(0,150,105,230)");
}
public void testDragInVerticalMiddleSelfPos() {
// Drag the 2nd button, down to the position between 3rd and 4th
dragInto(true,
// Bounds of the dragged item
new Rect(0, 100, 100, 80),
// Drag point
new Point(0, 250),
// Expected insert location
2,
// Dragging 1st item
1,
// Bounds rectangle
"useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",
// Drop zones - these are different because we exclude drop
// zones around the
// dragged item itself (it doesn't make sense to insert directly
// before or after
// myself
"useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,290,240,290), "
+ "drawLine(0,381,240,381)",
// Preview line along insert axis
"useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,290,240,290)",
// Preview of dropped rectangle
"useStyle(DROP_PREVIEW), drawRect(0,250,100,330)");
// Test dropping on self (no position change):
dragInto(true,
// Bounds of the dragged item
new Rect(0, 100, 100, 80),
// Drag point
new Point(0, 210),
// Expected insert location
1,
// Dragging from same pos
1,
// Bounds rectangle
"useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",
// Drop zones - these are different because we exclude drop
// zones around the
// dragged item itself (it doesn't make sense to insert directly
// before or after
// myself
"useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,290,240,290), "
+ "drawLine(0,381,240,381)",
// No active nearest line when you're over the self pos!
// Preview of the dropped rectangle
"useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawRect(0,100,100,180)");
}
public void testDragToLastPosition() {
// Drag a button to the last position -- and confirm that the preview rectangle
// is now shown midway between the second to last and last positions, but fully
// below the drop zone line:
dragInto(true,
// Bounds of the dragged item
new Rect(0, 100, 100, 80),
// Drag point
new Point(0, 400),
// Expected insert location
3,
// Dragging 1st item
1,
// Bounds rectangle
"useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])",
// Drop Zones
"useStyle(DROP_ZONE), drawLine(0,0,240,0), drawLine(0,290,240,290), " +
"drawLine(0,381,240,381), ",
// Active Drop Zone
"useStyle(DROP_ZONE_ACTIVE), useStyle(DROP_PREVIEW), drawLine(0,381,240,381)",
// Drop Preview
"useStyle(DROP_PREVIEW), drawRect(0,381,100,461)");
}
// Left to test:
// Check inserting at last pos with multiple children
// Check inserting with no bounds rectangle for dragged element
}