--- /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.gre;
+
+import com.android.ide.common.api.IAttributeInfo;
+import com.android.ide.common.api.INode;
+import com.android.ide.common.api.INodeHandler;
+import com.android.ide.common.api.Rect;
+import com.android.ide.common.resources.platform.AttributeInfo;
+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.AttributeDescriptor;
+import com.android.ide.eclipse.adt.internal.editors.descriptors.DescriptorsUtils;
+import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescriptor;
+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;
+import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode;
+
+import org.eclipse.swt.graphics.Rectangle;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ */
+public class NodeProxy implements INode {
+
+ private final UiViewElementNode mNode;
+ private final Rect mBounds;
+ private final NodeFactory mFactory;
+
+ /**
+ * Creates a new {@link INode} that wraps an {@link UiViewElementNode} that is
+ * actually valid in the current UI/XML model. The view may not be part of the canvas
+ * yet (e.g. if it has just been dynamically added and the canvas hasn't reloaded yet.)
+ * <p/>
+ * This method is package protected. To create a node, please use {@link NodeFactory} instead.
+ *
+ * @param uiNode The node to wrap.
+ * @param bounds The bounds of a the view in the canvas. Must be either: <br/>
+ * - a valid rect for a view that is actually in the canvas <br/>
+ * - <b>*or*</b> null (or an invalid rect) for a view that has just been added dynamically
+ * to the model. We never store a null bounds rectangle in the node, a null rectangle
+ * will be converted to an invalid rectangle.
+ * @param factory A {@link NodeFactory} to create unique children nodes.
+ */
+ /*package*/ NodeProxy(UiViewElementNode uiNode, Rectangle bounds, NodeFactory factory) {
+ mNode = uiNode;
+ mFactory = factory;
+ if (bounds == null) {
+ mBounds = new Rect();
+ } else {
+ mBounds = SwtUtils.toRect(bounds);
+ }
+ }
+
+ public Rect getBounds() {
+ return mBounds;
+ }
+
+
+ /**
+ * Updates the bounds of this node proxy. Bounds cannot be null, but it can be invalid.
+ * This is a package-protected method, only the {@link NodeFactory} uses this method.
+ */
+ /*package*/ void setBounds(Rectangle bounds) {
+ SwtUtils.set(mBounds, bounds);
+ }
+
+ /**
+ * Returns the {@link UiViewElementNode} corresponding to this
+ * {@link NodeProxy}.
+ *
+ * @return The {@link UiViewElementNode} corresponding to this
+ * {@link NodeProxy}
+ */
+ public UiViewElementNode getNode() {
+ return mNode;
+ }
+
+ public String getFqcn() {
+ ElementDescriptor desc = mNode.getDescriptor();
+ if (desc instanceof ViewElementDescriptor) {
+ return ((ViewElementDescriptor) desc).getFullClassName();
+ }
+ return null;
+ }
+
+
+ // ---- Hierarchy handling ----
+
+
+ public INode getRoot() {
+ if (mNode != null) {
+ UiElementNode p = mNode.getUiRoot();
+ // The node root should be a document. Instead what we really mean to
+ // return is the top level view element.
+ if (p instanceof UiDocumentNode) {
+ List<UiElementNode> children = p.getUiChildren();
+ if (children.size() > 0) {
+ p = children.get(0);
+ }
+ }
+
+ // Cope with a badly structured XML layout
+ while (p != null && !(p instanceof UiViewElementNode)) {
+ p = p.getUiNextSibling();
+ }
+
+ if (p == mNode) {
+ return this;
+ }
+ if (p instanceof UiViewElementNode) {
+ return mFactory.create((UiViewElementNode) p);
+ }
+ }
+
+ return null;
+ }
+
+ public INode getParent() {
+ if (mNode != null) {
+ UiElementNode p = mNode.getUiParent();
+ if (p instanceof UiViewElementNode) {
+ return mFactory.create((UiViewElementNode) p);
+ }
+ }
+
+ return null;
+ }
+
+ public INode[] getChildren() {
+ if (mNode != null) {
+ ArrayList<INode> nodes = new ArrayList<INode>();
+ for (UiElementNode uiChild : mNode.getUiChildren()) {
+ if (uiChild instanceof UiViewElementNode) {
+ nodes.add(mFactory.create((UiViewElementNode) uiChild));
+ }
+ }
+
+ return nodes.toArray(new INode[nodes.size()]);
+ }
+
+ return new INode[0];
+ }
+
+
+ // ---- XML Editing ---
+
+ public void editXml(String undoName, final INodeHandler c) {
+ final AndroidXmlEditor editor = mNode.getEditor();
+
+ if (editor instanceof LayoutEditor) {
+ // Create an undo edit XML wrapper, which takes a runnable
+ ((LayoutEditor) editor).wrapUndoEditXmlModel(
+ undoName,
+ new Runnable() {
+ public void run() {
+ // Here editor.isEditXmlModelPending returns true and it
+ // is safe to edit the model using any method from INode.
+
+ // Finally execute the closure that will act on the XML
+ c.handle(NodeProxy.this);
+ }
+ });
+ }
+ }
+
+ private void checkEditOK() {
+ final AndroidXmlEditor editor = mNode.getEditor();
+ if (!editor.isEditXmlModelPending()) {
+ throw new RuntimeException("Error: XML edit call without using INode.editXml!");
+ }
+ }
+
+ public INode appendChild(String viewFqcn) {
+ 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
+ ViewElementDescriptor vd = getFqcnViewDescriptor(viewFqcn);
+ if (vd == null) {
+ warnPrintf("Can't create a new %s element", viewFqcn);
+ return null;
+ }
+
+ final UiElementNode uiNew;
+ if (index == -1) {
+ // Append at the end.
+ uiNew = mNode.appendNewUiChild(vd);
+ } else {
+ // 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()
+ 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$
+ }
+
+ 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) {
+ checkEditOK();
+
+ UiAttributeNode attr = mNode.setAttributeValue(name, uri, value, true /* override */);
+ mNode.commitDirtyAttributesToXml();
+
+ return attr != null;
+ }
+
+ public String getStringAttr(String uri, String attrName) {
+ UiElementNode uiNode = mNode;
+
+ if (attrName == null) {
+ return null;
+ }
+
+ if (uiNode.getXmlNode() != null) {
+ Node xmlNode = uiNode.getXmlNode();
+ if (xmlNode != null) {
+ NamedNodeMap nodeAttributes = xmlNode.getAttributes();
+ if (nodeAttributes != null) {
+ Node attr = nodeAttributes.getNamedItemNS(uri, attrName);
+ if (attr != null) {
+ return attr.getNodeValue();
+ }
+ }
+ }
+ }
+ return null;
+ }
+
+ public IAttributeInfo getAttributeInfo(String uri, String attrName) {
+ UiElementNode uiNode = mNode;
+
+ if (attrName == null) {
+ return null;
+ }
+
+ for (AttributeDescriptor desc : uiNode.getAttributeDescriptors()) {
+ String dUri = desc.getNamespaceUri();
+ String dName = desc.getXmlLocalName();
+ if ((uri == null && dUri == null) || (uri != null && uri.equals(dUri))) {
+ if (attrName.equals(dName)) {
+ return desc.getAttributeInfo();
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public IAttributeInfo[] getDeclaredAttributes() {
+
+ AttributeDescriptor[] descs = mNode.getAttributeDescriptors();
+ int n = descs.length;
+ IAttributeInfo[] infos = new AttributeInfo[n];
+
+ for (int i = 0; i < n; i++) {
+ infos[i] = descs[i].getAttributeInfo();
+ }
+
+ return infos;
+ }
+
+ public IAttribute[] getLiveAttributes() {
+ UiElementNode uiNode = mNode;
+
+ if (uiNode.getXmlNode() != null) {
+ Node xmlNode = uiNode.getXmlNode();
+ if (xmlNode != null) {
+ NamedNodeMap nodeAttributes = xmlNode.getAttributes();
+ if (nodeAttributes != null) {
+
+ int n = nodeAttributes.getLength();
+ IAttribute[] result = new IAttribute[n];
+ for (int i = 0; i < n; i++) {
+ Node attr = nodeAttributes.item(i);
+ String uri = attr.getNamespaceURI();
+ String name = attr.getLocalName();
+ String value = attr.getNodeValue();
+
+ result[i] = new SimpleAttribute(uri, name, value);
+ }
+ return result;
+ }
+ }
+ }
+ return null;
+
+ }
+
+
+ // --- internal helpers ---
+
+ /**
+ * Helper methods that returns a {@link ViewElementDescriptor} for the requested FQCN.
+ * Will return null if we can't find that FQCN or we lack the editor/data/descriptors info
+ * (which shouldn't really happen since at this point the SDK should be fully loaded and
+ * isn't reloading, or we wouldn't be here editing XML for a layout rule.)
+ */
+ private ViewElementDescriptor getFqcnViewDescriptor(String fqcn) {
+ AndroidXmlEditor editor = mNode.getEditor();
+ if (editor instanceof LayoutEditor) {
+ return ((LayoutEditor) editor).getFqcnViewDescriptor(fqcn);
+ }
+
+ return null;
+ }
+
+ private void warnPrintf(String msg, Object...params) {
+ AdtPlugin.printToConsole(
+ mNode == null ? "" : mNode.getDescriptor().getXmlLocalName(),
+ String.format(msg, params)
+ );
+ }
+
+}
OSDN Git Service
