--- /dev/null
+/*
+ * Copyright (C) 2009 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.gle2;
+
+import com.android.ide.common.api.IDragElement;
+import com.android.ide.common.api.Rect;
+
+import java.util.ArrayList;
+
+/**
+ * Represents an XML element with a name, attributes and inner elements.
+ * <p/>
+ * The semantic of the element name is to be a fully qualified class name of a View to inflate.
+ * The element name is not expected to have a name space.
+ * <p/>
+ * For a more detailed explanation of the purpose of this class,
+ * please see {@link SimpleXmlTransfer}.
+ */
+public class SimpleElement implements IDragElement {
+
+ /** Version number of the internal serialized string format. */
+ private static final String FORMAT_VERSION = "3";
+
+ private final String mFqcn;
+ private final String mParentFqcn;
+ private final Rect mBounds;
+ private final Rect mParentBounds;
+ private final ArrayList<IDragAttribute> mAttributes = new ArrayList<IDragAttribute>();
+ private final ArrayList<IDragElement> mElements = new ArrayList<IDragElement>();
+
+ private IDragAttribute[] mCachedAttributes = null;
+ private IDragElement[] mCachedElements = null;
+
+ /**
+ * Creates a new {@link SimpleElement} with the specified element name.
+ *
+ * @param fqcn A fully qualified class name of a View to inflate, e.g.
+ * "android.view.Button". Must not be null nor empty.
+ * @param parentFqcn The fully qualified class name of the parent of this element.
+ * Can be null but not empty.
+ * @param bounds The canvas bounds of the originating canvas node of the element.
+ * If null, a non-null invalid rectangle will be assigned.
+ * @param parentBounds The canvas bounds of the parent of this element. Can be null.
+ */
+ public SimpleElement(String fqcn, String parentFqcn, Rect bounds, Rect parentBounds) {
+ mFqcn = fqcn;
+ mParentFqcn = parentFqcn;
+ mBounds = bounds == null ? new Rect() : bounds.copy();
+ mParentBounds = parentBounds == null ? new Rect() : parentBounds.copy();
+ }
+
+ /**
+ * Returns the element name, which must match a fully qualified class name of
+ * a View to inflate.
+ */
+ public String getFqcn() {
+ return mFqcn;
+ }
+
+ /**
+ * Returns the bounds of the element's node, if it originated from an existing
+ * canvas. The rectangle is invalid and non-null when the element originated
+ * from the object palette (unless it successfully rendered a preview)
+ */
+ public Rect getBounds() {
+ return mBounds;
+ }
+
+ /**
+ * Returns the fully qualified class name of the parent, if the element originated
+ * from an existing canvas. Returns null if the element has no parent, such as a top
+ * level element or an element originating from the object palette.
+ */
+ public String getParentFqcn() {
+ return mParentFqcn;
+ }
+
+ /**
+ * Returns the bounds of the element's parent, absolute for the canvas, or null if there
+ * is no suitable parent. This is null when {@link #getParentFqcn()} is null.
+ */
+ public Rect getParentBounds() {
+ return mParentBounds;
+ }
+
+ public IDragAttribute[] getAttributes() {
+ if (mCachedAttributes == null) {
+ mCachedAttributes = mAttributes.toArray(new IDragAttribute[mAttributes.size()]);
+ }
+ return mCachedAttributes;
+ }
+
+ public IDragAttribute getAttribute(String uri, String localName) {
+ for (IDragAttribute attr : mAttributes) {
+ if (attr.getUri().equals(uri) && attr.getName().equals(localName)) {
+ return attr;
+ }
+ }
+
+ return null;
+ }
+
+ public IDragElement[] getInnerElements() {
+ if (mCachedElements == null) {
+ mCachedElements = mElements.toArray(new IDragElement[mElements.size()]);
+ }
+ return mCachedElements;
+ }
+
+ public void addAttribute(SimpleAttribute attr) {
+ mCachedAttributes = null;
+ mAttributes.add(attr);
+ }
+
+ public void addInnerElement(SimpleElement e) {
+ mCachedElements = null;
+ mElements.add(e);
+ }
+
+ // reader and writer methods
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append("{V=").append(FORMAT_VERSION);
+ sb.append(",N=").append(mFqcn);
+ if (mParentFqcn != null) {
+ sb.append(",P=").append(mParentFqcn);
+ }
+ if (mBounds != null && mBounds.isValid()) {
+ sb.append(String.format(",R=%d %d %d %d", mBounds.x, mBounds.y, mBounds.w, mBounds.h));
+ }
+ if (mParentBounds != null && mParentBounds.isValid()) {
+ sb.append(String.format(",Q=%d %d %d %d",
+ mParentBounds.x, mParentBounds.y, mParentBounds.w, mParentBounds.h));
+ }
+ sb.append('\n');
+ for (IDragAttribute a : mAttributes) {
+ sb.append(a.toString());
+ }
+ for (IDragElement e : mElements) {
+ sb.append(e.toString());
+ }
+ sb.append("}\n"); //$NON-NLS-1$
+ return sb.toString();
+ }
+
+ /** Parses a string containing one or more elements. */
+ static SimpleElement[] parseString(String value) {
+ ArrayList<SimpleElement> elements = new ArrayList<SimpleElement>();
+ String[] lines = value.split("\n");
+ int[] index = new int[] { 0 };
+ SimpleElement element = null;
+ while ((element = parseLines(lines, index)) != null) {
+ elements.add(element);
+ }
+ return elements.toArray(new SimpleElement[elements.size()]);
+ }
+
+ /**
+ * Parses one element from the input lines array, starting at the inOutIndex
+ * and updating the inOutIndex to match the next unread line on output.
+ */
+ private static SimpleElement parseLines(String[] lines, int[] inOutIndex) {
+ SimpleElement e = null;
+ int index = inOutIndex[0];
+ while (index < lines.length) {
+ String line = lines[index++];
+ String s = line.trim();
+ if (s.startsWith("{")) { //$NON-NLS-1$
+ if (e == null) {
+ // This is the element's header, it should have
+ // the format "key=value,key=value,..."
+ String version = null;
+ String fqcn = null;
+ String parent = null;
+ Rect bounds = null;
+ Rect pbounds = null;
+
+ for (String s2 : s.substring(1).split(",")) { //$NON-NLS-1$
+ int pos = s2.indexOf('=');
+ if (pos <= 0 || pos == s2.length() - 1) {
+ continue;
+ }
+ String key = s2.substring(0, pos).trim();
+ String value = s2.substring(pos + 1).trim();
+
+ if (key.equals("V")) { //$NON-NLS-1$
+ version = value;
+ if (!value.equals(FORMAT_VERSION)) {
+ // Wrong format version. Don't even try to process anything
+ // else and just give up everything.
+ inOutIndex[0] = index;
+ return null;
+ }
+
+ } else if (key.equals("N")) { //$NON-NLS-1$
+ fqcn = value;
+
+ } else if (key.equals("P")) { //$NON-NLS-1$
+ parent = value;
+
+ } else if (key.equals("R") || key.equals("Q")) { //$NON-NLS-1$ //$NON-NLS-2$
+ // Parse the canvas bounds
+ String[] sb = value.split(" +"); //$NON-NLS-1$
+ if (sb != null && sb.length == 4) {
+ Rect r = null;
+ try {
+ r = new Rect();
+ r.x = Integer.parseInt(sb[0]);
+ r.y = Integer.parseInt(sb[1]);
+ r.w = Integer.parseInt(sb[2]);
+ r.h = Integer.parseInt(sb[3]);
+
+ if (key.equals("R")) {
+ bounds = r;
+ } else {
+ pbounds = r;
+ }
+ } catch (NumberFormatException ignore) {
+ }
+ }
+ }
+ }
+
+ // We need at least a valid name to recreate an element
+ if (version != null && fqcn != null && fqcn.length() > 0) {
+ e = new SimpleElement(fqcn, parent, bounds, pbounds);
+ }
+ } else {
+ // This is an inner element... need to parse the { line again.
+ inOutIndex[0] = index - 1;
+ SimpleElement e2 = SimpleElement.parseLines(lines, inOutIndex);
+ if (e2 != null) {
+ e.addInnerElement(e2);
+ }
+ index = inOutIndex[0];
+ }
+
+ } else if (e != null && s.startsWith("@")) { //$NON-NLS-1$
+ SimpleAttribute a = SimpleAttribute.parseString(line);
+ if (a != null) {
+ e.addAttribute(a);
+ }
+
+ } else if (e != null && s.startsWith("}")) { //$NON-NLS-1$
+ // We're done with this element
+ inOutIndex[0] = index;
+ return e;
+ }
+ }
+ inOutIndex[0] = index;
+ return null;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof SimpleElement) {
+ SimpleElement se = (SimpleElement) obj;
+
+ // Bounds and parentFqcn must be null on both sides or equal.
+ if ((mBounds == null && se.mBounds != null) ||
+ (mBounds != null && !mBounds.equals(se.mBounds))) {
+ return false;
+ }
+ if ((mParentFqcn == null && se.mParentFqcn != null) ||
+ (mParentFqcn != null && !mParentFqcn.equals(se.mParentFqcn))) {
+ return false;
+ }
+ if ((mParentBounds == null && se.mParentBounds != null) ||
+ (mParentBounds != null && !mParentBounds.equals(se.mParentBounds))) {
+ return false;
+ }
+
+ return mFqcn.equals(se.mFqcn) &&
+ mAttributes.size() == se.mAttributes.size() &&
+ mElements.size() == se.mElements.size() &&
+ mAttributes.equals(se.mAttributes) &&
+ mElements.equals(mElements);
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ long c = mFqcn.hashCode();
+ // uses the formula defined in java.util.List.hashCode()
+ c = 31*c + mAttributes.hashCode();
+ c = 31*c + mElements.hashCode();
+ if (mParentFqcn != null) {
+ c = 31*c + mParentFqcn.hashCode();
+ }
+ if (mBounds != null && mBounds.isValid()) {
+ c = 31*c + mBounds.hashCode();
+ }
+ if (mParentBounds != null && mParentBounds.isValid()) {
+ c = 31*c + mParentBounds.hashCode();
+ }
+
+ if (c > 0x0FFFFFFFFL) {
+ // wrap any overflow
+ c = c ^ (c >> 32);
+ }
+ return (int)(c & 0x0FFFFFFFFL);
+ }
+}
+
OSDN Git Service
