diff options
38 files changed, 1394 insertions, 211 deletions
diff --git a/eclipse/dictionary.txt b/eclipse/dictionary.txt index fe06849..b9356c0 100644 --- a/eclipse/dictionary.txt +++ b/eclipse/dictionary.txt @@ -1,5 +1,6 @@ aapt adb +addon adt aidl alt @@ -16,9 +17,11 @@ avds basename bitmask breadcrumb +builtin callback callbacks checkbox +classloader classpath clipboard clipboards @@ -37,13 +40,18 @@ dedent deprecated deselect deselects +designtime dev dex dexified diff +diffs dirs dpi editable +enum +enums +env exec fallback foo @@ -65,6 +73,7 @@ int javadoc layoutlib leaky +lib lifecycle linestyle linux @@ -74,6 +83,7 @@ luminance mac macs marquee +metadata min multi namespace @@ -89,12 +99,16 @@ plugin pre precompiler pref +preload +preloads +primordial printf programmatically proguard proxies proxy recompilation +rect redo regexp registry @@ -107,14 +121,18 @@ scrollbar scrollbars sdk se +searchable semi +serializer settable spec standalone stateless stderr stdout +stretchiness subclassing +submenu supertype syncs themed @@ -122,10 +140,12 @@ tmp tooltip traceview ui +uncomment undescribed uninstall uninstallation uninstalling +upcoming uri url validator diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/IClientRulesEngine.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/IClientRulesEngine.java index 647c6a0..a17af01 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/IClientRulesEngine.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/IClientRulesEngine.java @@ -28,8 +28,6 @@ import com.android.sdklib.annotations.Nullable; * <b>NOTE: This is not a public or final API; if you rely on this be prepared * to adjust your code for the next tools release.</b> * </p> - * - * @see IViewRule#RULES_ENGINE */ public interface IClientRulesEngine { @@ -57,6 +55,14 @@ public interface IClientRulesEngine { IViewRule loadRule(String fqcn); /** + * Returns the metadata associated with the given fully qualified class name. + * + * @param fqcn a fully qualified class name for an Android view class + * @return the metadata associated with the given fully qualified class name. + */ + IViewMetadata getMetadata(String fqcn); + + /** * Displays the given message string in an alert dialog with an "OK" button. */ void displayAlert(String message); diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/IViewMetadata.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/IViewMetadata.java new file mode 100644 index 0000000..9397ef8 --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/IViewMetadata.java @@ -0,0 +1,109 @@ +/* + * 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.api; + +/** + * Metadata about a particular view. The metadata for a View can be found by asking the + * {@link IClientRulesEngine} for the metadata for a given class via + * {@link IClientRulesEngine#getMetadata}. + */ +public interface IViewMetadata { + /** + * Returns true if this view is a potential parent (e.g. it <b>can</b> have children). + * + * @return true if this view can have children + */ + public boolean isParent(); + + /** + * Returns the display name views of this type (a name suitable to display to the + * user, normally capitalized and usually but not necessarily tied to the + * implementation class). To be clear, a specific view may have an id attribute and a + * text attribute, <b>neither</b> of these is the display name. Instead, the class + * android.widget.ZoomControls may have the display name "Zoom Controls", and an + * individual view created into a layout can for example have the id "ZoomControl01". + * + * @return the user visible name of views of this type (never null) + */ + public String getDisplayName(); + + /** + * Returns the tooltip for this view, if any + * + * @return a tooltip, or null + */ + public String getTooltip(); + + /** + * Returns the {@link FillPreference} of this view + * + * @return the {@link FillPreference} of this view + */ + public FillPreference getFillPreference(); + + /** + * Types of fill behavior that views can prefer. + * <p> + * TODO: Consider better names. FillPolicy? Stretchiness? + */ + public enum FillPreference { + /** This view does not want to fill */ + NONE, + /** This view wants to always fill both horizontal and vertical */ + BOTH, + /** This view wants to fill horizontally but not vertically */ + WIDTH, + /** This view wants to fill vertically but not horizontally */ + HEIGHT, + /** + * This view wants to fill in the opposite dimension of the context, e.g. in a + * vertical context it wants to fill horizontally, and vice versa + */ + OPPOSITE, + /** This view wants to fill horizontally, but only in a vertical context */ + WIDTH_IN_VERTICAL, + /** This view wants to fill vertically, but only in a horizontal context */ + HEIGHT_IN_HORIZONTAL; + + /** + * Returns true if this view wants to fill horizontally, if the context is + * vertical or horizontal as indicated by the parameter. + * + * @param verticalContext If true, the context is vertical, otherwise it is + * horizontal. + * @return true if this view wants to fill horizontally + */ + public boolean fillHorizontally(boolean verticalContext) { + return (this == BOTH || this == WIDTH || + (verticalContext && (this == OPPOSITE || this == WIDTH_IN_VERTICAL))); + } + + /** + * Returns true if this view wants to fill vertically, if the context is + * vertical or horizontal as indicated by the parameter. + * + * @param verticalContext If true, the context is vertical, otherwise it is + * horizontal. + * @return true if this view wants to fill vertically + */ + public boolean fillVertically(boolean verticalContext) { + return (this == BOTH || this == HEIGHT || + (!verticalContext && (this == OPPOSITE || this == HEIGHT_IN_HORIZONTAL))); + } + } + +} diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/IViewRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/IViewRule.java index 13699b4..0ec8eb3 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/IViewRule.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/IViewRule.java @@ -17,7 +17,6 @@ package com.android.ide.common.api; import java.util.List; -import java.util.Map; /** @@ -45,13 +44,6 @@ import java.util.Map; public interface IViewRule { /** - * The name of the property that returns a {@link IClientRulesEngine} created for this - * rules. The instance lets rules use some methods from the rules engine, for example - * for accessing other rules. - */ - final static String RULES_ENGINE = "_rules_engine"; - - /** * This method is called by the rule engine when the script is first loaded. * It gives the rule a chance to initialize itself. * @@ -63,7 +55,7 @@ public interface IViewRule { * the engine during initialization and then use it later to invoke some of the * {@link IClientRulesEngine} methods for example to request user input. * @return True if this rule can handle the given FQCN. False if the rule can't handle the - * given FQCN, in which case the rule engine will find another rule matching a parent clas. + * given FQCN, in which case the rule engine will find another rule matching a parent class. */ boolean onInitialize(String fqcn, IClientRulesEngine engine); @@ -140,23 +132,6 @@ public interface IViewRule { INode childNode); - // ==== XML Creation ==== - - /** - * Returns the default attributes that a new XML element of this type should have - * when added to an XML layout file. Note that these defaults can be overridden by the - * specific code performing the insertion. - * - * TODO: - * - added=>created - * - list tuple(uri, local name, str: value) - * - gen id - * - * @return A map of attribute:values for a new element of this type. Can be null or empty. - */ - Map<?, ?> getDefaultAttributes(); - - // ==== Drag'n'drop support ==== /** @@ -215,4 +190,40 @@ public interface IViewRule { * @param pastedElements The elements being pasted. */ void onPaste(INode targetNode, IDragElement[] pastedElements); + + // ==== XML Creation ==== + + /** + * Called when a view for this rule is being created. This allows for the rule to + * customize the newly created object. Note that this method is called not just when a + * view is created from a palette drag, but when views are constructed via a drag-move + * (where views are created in the destination and then deleted from the source), and + * even when views are constructed programmatically from other view rules. The + * {@link InsertType} parameter can be used to distinguish the context for the + * insertion. For example, the <code>DialerFilterRule</code> will insert EditText children + * when a DialerFilter is first created, but not during a copy/paste or a move. + * + * @param node the newly created node (which will always be a View that applies to + * this {@link IViewRule}) + * @param parent the parent of the node (which may not yet contain the newly created + * node in its child list) + * @param insertType whether this node was created as part of a newly created view, or + * as a copy, or as a move, etc. + */ + void onCreate(INode node, INode parent, InsertType insertType); + + /** + * Called when a child for this view has been created and is being inserted into the + * view parent for which this {@link IViewRule} applies. Allows the parent to perform + * customizations of the object. As with {@link #onCreate}, the {@link InsertType} + * parameter can be used to handle new creation versus moves versus copy/paste + * operations differently. + * + * @param child the newly created node + * @param parent the parent of the newly created node (which may not yet contain the + * newly created node in its child list) + * @param insertType whether this node was created as part of a newly created view, or + * as a copy, or as a move, etc. + */ + void onChildInserted(INode child, INode parent, InsertType insertType); } diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/InsertType.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/InsertType.java new file mode 100644 index 0000000..15d3a98 --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/InsertType.java @@ -0,0 +1,35 @@ +/* + * 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.api; + +/** + * An enumerated type of different insertion events, such as an insertion from a + * copy/paste operation or as the first half of a move operation. + */ +public enum InsertType { + /** The view is newly created (by for example a palette drag) */ + CREATE, + + /** The view is being inserted here because it was moved from somewhere else */ + MOVE, + + /** + * The view is being inserted here as a result of a copy/paste from elsewhere + * (including drags, but not from the palette) + */ + PASTE; +} diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/MenuAction.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/MenuAction.java index 210e565..d82049d 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/MenuAction.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/MenuAction.java @@ -152,7 +152,7 @@ public abstract class MenuAction { /** * The base class for {@link Toggle} and {@link Choices}. */ - public static abstract class Action extends MenuAction { + public static class Action extends MenuAction { /** * A callback executed when the action is selected in the context menu. @@ -176,7 +176,7 @@ public abstract class MenuAction { * @param callback The callback executed when the action is selected. * Must not be null. */ - private Action(String id, String title, String groupId, IMenuCallback callback) { + public Action(String id, String title, String groupId, IMenuCallback callback) { super(id, title); mGroupId = groupId; mCallback = callback; diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/Rect.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/Rect.java index 32caf62..b34d729 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/Rect.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/api/Rect.java @@ -16,7 +16,6 @@ package com.android.ide.common.api; -import org.eclipse.swt.graphics.Rectangle; /** @@ -49,11 +48,6 @@ public class Rect { } /** Initialize rectangle to the given values. They can be invalid. */ - public Rect(Rectangle swtRect) { - set(swtRect); - } - - /** Initialize rectangle to the given values. They can be invalid. */ public Rect set(int x, int y, int w, int h) { this.x = x; this.y = y; @@ -68,12 +62,6 @@ public class Rect { return this; } - /** Initialize rectangle to match the given one. */ - public Rect set(Rectangle swtRect) { - set(swtRect.x, swtRect.y, swtRect.width, swtRect.height); - return this; - } - /** Returns a new instance of a rectangle with the same values. */ public Rect copy() { return new Rect(x, y, w, h); @@ -161,11 +149,6 @@ public class Rect { } return this.x == rhs.x && this.y == rhs.y && this.w == rhs.w && this.h == rhs.h; - - } else if (obj instanceof Rectangle) { - Rectangle rhs = (Rectangle) obj; - return this.x == rhs.x && this.y == rhs.y && - this.w == rhs.width && this.h == rhs.height; } return false; @@ -173,10 +156,10 @@ public class Rect { @Override public int hashCode() { - int h = x; - h ^= ((y >> 8) & 0x0FFFFFF) | ((y & 0x00000FF) << 24); - h ^= ((w >> 16) & 0x000FFFF) | ((w & 0x000FFFF) << 16); - h ^= ((h >> 24) & 0x00000FF) | ((h & 0x0FFFFFF) << 8); - return h; + int hc = x; + hc ^= ((y >> 8) & 0x0FFFFFF) | ((y & 0x00000FF) << 24); + hc ^= ((w >> 16) & 0x000FFFF) | ((w & 0x000FFFF) << 16); + hc ^= ((h >> 24) & 0x00000FF) | ((h & 0x0FFFFFF) << 8); + return hc; } } diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/AbsListViewRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/AbsListViewRule.java new file mode 100644 index 0000000..cd1b0fc --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/AbsListViewRule.java @@ -0,0 +1,28 @@ +/* + * 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 com.android.ide.common.api.IViewRule; + +/** + * An {@link IViewRule} for android.widget.AbsListViewRule + */ +public class AbsListViewRule extends IgnoredLayoutRule { + + // GridViews and ListViews are not configurable via XML + +} diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/BaseView.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/BaseView.java index 15871d7..045f36d 100644 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/BaseView.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/BaseView.java @@ -26,6 +26,7 @@ import com.android.ide.common.api.IMenuCallback; import com.android.ide.common.api.INode; import com.android.ide.common.api.INodeHandler; import com.android.ide.common.api.IViewRule; +import com.android.ide.common.api.InsertType; import com.android.ide.common.api.MenuAction; import com.android.ide.common.api.Point; import com.android.ide.common.api.Rect; @@ -45,7 +46,7 @@ import java.util.Set; * Common IViewRule processing to all view and layout classes. */ public class BaseView implements IViewRule { - private IClientRulesEngine mRulesEngine; + protected IClientRulesEngine mRulesEngine; /** * Namespace for the Android resource XML, i.e. @@ -53,23 +54,42 @@ public class BaseView implements IViewRule { */ public static String ANDROID_URI = "http://schemas.android.com/apk/res/android"; //$NON-NLS-1$ + /** The fully qualified class name of an EditText view */ + public static final String FQCN_EDIT_TEXT = "android.widget.EditText"; //$NON-NLS-1$ + + /** The fully qualified class name of a LinearLayout view */ + public static final String FQCN_LINEAR_LAYOUT = "android.widget.LinearLayout"; //$NON-NLS-1$ + + /** The fully qualified class name of a FrameLayout view */ + public static final String FQCN_FRAME_LAYOUT = "android.widget.FrameLayout"; //$NON-NLS-1$ + + /** The fully qualified class name of a TableRow view */ + public static final String FQCN_TABLE_ROW = "android.widget.TableRow"; //$NON-NLS-1$ + + /** The fully qualified class name of a TabWidget view */ + public static final String FQCN_TAB_WIDGET = "android.widget.TabWidget"; //$NON-NLS-1$ + // Some common Android layout attribute names used by the view rules. // All these belong to the attribute namespace ANDROID_URI. - public static String ATTR_ID = "id"; //$NON-NLS-1$ + public static final String ATTR_ID = "id"; //$NON-NLS-1$ - public static String ATTR_TEXT = "text"; //$NON-NLS-1$ + public static final String ATTR_TEXT = "text"; //$NON-NLS-1$ - public static String ATTR_LAYOUT_WIDTH = "layout_width"; //$NON-NLS-1$ + public static final String ATTR_LAYOUT_WIDTH = "layout_width"; //$NON-NLS-1$ - public static String ATTR_LAYOUT_HEIGHT = "layout_height"; //$NON-NLS-1$ + public static final String ATTR_LAYOUT_HEIGHT = "layout_height"; //$NON-NLS-1$ + + public static final String ATTR_SRC = "src"; //$NON-NLS-1$ + + public static final String ATTR_LAYOUT_BELOW = "layout_below"; //$NON-NLS-1$ // Some common Android layout attribute values used by the view rules. - public static String VALUE_FILL_PARENT = "fill_parent"; //$NON-NLS-1$ + public static final String VALUE_FILL_PARENT = "fill_parent"; //$NON-NLS-1$ // like fill_parent for API 8 - public static String VALUE_MATCH_PARENT = "match_parent"; //$NON-NLS-1$ + public static final String VALUE_MATCH_PARENT = "match_parent"; //$NON-NLS-1$ - public static String VALUE_WRAP_CONTENT = "wrap_content"; //$NON-NLS-1$ + public static final String VALUE_WRAP_CONTENT = "wrap_content"; //$NON-NLS-1$ // Cache of attributes. Key is FQCN of a node mixed with its view hierarchy // parent. Values are a custom map as needed by getContextMenu. @@ -98,11 +118,6 @@ public class BaseView implements IViewRule { return null; } - public Map<?, ?> getDefaultAttributes() { - // The base rule does not have any custom default attributes. - return null; - } - // === Context Menu === /** @@ -531,4 +546,26 @@ public class BaseView implements IViewRule { return mChoices; } } + + /** + * Returns a source attribute value which points to a sample image. This is typically + * used to provide an initial image shown on ImageButtons, etc. There is no guarantee + * that the source pointed to by this method actually exists. + * + * @return a source attribute to use for sample images, never null + */ + protected String getSampleImageSrc() { + // For now, we point to the sample icon which is written into new Android projects + // created in ADT. We could alternatively look into the project resources folder + // and try to pick something else, or even return some builtin image resource + // in the @android namespace. + + return "@drawable/icon"; //$NON-NLS-1$ + } + + public void onCreate(INode node, INode parent, InsertType insertType) { + } + + public void onChildInserted(INode node, INode parent, InsertType insertType) { + } } diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/DialerFilterRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/DialerFilterRule.java new file mode 100644 index 0000000..54b511e --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/DialerFilterRule.java @@ -0,0 +1,53 @@ +/* + * 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 com.android.ide.common.api.INode; +import com.android.ide.common.api.IViewRule; +import com.android.ide.common.api.InsertType; + +/** + * An {@link IViewRule} for android.widget.DialerFilterRule. + */ +public class DialerFilterRule extends BaseView { + + @Override + public void onCreate(INode node, INode parent, InsertType insertType) { + super.onCreate(node, parent, insertType); + + // A DialerFilter requires a couple of nested EditTexts with fixed ids: + if (insertType == InsertType.CREATE) { + INode hint = node.appendChild(FQCN_EDIT_TEXT); + hint.setAttribute(ANDROID_URI, BaseView.ATTR_TEXT, "Hint"); + hint.setAttribute(ANDROID_URI, ATTR_ID, "@android:id/hint"); //$NON-NLS-1$ + hint.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, VALUE_FILL_PARENT); + + INode primary = node.appendChild(FQCN_EDIT_TEXT); + primary.setAttribute(ANDROID_URI, BaseView.ATTR_TEXT, "Primary"); + primary.setAttribute(ANDROID_URI, ATTR_ID, "@android:id/primary"); //$NON-NLS-1$ + primary.setAttribute(ANDROID_URI, ATTR_LAYOUT_BELOW, + "@android:id/hint"); //$NON-NLS-1$ + primary.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, VALUE_FILL_PARENT); + + + // What do we initialize the icon to? + //INode icon = node.appendChild("android.widget.ImageView"); //$NON-NLS-1$ + //icon.setAttribute(ANDROID_URI, ATTR_ID, "@android:id/icon"); //$NON-NLS-1$ + } + } + +} diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/HorizontalScrollViewRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/HorizontalScrollViewRule.java new file mode 100644 index 0000000..547dc04 --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/HorizontalScrollViewRule.java @@ -0,0 +1,50 @@ +/* + * 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 com.android.ide.common.api.INode; +import com.android.ide.common.api.IViewRule; +import com.android.ide.common.api.InsertType; + +/** + * An {@link IViewRule} for android.widget.HorizontalScrollView. + */ +public class HorizontalScrollViewRule extends BaseView { + + @Override + public void onChildInserted(INode child, INode parent, InsertType insertType) { + super.onChildInserted(child, parent, insertType); + + // The child of the ScrollView should fill in both directions + child.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, VALUE_FILL_PARENT); + child.setAttribute(ANDROID_URI, ATTR_LAYOUT_HEIGHT, VALUE_FILL_PARENT); + } + + @Override + public void onCreate(INode node, INode parent, InsertType insertType) { + super.onCreate(node, parent, insertType); + + if (insertType == InsertType.CREATE) { + // Insert a horizontal linear layout which is commonly used with horizontal scrollbars + // as described by the documentation for HorizontalScrollbars. + INode linearLayout = node.appendChild(FQCN_LINEAR_LAYOUT); + linearLayout.setAttribute(ANDROID_URI, LinearLayoutRule.ATTR_ORIENTATION, + LinearLayoutRule.VALUE_HORIZONTAL); + } + } + +} diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/ImageButtonRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/ImageButtonRule.java new file mode 100644 index 0000000..7a23f17 --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/ImageButtonRule.java @@ -0,0 +1,37 @@ +/* + * 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 com.android.ide.common.api.INode; +import com.android.ide.common.api.IViewRule; +import com.android.ide.common.api.InsertType; + +/** + * An {@link IViewRule} for android.widget.ImageButtonRule. + */ +public class ImageButtonRule extends BaseView { + + @Override + public void onCreate(INode node, INode parent, InsertType insertType) { + super.onCreate(node, parent, insertType); + + if (insertType == InsertType.CREATE) { + node.setAttribute(ANDROID_URI, ATTR_SRC, getSampleImageSrc()); + } + } + +} diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/ImageViewRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/ImageViewRule.java new file mode 100644 index 0000000..67cd422 --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/ImageViewRule.java @@ -0,0 +1,37 @@ +/* + * 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 com.android.ide.common.api.INode; +import com.android.ide.common.api.IViewRule; +import com.android.ide.common.api.InsertType; + +/** + * An {@link IViewRule} for android.widget.ImageViewRule. + */ +public class ImageViewRule extends BaseView { + + @Override + public void onCreate(INode node, INode parent, InsertType insertType) { + super.onCreate(node, parent, insertType); + + if (insertType == InsertType.CREATE) { + node.setAttribute(ANDROID_URI, ATTR_SRC, getSampleImageSrc()); + } + } + +} diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/LinearLayoutRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/LinearLayoutRule.java index e5334f8..e31424c 100644 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/LinearLayoutRule.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/LinearLayoutRule.java @@ -24,10 +24,13 @@ import com.android.ide.common.api.IGraphics; import com.android.ide.common.api.IMenuCallback; import com.android.ide.common.api.INode; import com.android.ide.common.api.INodeHandler; +import com.android.ide.common.api.IViewMetadata; import com.android.ide.common.api.IViewRule; +import com.android.ide.common.api.InsertType; import com.android.ide.common.api.MenuAction; import com.android.ide.common.api.Point; import com.android.ide.common.api.Rect; +import com.android.ide.common.api.IViewMetadata.FillPreference; import java.util.ArrayList; import java.util.List; @@ -47,34 +50,57 @@ public class LinearLayoutRule extends BaseLayout { */ @Override public List<MenuAction> getContextMenu(final INode selectedNode) { + if (supportsOrientation()) { + String curr_orient = selectedNode.getStringAttr(ANDROID_URI, ATTR_ORIENTATION); + if (curr_orient == null || curr_orient.length() == 0) { + curr_orient = VALUE_HORIZONTAL; + } - String curr_orient = selectedNode.getStringAttr(ANDROID_URI, ATTR_ORIENTATION); - if (curr_orient == null || curr_orient.length() == 0) { - curr_orient = VALUE_HORIZONTAL; + IMenuCallback onChange = new IMenuCallback() { + public void action(MenuAction action, final String valueId, Boolean newValue) { + String actionId = action.getId(); + final INode node = selectedNode; + + if (actionId.equals("_orientation")) { //$NON-NLS-1$ + node.editXml("Change LinearLayout " + ATTR_ORIENTATION, new INodeHandler() { + public void handle(INode n) { + node.setAttribute(ANDROID_URI, ATTR_ORIENTATION, valueId); + } + }); + } + } + }; + + return concatenate(super.getContextMenu(selectedNode), + new MenuAction.Choices("_orientation", "Orientation", //$NON-NLS-1$ + mapify( + "horizontal", "Horizontal", //$NON-NLS-1$ + "vertical", "Vertical" //$NON-NLS-1$ + ), + curr_orient, onChange)); + } else { + return super.getContextMenu(selectedNode); } + } - IMenuCallback onChange = new IMenuCallback() { - public void action(MenuAction action, final String valueId, Boolean newValue) { - String actionId = action.getId(); - final INode node = selectedNode; + /** + * Returns true if the given node represents a vertical linear layout. + * @param node the node to check layout orientation for + * @return true if the layout is in vertical mode, otherwise false + */ + protected boolean isVertical(INode node) { + // Horizontal is the default, so if no value is specified it is horizontal. + return VALUE_VERTICAL.equals(node.getStringAttr(ANDROID_URI, + ATTR_ORIENTATION)); + } - if (actionId.equals("_orientation")) { //$NON-NLS-1$ - node.editXml("Change LinearLayout " + ATTR_ORIENTATION, new INodeHandler() { - public void handle(INode n) { - node.setAttribute(ANDROID_URI, ATTR_ORIENTATION, valueId); - } - }); - } - } - }; - - return concatenate(super.getContextMenu(selectedNode), - new MenuAction.Choices("_orientation", "Orientation", //$NON-NLS-1$ - mapify( - "horizontal", "Horizontal", //$NON-NLS-1$ - "vertical", "Vertical" //$NON-NLS-1$ - ), - curr_orient, onChange)); + /** + * Returns true if this LinearLayout supports switching orientation. + * + * @return true if this layout supports orientations + */ + protected boolean supportsOrientation() { + return true; } // ==== Drag'n'drop support ==== @@ -91,8 +117,7 @@ public class LinearLayoutRule extends BaseLayout { return null; } - boolean isVertical = VALUE_VERTICAL.equals(targetNode.getStringAttr(ANDROID_URI, - ATTR_ORIENTATION)); + boolean isVertical = isVertical(targetNode); // Prepare a list of insertion points: X coords for horizontal, Y for // vertical. @@ -247,11 +272,28 @@ public class LinearLayoutRule extends BaseLayout { gc.useStyle(DrawingStyle.DROP_PREVIEW); for (IDragElement element : elements) { Rect bounds = element.getBounds(); - if (bounds.isValid() && (bounds.w > b.w || bounds.h > b.h)) { + if (bounds.isValid() && (bounds.w > b.w || bounds.h > b.h) && + node.getChildren().length == 0) { // The bounds of the child does not fully fit inside the target. - // Limit the bounds to the layout bounds. - Rect within = new Rect(b.x, b.y, - Math.min(bounds.w, b.w), Math.min(bounds.h, b.h)); + // Limit the bounds to the layout bounds (but only when there + // are no children, since otherwise positioning around the existing + // children gets difficult) + final int px, py, pw, ph; + if (bounds.w > b.w) { + px = b.x; + pw = b.w; + } else { + px = bounds.x + offsetX; + pw = bounds.w; + } + if (bounds.h > b.h) { + py = b.y; + ph = b.h; + } else { + py = bounds.y + offsetY; + ph = bounds.h; + } + Rect within = new Rect(px, py, pw, ph); gc.drawRect(within); } else { drawElement(gc, element, offsetX, offsetY); @@ -369,6 +411,25 @@ public class LinearLayoutRule extends BaseLayout { }); } + @Override + public void onChildInserted(INode node, INode parent, InsertType insertType) { + // Attempt to set fill-properties on newly added views such that for example, + // in a vertical layout, a text field defaults to filling horizontally, but not + // vertically. + String fqcn = node.getFqcn(); + IViewMetadata metadata = mRulesEngine.getMetadata(fqcn); + if (metadata != null) { + boolean vertical = isVertical(parent); + FillPreference fill = metadata.getFillPreference(); + if (fill.fillHorizontally(vertical)) { + node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, VALUE_FILL_PARENT); + } + if (fill.fillVertically(vertical)) { + node.setAttribute(ANDROID_URI, ATTR_LAYOUT_HEIGHT, VALUE_FILL_PARENT); + } + } + } + /** A possible match position */ private class MatchPos { /** The pixel distance */ diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/ListViewRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/ListViewRule.java index 67a3cf3..347057a 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/ListViewRule.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/ListViewRule.java @@ -16,10 +16,9 @@ package com.android.ide.common.layout; +import com.android.ide.common.api.INode; import com.android.ide.common.api.IViewRule; - -import java.util.HashMap; -import java.util.Map; +import com.android.ide.common.api.InsertType; /** * An {@link IViewRule} for android.widget.ListView and all its derived classes. @@ -28,19 +27,10 @@ import java.util.Map; */ public class ListViewRule extends BaseView { - // ==== XML Creation ==== - - /** - * The default for new views is to be wrap_content on both width/height. - * However ListView is special in that ideally we want fill_parent width by - * default. - */ @Override - public Map<?, ?> getDefaultAttributes() { - // TODO: find a way to plug in the new value VALUE_MATCH_PARENT. - Map<String, String> result = new HashMap<String, String>(); - result.put(ATTR_LAYOUT_WIDTH, VALUE_FILL_PARENT); - return result; - } + public void onCreate(INode node, INode parent, InsertType insertType) { + super.onCreate(node, parent, insertType); + node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, VALUE_FILL_PARENT); + } } diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/MapViewRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/MapViewRule.java new file mode 100644 index 0000000..2eff369 --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/MapViewRule.java @@ -0,0 +1,42 @@ +/* + * 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 com.android.ide.common.api.INode; +import com.android.ide.common.api.IViewRule; +import com.android.ide.common.api.InsertType; + +/** + * An {@link IViewRule} for com.google.android.maps.MapView. + * <p> + * TODO: This class should be pulled out of the ADT and bundled with the add ons + * (not the core jar but an optional tool jar) + */ +public class MapViewRule extends BaseView { + + @Override + public void onCreate(INode node, INode parent, InsertType insertType) { + super.onCreate(node, parent, insertType); + + if (insertType == InsertType.CREATE) { + node.setAttribute(ANDROID_URI, "android:apiKey", //$NON-NLS-1$ + "Your API key: see " + //$NON-NLS-1$ + "http://code.google.com/android/add-ons/google-apis/mapkey.html"); //$NON-NLS-1$ + } + } + +} diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/ScrollViewRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/ScrollViewRule.java new file mode 100644 index 0000000..5ce8bad --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/ScrollViewRule.java @@ -0,0 +1,49 @@ +/* + * 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 com.android.ide.common.api.INode; +import com.android.ide.common.api.IViewRule; +import com.android.ide.common.api.InsertType; + +/** + * An {@link IViewRule} for android.widget.ScrollView. + */ +public class ScrollViewRule extends BaseView { + + @Override + public void onChildInserted(INode child, INode parent, InsertType insertType) { + super.onChildInserted(child, parent, insertType); + + // The child of the ScrollView should fill in both directions + child.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, VALUE_FILL_PARENT); + child.setAttribute(ANDROID_URI, ATTR_LAYOUT_HEIGHT, VALUE_FILL_PARENT); + } + + @Override + public void onCreate(INode node, INode parent, InsertType insertType) { + super.onCreate(node, parent, insertType); + + if (insertType == InsertType.CREATE) { + // Insert a default linear layout (which will in turn be registered as + // a child of this node and the create child method above will set its + // fill parent attributes, its id, etc. + node.appendChild(FQCN_LINEAR_LAYOUT); + } + } + +} diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/SeekBarRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/SeekBarRule.java new file mode 100644 index 0000000..b6d184f --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/SeekBarRule.java @@ -0,0 +1,37 @@ +/* + * 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 com.android.ide.common.api.INode; +import com.android.ide.common.api.IViewRule; +import com.android.ide.common.api.InsertType; + +/** + * An {@link IViewRule} for android.widget.SeekBar + */ +public class SeekBarRule extends BaseView { + + @Override + public void onCreate(INode node, INode parent, InsertType insertType) { + super.onCreate(node, parent, insertType); + + // A SeekBar isn't useful with wrap_content because it packs itself down to + // almost no usable width -- so just make it grow in all layouts + node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, VALUE_FILL_PARENT); + } + +} diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/TabHostRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/TabHostRule.java index 4885bb9..f47da68 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/TabHostRule.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/TabHostRule.java @@ -16,7 +16,9 @@ package com.android.ide.common.layout; +import com.android.ide.common.api.INode; import com.android.ide.common.api.IViewRule; +import com.android.ide.common.api.InsertType; /** * An {@link IViewRule} for android.widget.TabHost. @@ -26,6 +28,32 @@ public class TabHostRule extends IgnoredLayoutRule { // manipulate its children via the TabHost rather than directly manipulating // the child elements yourself, e.g. via addTab() etc. - // TODO: We should add a context menu here to add tabs. We should also add - // creation code to pre-populate a tab + @Override + public void onCreate(INode node, INode parent, InsertType insertType) { + super.onCreate(node, parent, insertType); + + if (insertType == InsertType.CREATE) { + // Configure default Table setup as described in the Table tutorial + node.setAttribute(ANDROID_URI, ATTR_ID, "@android:id/tabhost"); //$NON-NLS-1$ + node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, VALUE_FILL_PARENT); + node.setAttribute(ANDROID_URI, ATTR_LAYOUT_HEIGHT, VALUE_FILL_PARENT); + + INode linear = node.appendChild(FQCN_LINEAR_LAYOUT); + linear.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, VALUE_FILL_PARENT); + linear.setAttribute(ANDROID_URI, ATTR_LAYOUT_HEIGHT, VALUE_FILL_PARENT); + linear.setAttribute(ANDROID_URI, LinearLayoutRule.ATTR_ORIENTATION, + LinearLayoutRule.VALUE_VERTICAL); + + INode tab = linear.appendChild(FQCN_TAB_WIDGET); + tab.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, VALUE_FILL_PARENT); + tab.setAttribute(ANDROID_URI, ATTR_LAYOUT_HEIGHT, VALUE_WRAP_CONTENT); + tab.setAttribute(ANDROID_URI, ATTR_ID, "@android:id/tabs"); //$NON-NLS-1$ + + INode frame = linear.appendChild(FQCN_FRAME_LAYOUT); + frame.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH, VALUE_FILL_PARENT); + frame.setAttribute(ANDROID_URI, ATTR_LAYOUT_HEIGHT, VALUE_FILL_PARENT); + frame.setAttribute(ANDROID_URI, ATTR_ID, "@android:id/tabcontent"); //$NON-NLS-1$ + } + } + } diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/TableLayoutRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/TableLayoutRule.java new file mode 100644 index 0000000..a4d528c --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/TableLayoutRule.java @@ -0,0 +1,68 @@ +/* + * 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 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.InsertType; +import com.android.ide.common.api.MenuAction; + +import java.util.List; + +/** + * An {@link IViewRule} for android.widget.TableLayout. + */ +public class TableLayoutRule extends LinearLayoutRule { + // A table is a linear layout, but with a few differences: + // the default is vertical, not horizontal + // The fill of all children should be wrap_content + + @Override + protected boolean isVertical(INode node) { + // Tables are always vertical + return true; + } + + @Override + protected boolean supportsOrientation() { + return false; + } + + @Override + public void onChildInserted(INode node, INode parent, InsertType insertType) { + // Overridden to inhibit the setting of layout_width/layout_height since + // it should always be match_parent + } + + /** + * Add an explicit "Add Row" action to the context menu + */ + @Override + public List<MenuAction> getContextMenu(final INode selectedNode) { + IMenuCallback addTab = new IMenuCallback() { + public void action(MenuAction action, final String valueId, Boolean newValue) { + final INode node = selectedNode; + node.appendChild(FQCN_TABLE_ROW); + + } + }; + return concatenate(super.getContextMenu(selectedNode), + new MenuAction.Action("_addrow", "Add Row", //$NON-NLS-1$ + null, addTab)); + } + +} diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/TableRowRule.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/TableRowRule.java new file mode 100644 index 0000000..e734f4a --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/common/layout/TableRowRule.java @@ -0,0 +1,43 @@ +/* + * 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 com.android.ide.common.api.INode; +import com.android.ide.common.api.IViewRule; +import com.android.ide.common.api.InsertType; + +/** + * An {@link IViewRule} for android.widget.TableRow. + */ +public class TableRowRule extends LinearLayoutRule { + @Override + protected boolean isVertical(INode node) { + return false; + } + + @Override + protected boolean supportsOrientation() { + return false; + } + + @Override + public void onChildInserted(INode child, INode parent, InsertType insertType) { + // Overridden to inhibit the setting of layout_width/layout_height since + // the table row will enforce match_parent and wrap_content for width and height + // respectively. + } + +} diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/AndroidConstants.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/AndroidConstants.java index 04abe34..9c31b11 100644 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/AndroidConstants.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/AndroidConstants.java @@ -127,10 +127,10 @@ public class AndroidConstants { /** Absolute path of the workspace root, i.e. "/" */ public final static String WS_ROOT = WS_SEP; - /** Absolute path of the resource folder, eg "/res".<br> This is a workspace path. */ + /** Absolute path of the resource folder, e.g. "/res".<br> This is a workspace path. */ public final static String WS_RESOURCES = WS_SEP + SdkConstants.FD_RESOURCES; - /** Absolute path of the resource folder, eg "/assets".<br> This is a workspace path. */ + /** Absolute path of the resource folder, e.g. "/assets".<br> This is a workspace path. */ public final static String WS_ASSETS = WS_SEP + SdkConstants.FD_ASSETS; /** Leaf of the javaDoc folder. Does not start with a separator. */ @@ -212,7 +212,7 @@ public class AndroidConstants { public final static String MARKER_ATTR_TYPE_PROVIDER = "provider"; //$NON-NLS-1$ /** - * Prefered compiler level, i.e. "1.5". + * Preferred compiler level, i.e. "1.5". */ public final static String COMPILER_COMPLIANCE_PREFERRED = "1.5"; //$NON-NLS-1$ /** diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/IconFactory.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/IconFactory.java index a899bba..0c10363 100644 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/IconFactory.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/IconFactory.java @@ -198,7 +198,7 @@ public class IconFactory { gc.setAntialias(SWT.ON); gc.setTextAntialias(SWT.ON); - // image.setBackground() does not appear to have any affect; we must explicitly + // image.setBackground() does not appear to have any effect; we must explicitly // paint into the image the background color we want masked out later. // HOWEVER, alpha transparency does not work; we only get to mark a single color // as transparent. You might think we could pick a system color (to avoid having diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/IGraphicalLayoutEditor.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/IGraphicalLayoutEditor.java index 3a22b64..c200e47 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/IGraphicalLayoutEditor.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/IGraphicalLayoutEditor.java @@ -22,6 +22,7 @@ import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode; import com.android.layoutlib.api.LayoutScene; import org.eclipse.core.resources.IFile; +import org.eclipse.draw2d.geometry.Rectangle; import org.eclipse.ui.IEditorPart; import java.util.Set; @@ -96,8 +97,10 @@ public interface IGraphicalLayoutEditor extends IEditorPart { * * @param model the model to be rendered, which can be different than the editor's own * {@link #getModel()}. - * @param width the width to use for the layout - * @param height the height to use for the layout + * @param width the width to use for the layout, or -1 to use the width of the screen + * associated with this editor + * @param height the height to use for the layout, or -1 to use the height of the screen + * associated with this editor * @param explodeNodes a set of nodes to explode, or null for none * @param transparentBackground If true, the rendering will <b>not</b> paint the * normal background requested by the theme, and it will instead paint the @@ -107,4 +110,10 @@ public interface IGraphicalLayoutEditor extends IEditorPart { abstract LayoutScene render(UiDocumentNode model, int width, int height, Set<UiElementNode> explodeNodes, boolean transparentBackground); + /** + * Returns the current bounds of the Android device screen, in canvas control pixels + * + * @return the bounds of the screen, never null + */ + abstract Rectangle getScreenBounds(); } diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/LayoutEditor.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/LayoutEditor.java index ed8a205..41bf099 100644 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/LayoutEditor.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/LayoutEditor.java @@ -28,6 +28,7 @@ import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.ViewEleme import com.android.ide.eclipse.adt.internal.editors.layout.gle2.GraphicalEditorPart; import com.android.ide.eclipse.adt.internal.editors.layout.gle2.OutlinePage2; import com.android.ide.eclipse.adt.internal.editors.layout.gle2.PropertySheetPage2; +import com.android.ide.eclipse.adt.internal.editors.layout.gre.RulesEngine; import com.android.ide.eclipse.adt.internal.editors.uimodel.UiDocumentNode; import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; import com.android.ide.eclipse.adt.internal.sdk.Sdk; @@ -202,7 +203,7 @@ public class LayoutEditor extends AndroidXmlEditor implements IShowEditorInput, // Optional: set the default page. Eventually a default page might be // restored by selectDefaultPage() later based on the last page used by the user. // For example, to make the last page the default one (rather than the first page), - // un-comment this line: + // uncomment this line: // setActivePage(getPageCount() - 1); } @@ -604,4 +605,17 @@ public class LayoutEditor extends AndroidXmlEditor implements IShowEditorInput, return null; } + + /** + * Returns the {@link RulesEngine} associated with this editor + * + * @return the {@link RulesEngine} associated with this editor, or null + */ + public RulesEngine getRulesEngine() { + if (mGraphicalEditor instanceof GraphicalEditorPart) { + return ((GraphicalEditorPart) mGraphicalEditor).getRulesEngine(); + } + + return null; + } } diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/CanvasViewInfo.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/CanvasViewInfo.java index 2da2467..303c58d 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/CanvasViewInfo.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/CanvasViewInfo.java @@ -335,7 +335,7 @@ public class CanvasViewInfo implements IPropertySource { String fqcn = SimpleXmlTransfer.getFqcn(uiNode.getDescriptor()); String parentFqcn = null; - Rect bounds = new Rect(getAbsRect()); + Rect bounds = SwtUtils.toRect(getAbsRect()); Rect parentBounds = null; UiElementNode uiParent = uiNode.getUiParent(); @@ -343,7 +343,7 @@ public class CanvasViewInfo implements IPropertySource { parentFqcn = SimpleXmlTransfer.getFqcn(uiParent.getDescriptor()); } if (getParent() != null) { - parentBounds = new Rect(getParent().getAbsRect()); + parentBounds = SwtUtils.toRect(getParent().getAbsRect()); } SimpleElement e = new SimpleElement(fqcn, parentFqcn, bounds, parentBounds); diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/DynamicContextMenu.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/DynamicContextMenu.java index 66f2327..a514447 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/DynamicContextMenu.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/DynamicContextMenu.java @@ -179,6 +179,9 @@ import java.util.regex.Pattern; contrib = createDynamicChoices( (MenuAction.Choices)firstAction, choiceMap, actionsMap); } + } else { + // Must be a plain action + contrib = createDynamicAction(firstAction, actionsMap); } if (contrib != null) { @@ -328,7 +331,7 @@ import java.util.regex.Pattern; mEditor.wrapUndoEditXmlModel(label, new Runnable() { public void run() { - // Invoke the closures of all the actions using the same action-id + // Invoke the callbacks of all the actions using the same action-id for (MenuAction a2 : actions) { if (a2 instanceof MenuAction.Action) { IMenuCallback c = ((MenuAction.Action) a2).getCallback(); @@ -354,6 +357,66 @@ import java.util.regex.Pattern; /** * Invoked by {@link #populateDynamicContextMenu()} to create a new menu item + * for a plain action. This is nearly identical to {@link #createDynamicMenuToggle}, + * except for the {@link IAction} type and the removal of setChecked, isChecked, etc. + * + * @param firstAction The action to convert to a menu item. In the case of a + * multiple selection, this is the first of many similar actions. + * @param actionsMap Map of all contributed actions. + * @return a new {@link IContributionItem} to add to the context menu + */ + private IContributionItem createDynamicAction( + final MenuAction.Action firstAction, + final TreeMap<String, ArrayList<MenuAction>> actionsMap) { + + Action a = new Action(firstAction.getTitle(), IAction.AS_PUSH_BUTTON) { + @Override + public void run() { + final List<MenuAction> actions = actionsMap.get(firstAction.getId()); + if (actions == null || actions.isEmpty()) { + return; + } + + String label = actions.get(0).getTitle(); + if (actions.size() > 1) { + label += String.format(" (%d elements)", actions.size()); + } + + if (mEditor.isEditXmlModelPending()) { + // This should not be happening. + logError("Action '%s' failed: XML changes pending, document might be corrupt.", //$NON-NLS-1$ + label); + return; + } + + mEditor.wrapUndoEditXmlModel(label, new Runnable() { + public void run() { + // Invoke the callbacks of all the actions using the same action-id + for (MenuAction a2 : actions) { + if (a2 instanceof MenuAction.Action) { + IMenuCallback c = ((MenuAction.Action) a2).getCallback(); + if (c != null) { + try { + // Values do not apply for plain actions + c.action(a2, null /* valueId */, null /* newValue */); + } catch (Exception e) { + RulesEngine gre = mCanvas.getRulesEngine(); + gre.logError("XML edit operation failed: %s", e.toString()); + } + } + } + } + } + }); + } + }; + a.setId(firstAction.getId()); + + return new ActionContributionItem(a); + } + + /** + * Invoked by {@link #populateDynamicContextMenu()} to create a new menu item * for a {@link MenuAction.Choices}. * <p/> * Multiple-choices are represented by a sub-menu containing checked items. @@ -429,7 +492,7 @@ import java.util.regex.Pattern; } // We consider the item to be checked if all actions are all checked. - // This means a mixed item will be first toggled from off to on by all the closures. + // This means a mixed item will be first toggled from off to on by all the callbacks. final boolean isChecked = numOff == 0 && numOn > 0; boolean isMixed = numOff > 0 && numOn > 0; @@ -456,7 +519,7 @@ import java.util.regex.Pattern; mEditor.wrapUndoEditXmlModel(label, new Runnable() { public void run() { - // Invoke the closures of all the actions using the same action-id + // Invoke the callbacks of all the actions using the same action-id for (MenuAction a2 : actions) { if (a2 instanceof MenuAction.Action) { try { diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/GraphicalEditorPart.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/GraphicalEditorPart.java index 73711aa..728c089 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/GraphicalEditorPart.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/GraphicalEditorPart.java @@ -899,7 +899,7 @@ public class GraphicalEditorPart extends EditorPart } if (mRulesEngine == null) { - mRulesEngine = new RulesEngine(mEditedFile.getProject()); + mRulesEngine = new RulesEngine(this, mEditedFile.getProject()); if (mCanvasViewer != null) { mCanvasViewer.getCanvas().setRulesEngine(mRulesEngine); } @@ -949,6 +949,15 @@ public class GraphicalEditorPart extends EditorPart return mLayoutEditor; } + /** + * Returns the {@link RulesEngine} associated with this editor + * + * @return the {@link RulesEngine} associated with this editor, never null + */ + public RulesEngine getRulesEngine() { + return mRulesEngine; + } + /* package */ LayoutCanvas getCanvasControl() { if (mCanvasViewer != null) { return mCanvasViewer.getCanvas(); @@ -1174,7 +1183,7 @@ public class GraphicalEditorPart extends EditorPart Set<UiElementNode> explodeNodes = canvas.getNodesToExplode(); // Compute the layout - Rectangle rect = getBounds(); + Rectangle rect = getScreenBounds(); int width = rect.width; int height = rect.height; @@ -1355,7 +1364,7 @@ public class GraphicalEditorPart extends EditorPart // FIXME: get rid of the current LayoutScene if any. } - public Rectangle getBounds() { + public Rectangle getScreenBounds() { return mConfigComposite.getScreenBounds(); } diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/MoveGesture.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/MoveGesture.java index c11d00b..d36b96c 100644 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/MoveGesture.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/MoveGesture.java @@ -17,6 +17,7 @@ package com.android.ide.eclipse.adt.internal.editors.layout.gle2; import com.android.ide.common.api.DropFeedback; import com.android.ide.common.api.INode; +import com.android.ide.common.api.InsertType; import com.android.ide.common.api.Point; import com.android.ide.common.api.Rect; import com.android.ide.eclipse.adt.AdtPlugin; @@ -316,10 +317,19 @@ public class MoveGesture extends DropGesture { String label = computeUndoLabel(mTargetNode, elements, event.detail); mCanvas.getLayoutEditor().wrapUndoEditXmlModel(label, new Runnable() { public void run() { + InsertType insertType; + if (event.detail == DND.DROP_MOVE) { + insertType = InsertType.MOVE; + } else if (GlobalCanvasDragInfo.getInstance().getSourceCanvas() != null) { + insertType = InsertType.PASTE; + } else { + insertType = InsertType.CREATE; + } mCanvas.getRulesEngine().callOnDropped(mTargetNode, elementsFinal, mFeedback, - new Point(canvasPoint.x, canvasPoint.y)); + new Point(canvasPoint.x, canvasPoint.y), + insertType); // Clean up drag if applicable if (event.detail == DND.DROP_MOVE) { GlobalCanvasDragInfo.getInstance().removeSource(); diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/PaletteComposite.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/PaletteComposite.java index c249981..6b46688 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/PaletteComposite.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/PaletteComposite.java @@ -16,15 +16,21 @@ package com.android.ide.eclipse.adt.internal.editors.layout.gle2; +import com.android.ide.common.api.InsertType; import com.android.ide.common.api.Rect; +import com.android.ide.common.layout.BaseView; import com.android.ide.common.layoutlib.LayoutLibrary; import com.android.ide.eclipse.adt.internal.editors.descriptors.DescriptorsUtils; import com.android.ide.eclipse.adt.internal.editors.descriptors.DocumentDescriptor; import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescriptor; +import com.android.ide.eclipse.adt.internal.editors.descriptors.XmlnsAttributeDescriptor; import com.android.ide.eclipse.adt.internal.editors.layout.IGraphicalLayoutEditor; import com.android.ide.eclipse.adt.internal.editors.layout.LayoutConstants; import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditor; import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.LayoutDescriptors; +import com.android.ide.eclipse.adt.internal.editors.layout.gre.NodeFactory; +import com.android.ide.eclipse.adt.internal.editors.layout.gre.NodeProxy; +import com.android.ide.eclipse.adt.internal.editors.layout.uimodel.UiViewElementNode; import com.android.ide.eclipse.adt.internal.editors.uimodel.UiDocumentNode; import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode; import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; @@ -60,10 +66,13 @@ import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.ScrollBar; +import org.w3c.dom.Attr; import org.w3c.dom.Document; import org.w3c.dom.Element; import java.awt.image.BufferedImage; +import java.io.IOException; +import java.io.StringWriter; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.List; @@ -548,11 +557,18 @@ public class PaletteComposite extends Composite { // not to make it much larger than necessary since to crop this we rely on // actually scanning pixels. - /** Width of the rendered preview image (before it is cropped) */ - private static final int RENDER_HEIGHT = 400; + /** + * Width of the rendered preview image (before it is cropped), although the actual + * width may be smaller (since we also take the device screen's size into account) + */ + private static final int MAX_RENDER_HEIGHT = 400; - /** Height of the rendered preview image (before it is cropped) */ - private static final int RENDER_WIDTH = 500; + /** + * Height of the rendered preview image (before it is cropped), although the + * actual width may be smaller (since we also take the device screen's size into + * account) + */ + private static final int MAX_RENDER_WIDTH = 500; /** Amount of alpha to multiply into the image (divided by 256) */ private static final int IMG_ALPHA = 216; @@ -655,6 +671,8 @@ public class PaletteComposite extends Composite { Document document = null; DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); try { + factory.setNamespaceAware(true); + factory.setValidating(false); DocumentBuilder builder = factory.newDocumentBuilder(); document = builder.newDocument(); } catch (ParserConfigurationException e) { @@ -668,6 +686,13 @@ public class PaletteComposite extends Composite { String viewName = desc.getXmlLocalName(); Element element = document.createElement(viewName); + + // Set up a proper name space + Attr attr = document.createAttributeNS(XmlnsAttributeDescriptor.XMLNS_URI, + "xmlns:android"); //$NON-NLS-1$ + attr.setValue(BaseView.ANDROID_URI); + element.getAttributes().setNamedItemNS(attr); + element.setAttributeNS(SdkConstants.NS_RESOURCES, LayoutConstants.ATTR_LAYOUT_WIDTH, LayoutConstants.VALUE_WRAP_CONTENT); element.setAttributeNS(SdkConstants.NS_RESOURCES, @@ -679,15 +704,37 @@ public class PaletteComposite extends Composite { String text = DescriptorsUtils.getFreeWidgetId(uiRoot, viewName); element.setAttributeNS(SdkConstants.NS_RESOURCES, LayoutConstants.ATTR_TEXT, text); - document.insertBefore(element, null); + document.appendChild(element); // Construct UI model from XML - DocumentDescriptor documentDescriptor = - new DocumentDescriptor("layout_doc", null); //$NON-NLS-1$ - UiDocumentNode model = new UiDocumentNode(documentDescriptor); + AndroidTargetData data = layoutEditor.getTargetData(); + DocumentDescriptor documentDescriptor; + if (data == null) { + documentDescriptor = new DocumentDescriptor("temp", null /*children*/); //$NON-NLS-1$ + } else { + documentDescriptor = data.getLayoutDescriptors().getDescriptor(); + } + UiDocumentNode model = (UiDocumentNode) documentDescriptor.createUiNode(); model.setEditor(layoutEditor); + model.setUnknownDescriptorProvider(editor.getModel().getUnknownDescriptorProvider()); model.loadFromXmlNode(document); + // Call the create-hooks such that we for example insert mandatory + // children into views like the DialerFilter, apply image source attributes + // to ImageButtons, etc. + if (editor instanceof GraphicalEditorPart) { + LayoutCanvas canvas = ((GraphicalEditorPart) editor).getCanvasControl(); + NodeFactory nodeFactory = canvas.getNodeFactory(); + UiElementNode parent = model.getUiRoot(); + UiElementNode child = parent.getUiChildren().get(0); + if (child instanceof UiViewElementNode) { + UiViewElementNode childUiNode = (UiViewElementNode) child; + NodeProxy childNode = nodeFactory.create(childUiNode); + canvas.getRulesEngine().callCreateHooks(layoutEditor, + null, childNode, InsertType.CREATE); + } + } + boolean hasTransparency = false; LayoutLibrary layoutLibrary = editor.getLayoutLibrary(); if (layoutLibrary != null) { @@ -697,8 +744,23 @@ public class PaletteComposite extends Composite { } } - LayoutScene scene = editor.render(model, RENDER_WIDTH, RENDER_HEIGHT, + LayoutScene scene = null; + try { + // Use at most the size of the screen for the preview render. + // This is important since when we fill the size of certain views (like + // a SeekBar), we want it to at most be the width of the screen, and for small + // screens the RENDER_WIDTH was wider. + org.eclipse.draw2d.geometry.Rectangle screenBounds = editor.getScreenBounds(); + int renderWidth = Math.min(screenBounds.width, MAX_RENDER_WIDTH); + int renderHeight = Math.min(screenBounds.height, MAX_RENDER_HEIGHT); + + scene = editor.render(model, renderWidth, renderHeight, null /* explodeNodes */, hasTransparency); + } catch (Throwable t) { + // Previews can fail for a variety of reasons -- let's not bug + // the user with it + return null; + } if (scene != null) { if (scene.getResult() == SceneResult.SUCCESS) { @@ -761,6 +823,41 @@ public class PaletteComposite extends Composite { } /** + * Utility method to print out the contents of the given XML document. This is + * really useful when working on the preview code above. I'm including all the + * code inside a constant false, which means the compiler will omit all the code, + * but I'd like to leave it in the code base and by doing it this way rather than + * as commented out code the code won't be accidentally broken. + */ + @SuppressWarnings("all") + private static void dumpDocument(Document document) { + // Diagnostics: print out the XML that we're about to render + if (false) { // Will be omitted by the compiler + org.apache.xml.serialize.OutputFormat outputFormat = + new org.apache.xml.serialize.OutputFormat( + "XML", "ISO-8859-1", true); //$NON-NLS-1$ //$NON-NLS-2$ + outputFormat.setIndent(2); + outputFormat.setLineWidth(100); + outputFormat.setIndenting(true); + outputFormat.setOmitXMLDeclaration(true); + outputFormat.setOmitDocumentType(true); + StringWriter stringWriter = new StringWriter(); + // Using FQN here to avoid having an import above, which will result + // in a deprecation warning, and there isn't a way to annotate a single + // import element with a SuppressWarnings. + org.apache.xml.serialize.XMLSerializer serializer = + new org.apache.xml.serialize.XMLSerializer(stringWriter, outputFormat); + serializer.setNamespaces(true); + try { + serializer.serialize(document.getDocumentElement()); + System.out.println(stringWriter.toString()); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + + /** * Returns the image shown as the drag source effect. The image may be a preview * of the palette item, or just a placeholder image; {@link #isPlaceholder()} can * tell the difference. diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/SwtUtils.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/SwtUtils.java index 6c55dd3..c2c46f1 100644 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/SwtUtils.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/SwtUtils.java @@ -15,9 +15,12 @@ */ package com.android.ide.eclipse.adt.internal.editors.layout.gle2; +import com.android.ide.common.api.Rect; + import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.ImageData; import org.eclipse.swt.graphics.PaletteData; +import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.widgets.Display; import java.awt.image.BufferedImage; @@ -109,4 +112,38 @@ public class SwtUtils { return awtImage; } + + /** + * Converts the given SWT {@link Rectangle} into an ADT {@link Rect} + * + * @param swtRect the SWT {@link Rectangle} + * @return an equivalent {@link Rect} + */ + public static Rect toRect(Rectangle swtRect) { + return new Rect(swtRect.x, swtRect.y, swtRect.width, swtRect.height); + } + + /** + * Sets the values of the given ADT {@link Rect} to the values of the given SWT + * {@link Rectangle} + * + * @param target the ADT {@link Rect} to modify + * @param source the SWT {@link Rectangle} to read values from + */ + public static void set(Rect target, Rectangle source) { + target.set(source.x, source.y, source.width, source.height); + } + + /** + * Compares an ADT {@link Rect} with an SWT {@link Rectangle} and returns true if they + * are equivalent + * + * @param r1 the ADT {@link Rect} + * @param r2 the SWT {@link Rectangle} + * @return true if the two rectangles are equivalent + */ + public static boolean equals(Rect r1, Rectangle r2) { + return r1.x == r2.x && r1.y == r2.y && r1.w == r2.width && r1.h == r2.height; + + } } diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/NodeFactory.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/NodeFactory.java index 825a0e4..e608377 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/NodeFactory.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/NodeFactory.java @@ -18,6 +18,7 @@ package com.android.ide.eclipse.adt.internal.editors.layout.gre; import com.android.ide.common.api.INode; import com.android.ide.eclipse.adt.internal.editors.layout.gle2.CanvasViewInfo; +import com.android.ide.eclipse.adt.internal.editors.layout.gle2.SwtUtils; import com.android.ide.eclipse.adt.internal.editors.layout.uimodel.UiViewElementNode; import org.eclipse.swt.graphics.Rectangle; @@ -67,7 +68,7 @@ public class NodeFactory { proxy = new NodeProxy(uiNode, bounds, this); mNodeMap.put(uiNode, proxy); - } else if (bounds != null && !proxy.getBounds().equals(bounds)) { + } else if (bounds != null && !SwtUtils.equals(proxy.getBounds(), bounds)) { // Update the bounds if necessary proxy.setBounds(bounds); } diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/NodeProxy.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/NodeProxy.java index 3916eaa..59c6e15 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/NodeProxy.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/NodeProxy.java @@ -29,6 +29,7 @@ import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescripto import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditor; import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.ViewElementDescriptor; import com.android.ide.eclipse.adt.internal.editors.layout.gle2.SimpleAttribute; +import com.android.ide.eclipse.adt.internal.editors.layout.gle2.SwtUtils; import com.android.ide.eclipse.adt.internal.editors.layout.uimodel.UiViewElementNode; import com.android.ide.eclipse.adt.internal.editors.uimodel.UiAttributeNode; import com.android.ide.eclipse.adt.internal.editors.uimodel.UiDocumentNode; @@ -71,7 +72,7 @@ public class NodeProxy implements INode { if (bounds == null) { mBounds = new Rect(); } else { - mBounds = new Rect(bounds); + mBounds = SwtUtils.toRect(bounds); } } @@ -85,7 +86,7 @@ public class NodeProxy implements INode { * This is a package-protected method, only the {@link NodeFactory} uses this method. */ /*package*/ void setBounds(Rectangle bounds) { - mBounds.set(bounds); + SwtUtils.set(mBounds, bounds); } /** @@ -195,38 +196,14 @@ public class NodeProxy implements INode { } public INode appendChild(String viewFqcn) { - checkEditOK(); - - // Find the descriptor for this FQCN - ViewElementDescriptor vd = getFqcnViewDescriptor(viewFqcn); - if (vd == null) { - warnPrintf("Can't create a new %s element", viewFqcn); - return null; - } - - // Append at the end. - UiElementNode uiNew = mNode.appendNewUiChild(vd); - - // TODO we probably want to defer that to the GRE to use IViewRule#getDefaultAttributes() - DescriptorsUtils.setDefaultLayoutAttributes(uiNew, false /*updateLayout*/); - - Node xmlNode = uiNew.createXmlNode(); - - if (!(uiNew instanceof UiViewElementNode) || xmlNode == null) { - // Both things are not supposed to happen. When they do, we're in big trouble. - // We don't really know how to revert the state at this point and the UI model is - // now out of sync with the XML model. - // Panic ensues. - // The best bet is to abort now. The edit wrapper will release the edit and the - // XML/UI should get reloaded properly (with a likely invalid XML.) - warnPrintf("Failed to create a new %s element", viewFqcn); - throw new RuntimeException("XML node creation failed."); //$NON-NLS-1$ - } - - return mFactory.create((UiViewElementNode) uiNew); + return insertOrAppend(viewFqcn, -1); } public INode insertChildAt(String viewFqcn, int index) { + return insertOrAppend(viewFqcn, index); + } + + private INode insertOrAppend(String viewFqcn, int index) { checkEditOK(); // Find the descriptor for this FQCN @@ -236,13 +213,18 @@ public class NodeProxy implements INode { return null; } - // Insert at the requested position or at the end. - int n = mNode.getUiChildren().size(); - UiElementNode uiNew = null; - if (index < 0 || index >= n) { + final UiElementNode uiNew; + if (index == -1) { + // Append at the end. uiNew = mNode.appendNewUiChild(vd); } else { - uiNew = mNode.insertNewUiChild(index, vd); + // Insert at the requested position or at the end. + int n = mNode.getUiChildren().size(); + if (index < 0 || index >= n) { + uiNew = mNode.appendNewUiChild(vd); + } else { + uiNew = mNode.insertNewUiChild(index, vd); + } } // TODO we probably want to defer that to the GRE to use IViewRule#getDefaultAttributes() @@ -261,7 +243,18 @@ public class NodeProxy implements INode { throw new RuntimeException("XML node creation failed."); //$NON-NLS-1$ } - return mFactory.create((UiViewElementNode) uiNew); + UiViewElementNode uiNewView = (UiViewElementNode) uiNew; + NodeProxy newNode = mFactory.create(uiNewView); + + AndroidXmlEditor editor = mNode.getEditor(); + if (editor instanceof LayoutEditor) { + RulesEngine engine = ((LayoutEditor)editor).getRulesEngine(); + if (engine != null) { + engine.callCreateHooks(editor, this, newNode, null); + } + } + + return newNode; } public boolean setAttribute(String uri, String name, String value) { diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/RulesEngine.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/RulesEngine.java index 7856cd9..a14d812 100755 --- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/RulesEngine.java +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/RulesEngine.java @@ -22,12 +22,16 @@ import com.android.ide.common.api.IDragElement; import com.android.ide.common.api.IGraphics; import com.android.ide.common.api.INode; import com.android.ide.common.api.IValidator; +import com.android.ide.common.api.IViewMetadata; import com.android.ide.common.api.IViewRule; +import com.android.ide.common.api.InsertType; import com.android.ide.common.api.MenuAction; import com.android.ide.common.api.Point; import com.android.ide.common.layout.ViewRule; import com.android.ide.eclipse.adt.AdtPlugin; +import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor; import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescriptor; +import com.android.ide.eclipse.adt.internal.editors.layout.IGraphicalLayoutEditor; import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.ViewElementDescriptor; import com.android.ide.eclipse.adt.internal.editors.layout.gle2.SimpleElement; import com.android.ide.eclipse.adt.internal.editors.layout.uimodel.UiViewElementNode; @@ -63,6 +67,15 @@ import java.util.Map; public class RulesEngine { private final IProject mProject; private final Map<Object, IViewRule> mRulesCache = new HashMap<Object, IViewRule>(); + /** + * The type of any upcoming node manipulations performed by the {@link IViewRule}s. + * When actions are performed in the tool (like a paste action, or a drag from palette, + * or a drag move within the canvas, etc), these are different types of inserts, + * and we don't want to have the rules track them closely (and pass them back to us + * in the {@link INode#insertChildAt} methods etc), so instead we track the state + * here on behalf of the currently executing rule. + */ + private InsertType mInsertType = InsertType.CREATE; /** * Class loader (or null) used to load user/project-specific IViewRule @@ -77,14 +90,21 @@ public class RulesEngine { private boolean mUserClassLoaderInited; /** + * The editor which owns this {@link RulesEngine} + */ + private IGraphicalLayoutEditor mEditor; + + /** * Creates a new {@link RulesEngine} associated with the selected project. * <p/> * The rules engine will look in the project for a tools jar to load custom view rules. * + * @param editor the editor which owns this {@link RulesEngine} * @param project A non-null open project. */ - public RulesEngine(IProject project) { + public RulesEngine(IGraphicalLayoutEditor editor, IProject project) { mProject = project; + mEditor = editor; } /** @@ -194,6 +214,7 @@ public class RulesEngine { if (rule != null) { try { + mInsertType = InsertType.CREATE; return rule.getContextMenu(selectedNode); } catch (Exception e) { @@ -335,12 +356,14 @@ public class RulesEngine { public void callOnDropped(NodeProxy targetNode, IDragElement[] elements, DropFeedback feedback, - Point where) { + Point where, + InsertType insertType) { // try to find a rule for this element's FQCN IViewRule rule = loadRule(targetNode.getNode()); if (rule != null) { try { + mInsertType = insertType; rule.onDropped(targetNode, elements, feedback, where); } catch (Exception e) { @@ -379,6 +402,7 @@ public class RulesEngine { if (rule != null) { try { + mInsertType = InsertType.PASTE; rule.onPaste(targetNode, pastedElements); } catch (Exception e) { @@ -389,6 +413,74 @@ public class RulesEngine { } } + // ---- Creation customizations ---- + + /** + * Invokes the create hooks ({@link IViewRule#onCreate}, + * {@link IViewRule#onChildInserted} when a new child has been created/pasted/moved, and + * is inserted into a given parent. The parent may be null (for example when rendering + * top level items for preview). + * + * @param editor the XML editor to apply edits to the model for (performed by view + * rules) + * @param parentNode the parent XML node, or null if unknown + * @param childNode the XML node of the new node, never null + * @param overrideInsertType If not null, specifies an explicit insert type to use for + * edits made during the customization + */ + public void callCreateHooks( + AndroidXmlEditor editor, + NodeProxy parentNode, NodeProxy childNode, + InsertType overrideInsertType) { + IViewRule parentRule = null; + + if (parentNode != null) { + UiViewElementNode parentUiNode = parentNode.getNode(); + parentRule = loadRule(parentUiNode); + } + + if (overrideInsertType != null) { + mInsertType = overrideInsertType; + } + + UiViewElementNode newUiNode = childNode.getNode(); + IViewRule childRule = loadRule(newUiNode); + if (childRule != null || parentRule != null) { + callCreateHooks(editor, mInsertType, parentRule, parentNode, + childRule, childNode); + } + } + + private static void callCreateHooks( + final AndroidXmlEditor editor, final InsertType insertType, + final IViewRule parentRule, final INode parentNode, + final IViewRule childRule, final INode newNode) { + // Notify the parent about the new child in case it wants to customize it + // (For example, a ScrollView parent can go and set all its children's layout params to + // fill the parent.) + if (!editor.isEditXmlModelPending()) { + editor.wrapUndoEditXmlModel("Customize creation", new Runnable() { + public void run() { + callCreateHooks(editor, insertType, + parentRule, parentNode, childRule, newNode); + } + }); + return; + } + + if (parentRule != null) { + parentRule.onChildInserted(newNode, parentNode, insertType); + } + + // Look up corresponding IViewRule, and notify the rule about + // this create action in case it wants to customize the new object. + // (For example, a rule for TabHosts can go and create a default child tab + // when you create it.) + if (childRule != null) { + childRule.onCreate(newNode, parentNode, insertType); + } + } + // ---- private --- /** @@ -531,7 +623,11 @@ public class RulesEngine { // than in the same package as the widgets. String ruleClassName; ClassLoader classLoader; - if (realFqcn.startsWith("android.")) { //$NON-NLS-1$ + if (realFqcn.startsWith("android.") || //$NON-NLS-1$ + // FIXME: Remove this special case as soon as we pull + // the MapViewRule out of this code base and bundle it + // with the add ons + realFqcn.startsWith("com.google.android.maps.")) { //$NON-NLS-1$ // This doesn't handle a case where there are name conflicts // (e.g. where there are multiple different views with the same // class name and only differing in package names, but that's a @@ -697,6 +793,9 @@ public class RulesEngine { } return null; } - } + public IViewMetadata getMetadata(final String fqcn) { + return new ViewMetadata(mEditor.getLayoutEditor(), fqcn); + } + } } diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/ViewMetadata.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/ViewMetadata.java new file mode 100644 index 0000000..eeebad7 --- /dev/null +++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gre/ViewMetadata.java @@ -0,0 +1,131 @@ +/* + * 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.eclipse.adt.internal.editors.layout.gre; + +/** + * An implementation of {@link IViewMetadata} which consults the + * SDK descriptors to answer metadata questions about views. + */ +import com.android.ide.common.api.IViewMetadata; +import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescriptor; +import com.android.ide.eclipse.adt.internal.editors.layout.IGraphicalLayoutEditor; +import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditor; + +import java.util.HashMap; +import java.util.Map; + +final class ViewMetadata implements IViewMetadata { + /** The {@link ElementDescriptor} for this view, computed lazily */ + private ElementDescriptor mDescriptor; + + /** The fully qualified class name of the view whose metadata this class represents */ + private String mFqcn; + + /** The {@link IGraphicalLayoutEditor} associated with the view we're looking up */ + private LayoutEditor mEditor; + + /** + * A map from class names to {@link FillPreference} which indicates how each view + * prefers to grow when added in various layout contexts + */ + private static final Map<String,FillPreference> mFill = new HashMap<String,FillPreference>(); + static { + // Hardcoded metadata about fill preferences for various known views. We should + // work to try to get this into the platform as designtime annotations. + + mFill.put("android.widget.EditText", FillPreference.WIDTH_IN_VERTICAL); //$NON-NLS-1$ + mFill.put("android.widget.DialerFilter", FillPreference.WIDTH_IN_VERTICAL); //$NON-NLS-1$ + mFill.put("android.widget.SeekBar", FillPreference.WIDTH_IN_VERTICAL); //$NON-NLS-1$ + mFill.put("android.widget.Spinner", FillPreference.WIDTH_IN_VERTICAL); //$NON-NLS-1$ + mFill.put("android.widget.AutoComplete", FillPreference.WIDTH_IN_VERTICAL); //$NON-NLS-1$ + mFill.put("android.widget.ListView", FillPreference.WIDTH_IN_VERTICAL); //$NON-NLS-1$ + mFill.put("android.widget.GridView", FillPreference.OPPOSITE); //$NON-NLS-1$ + mFill.put("android.widget.Gallery", FillPreference.WIDTH_IN_VERTICAL); //$NON-NLS-1$ + mFill.put("android.widget.TabWidget", FillPreference.WIDTH_IN_VERTICAL); //$NON-NLS-1$ + mFill.put("android.widget.MapView", FillPreference.OPPOSITE); //$NON-NLS-1$ + mFill.put("android.widget.WebView", FillPreference.OPPOSITE); //$NON-NLS-1$ + + // In addition, all layouts are FillPreference.OPPOSITE - these are computed + // lazily rather than enumerating them here + + // For any other view, the fallback fill preference is FillPreference.NONE. + } + + public ViewMetadata(LayoutEditor editor, String fqcn) { + super(); + mFqcn = fqcn; + mEditor = editor; + } + + /** Lazily look up the descriptor for the FQCN of this metadata object */ + private boolean findDescriptor() { + if (mDescriptor == null) { + // Look up the corresponding view element node. We don't need the graphical part; + // we just need the project context. Maybe I should extract this code into + // a utility. + mDescriptor = mEditor.getFqcnViewDescriptor(mFqcn); + } + + return mDescriptor != null; + } + + public boolean isParent() { + if (findDescriptor()) { + return mDescriptor.hasChildren(); + } + + return false; + } + + public String getDisplayName() { + if (findDescriptor()) { + return mDescriptor.getUiName(); + } + + return mFqcn.substring(mFqcn.lastIndexOf('.') + 1); // This also works when there is no "." + } + + public String getTooltip() { + if (findDescriptor()) { + return mDescriptor.getTooltip(); + } + + return null; + } + + /** Returns true if this view represents a layout */ + private boolean isLayout() { + if (findDescriptor()) { + return mDescriptor.hasChildren(); + } + return false; + } + + public FillPreference getFillPreference() { + FillPreference fillPreference = mFill.get(mFqcn); + if (fillPreference == null) { + if (isLayout()) { + fillPreference = FillPreference.OPPOSITE; + } else { + fillPreference = FillPreference.NONE; + } + mFill.put(mFqcn, fillPreference); + } + + return fillPreference; + } +} diff --git a/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/api/RectTest.java b/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/api/RectTest.java index 043c9ee..36fa743 100755 --- a/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/api/RectTest.java +++ b/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/api/RectTest.java @@ -16,11 +16,6 @@ package com.android.ide.common.api; -import com.android.ide.common.api.Point; -import com.android.ide.common.api.Rect; - -import org.eclipse.swt.graphics.Rectangle; - import junit.framework.TestCase; public class RectTest extends TestCase { @@ -54,16 +49,6 @@ public class RectTest extends TestCase { assertEquals(r2, r); } - public final void testRectRectangle() { - Rectangle r = new Rectangle(3, 4, 20, 30); - Rect r2 = new Rect(r); - - assertEquals(3, r2.x); - assertEquals(4, r2.y); - assertEquals(20, r2.w); - assertEquals(30, r2.h); - } - public final void testSetIntIntIntInt() { Rect r = new Rect(1, 2, 3, 4); Rect r2 = r.set(3, 4, 20, 30); @@ -88,19 +73,6 @@ public class RectTest extends TestCase { assertEquals(30, r.h); } - public final void testSetRectangle() { - Rect r = new Rect(1, 2, 3, 4); - Rectangle r2 = new Rectangle(3, 4, 20, 30); - Rect r3 = r.set(r2); - - assertSame(r3, r); - assertNotSame(r3, r2); - assertEquals(3, r.x); - assertEquals(4, r.y); - assertEquals(20, r.w); - assertEquals(30, r.h); - } - public final void testCopy() { Rect r = new Rect(1, 2, 3, 4); Rect r2 = r.copy(); diff --git a/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/layout/AbsoluteLayoutRuleTest.java b/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/layout/AbsoluteLayoutRuleTest.java index 2f4e22f..7853410 100644 --- a/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/layout/AbsoluteLayoutRuleTest.java +++ b/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/layout/AbsoluteLayoutRuleTest.java @@ -54,10 +54,10 @@ public class AbsoluteLayoutRuleTest extends AbstractLayoutRuleTest { "useStyle(DROP_RECIPIENT), drawRect(Rect[0,0,240,480])", // Drop preview - "useStyle(DROP_PREVIEW), drawRect(Rect[30,-10,105,80])"); + "useStyle(DROP_PREVIEW), drawRect(Rect[-22,-50,105,80])"); - assertEquals("30dip", inserted.getStringAttr(BaseLayout.ANDROID_URI, "layout_x")); - assertEquals("-10dip", inserted.getStringAttr(BaseLayout.ANDROID_URI, "layout_y")); + assertEquals("-22dip", inserted.getStringAttr(BaseLayout.ANDROID_URI, "layout_x")); + assertEquals("-50dip", inserted.getStringAttr(BaseLayout.ANDROID_URI, "layout_y")); // Without drag bounds we should just draw guide lines instead inserted = dragInto(new Rect(0, 0, 0, 0), new Point(30, -10), 4, -1, diff --git a/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/eclipse/adt/internal/editors/layout/gle2/SwtUtilsTest.java b/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/eclipse/adt/internal/editors/layout/gle2/SwtUtilsTest.java index e383796..c575f46 100644 --- a/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/eclipse/adt/internal/editors/layout/gle2/SwtUtilsTest.java +++ b/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/eclipse/adt/internal/editors/layout/gle2/SwtUtilsTest.java @@ -16,8 +16,11 @@ package com.android.ide.eclipse.adt.internal.editors.layout.gle2; +import com.android.ide.common.api.Rect; + import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.ImageData; +import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; @@ -134,4 +137,25 @@ public class SwtUtilsTest extends TestCase { } } + public final void testSetRectangle() { + Rect r = new Rect(1, 2, 3, 4); + Rectangle r2 = new Rectangle(3, 4, 20, 30); + SwtUtils.set(r, r2); + + assertEquals(3, r.x); + assertEquals(4, r.y); + assertEquals(20, r.w); + assertEquals(30, r.h); + } + + public final void testRectRectangle() { + Rectangle r = new Rectangle(3, 4, 20, 30); + Rect r2 = SwtUtils.toRect(r); + + assertEquals(3, r2.x); + assertEquals(4, r2.y); + assertEquals(20, r2.w); + assertEquals(30, r2.h); + } + } |