/*
* 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.annotations.NonNull;
import com.android.annotations.Nullable;
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.Margins;
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.LayoutEditorDelegate;
import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.ViewElementDescriptor;
import com.android.ide.eclipse.adt.internal.editors.layout.gle2.CanvasViewInfo;
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.gle2.ViewHierarchy;
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 com.android.ide.eclipse.adt.internal.project.SupportLibraryHelper;
import org.eclipse.core.resources.IProject;
import org.eclipse.swt.graphics.Rectangle;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
*/
public class NodeProxy implements INode {
private static final Margins NO_MARGINS = new Margins(0, 0, 0, 0);
private final UiViewElementNode mNode;
private final Rect mBounds;
private final NodeFactory mFactory;
/** Map from URI to Map(key=>value) (where no namespace uses "" as a key) */
private Map<String, Map<String, String>> mPendingAttributes;
/**
* 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);
}
}
@Override
public @NonNull Rect getBounds() {
return mBounds;
}
@Override
public @NonNull Margins getMargins() {
ViewHierarchy viewHierarchy = mFactory.getCanvas().getViewHierarchy();
CanvasViewInfo view = viewHierarchy.findViewInfoFor(this);
if (view != null) {
Margins margins = view.getMargins();
if (margins != null) {
return margins;
}
}
return NO_MARGINS;
}
@Override
public int getBaseline() {
ViewHierarchy viewHierarchy = mFactory.getCanvas().getViewHierarchy();
CanvasViewInfo view = viewHierarchy.findViewInfoFor(this);
if (view != null) {
return view.getBaseline();
}
return -1;
}
/**
* 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;
}
@Override
public @NonNull String getFqcn() {
if (mNode != null) {
ElementDescriptor desc = mNode.getDescriptor();
if (desc instanceof ViewElementDescriptor) {
return ((ViewElementDescriptor) desc).getFullClassName();
}
}
return "";
}
// ---- Hierarchy handling ----
@Override
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;
}
@Override
public INode getParent() {
if (mNode != null) {
UiElementNode p = mNode.getUiParent();
if (p instanceof UiViewElementNode) {
return mFactory.create((UiViewElementNode) p);
}
}
return null;
}
@Override
public @NonNull INode[] getChildren() {
if (mNode != null) {
List<UiElementNode> uiChildren = mNode.getUiChildren();
List<INode> nodes = new ArrayList<INode>(uiChildren.size());
for (UiElementNode uiChild : uiChildren) {
if (uiChild instanceof UiViewElementNode) {
nodes.add(mFactory.create((UiViewElementNode) uiChild));
}
}
return nodes.toArray(new INode[nodes.size()]);
}
return new INode[0];
}
// ---- XML Editing ---
@Override
public void editXml(@NonNull String undoName, final @NonNull INodeHandler c) {
final AndroidXmlEditor editor = mNode.getEditor();
if (editor != null) {
// Create an undo edit XML wrapper, which takes a runnable
editor.wrapUndoEditXmlModel(
undoName,
new Runnable() {
@Override
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);
applyPendingChanges();
}
});
}
}
private void checkEditOK() {
final AndroidXmlEditor editor = mNode.getEditor();
if (!editor.isEditXmlModelPending()) {
throw new RuntimeException("Error: XML edit call without using INode.editXml!");
}
}
@Override
public @NonNull INode appendChild(@NonNull String viewFqcn) {
return insertOrAppend(viewFqcn, -1);
}
@Override
public @NonNull INode insertChildAt(@NonNull String viewFqcn, int index) {
return insertOrAppend(viewFqcn, index);
}
@Override
public void removeChild(@NonNull INode node) {
checkEditOK();
((NodeProxy) node).mNode.deleteXmlNode();
}
private INode insertOrAppend(String viewFqcn, int index) {
checkEditOK();
AndroidXmlEditor editor = mNode.getEditor();
if (editor != null) {
// Possibly replace the tag with a compatibility version if the
// minimum SDK requires it
IProject project = editor.getProject();
if (project != null) {
viewFqcn = SupportLibraryHelper.getTagFor(project, viewFqcn);
}
}
// 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);
}
}
// Set default attributes -- but only for new widgets (not when moving or copying)
RulesEngine engine = null;
LayoutEditorDelegate delegate = LayoutEditorDelegate.fromEditor(editor);
if (delegate != null) {
engine = delegate.getRulesEngine();
}
if (engine == null || engine.getInsertType().isCreate()) {
// TODO: This should probably use IViewRule#getDefaultAttributes() at some point
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);
if (engine != null) {
engine.callCreateHooks(editor, this, newNode, null);
}
return newNode;
}
@Override
public boolean setAttribute(
@Nullable String uri,
@NonNull String name,
@Nullable String value) {
checkEditOK();
UiAttributeNode attr = mNode.setAttributeValue(name, uri, value, true /* override */);
if (uri == null) {
uri = ""; //$NON-NLS-1$
}
Map<String, String> map = null;
if (mPendingAttributes == null) {
// Small initial size: we don't expect many different namespaces
mPendingAttributes = new HashMap<String, Map<String, String>>(3);
} else {
map = mPendingAttributes.get(uri);
}
if (map == null) {
map = new HashMap<String, String>();
mPendingAttributes.put(uri, map);
}
map.put(name, value);
return attr != null;
}
@Override
public String getStringAttr(@Nullable String uri, @NonNull String attrName) {
UiElementNode uiNode = mNode;
if (attrName == null) {
return null;
}
if (mPendingAttributes != null) {
Map<String, String> map = mPendingAttributes.get(uri == null ? "" : uri); //$NON-NLS-1$
if (map != null) {
String value = map.get(attrName);
if (value != null) {
return value;
}
}
}
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;
}
@Override
public IAttributeInfo getAttributeInfo(@Nullable String uri, @NonNull 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;
}
@Override
public @NonNull 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;
}
@Override
public @NonNull List<String> getAttributeSources() {
ElementDescriptor descriptor = mNode.getDescriptor();
if (descriptor instanceof ViewElementDescriptor) {
return ((ViewElementDescriptor) descriptor).getAttributeSources();
} else {
return Collections.emptyList();
}
}
@Override
public @NonNull 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 new IAttribute[0];
}
@Override
public String toString() {
return "NodeProxy [node=" + mNode + ", bounds=" + mBounds + "]";
}
// --- 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) {
LayoutEditorDelegate delegate = LayoutEditorDelegate.fromEditor(mNode.getEditor());
if (delegate != null) {
return delegate.getFqcnViewDescriptor(fqcn);
}
return null;
}
private void warnPrintf(String msg, Object...params) {
AdtPlugin.printToConsole(
mNode == null ? "" : mNode.getDescriptor().getXmlLocalName(),
String.format(msg, params)
);
}
/**
* If there are any pending changes in these nodes, apply them now
*
* @return true if any modifications were made
*/
public boolean applyPendingChanges() {
boolean modified = false;
// Flush all pending attributes
if (mPendingAttributes != null) {
mNode.commitDirtyAttributesToXml();
modified = true;
mPendingAttributes = null;
}
for (INode child : getChildren()) {
modified |= ((NodeProxy) child).applyPendingChanges();
}
return modified;
}
}