/*
* Copyright (C) 2007 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;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.annotations.VisibleForTesting;
import com.android.annotations.VisibleForTesting.Visibility;
import com.android.ide.eclipse.adt.AdtConstants;
import com.android.ide.eclipse.adt.AdtPlugin;
import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor;
import com.android.ide.eclipse.adt.internal.editors.XmlEditorMultiOutline;
import com.android.ide.eclipse.adt.internal.editors.common.CommonXmlDelegate;
import com.android.ide.eclipse.adt.internal.editors.common.CommonXmlEditor;
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.IUnknownDescriptorProvider;
import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.CustomViewDescriptorService;
import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.LayoutDescriptors;
import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.ViewElementDescriptor;
import com.android.ide.eclipse.adt.internal.editors.layout.gle2.DomUtilities;
import com.android.ide.eclipse.adt.internal.editors.layout.gle2.GraphicalEditorPart;
import com.android.ide.eclipse.adt.internal.editors.layout.gle2.LayoutActionBar;
import com.android.ide.eclipse.adt.internal.editors.layout.gle2.LayoutCanvas;
import com.android.ide.eclipse.adt.internal.editors.layout.gle2.OutlinePage;
import com.android.ide.eclipse.adt.internal.editors.layout.gle2.SelectionManager;
import com.android.ide.eclipse.adt.internal.editors.layout.gre.RulesEngine;
import com.android.ide.eclipse.adt.internal.editors.layout.properties.PropertySheetPage;
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.lint.EclipseLintClient;
import com.android.ide.eclipse.adt.internal.lint.EclipseLintRunner;
import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs;
import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData;
import com.android.ide.eclipse.adt.internal.sdk.Sdk;
import com.android.resources.ResourceFolderType;
import com.android.sdklib.IAndroidTarget;
import com.android.tools.lint.client.api.IssueRegistry;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.ISelectionService;
import org.eclipse.ui.IShowEditorInput;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartSite;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.forms.editor.IFormPage;
import org.eclipse.ui.part.FileEditorInput;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
import org.eclipse.ui.views.properties.IPropertySheetPage;
import org.eclipse.wst.sse.ui.StructuredTextEditor;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import java.io.File;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* Multi-page form editor for /res/layout XML files.
*/
public class LayoutEditorDelegate extends CommonXmlDelegate
implements IShowEditorInput, CommonXmlDelegate.IActionContributorDelegate {
/** The prefix for layout folders that are not the default layout folder */
private static final String LAYOUT_FOLDER_PREFIX = "layout-"; //$NON-NLS-1$
public static class Creator implements IDelegateCreator {
@Override
@SuppressWarnings("unchecked")
public LayoutEditorDelegate createForFile(
@NonNull CommonXmlEditor delegator,
@Nullable ResourceFolderType type) {
if (ResourceFolderType.LAYOUT == type) {
return new LayoutEditorDelegate(delegator);
}
return null;
}
}
/**
* Old standalone-editor ID.
* Use {@link CommonXmlEditor#ID} instead.
*/
public static final String LEGACY_EDITOR_ID =
AdtConstants.EDITORS_NAMESPACE + ".layout.LayoutEditor"; //$NON-NLS-1$
/** Root node of the UI element hierarchy */
private UiDocumentNode mUiDocRootNode;
private GraphicalEditorPart mGraphicalEditor;
private int mGraphicalEditorIndex;
/** Implementation of the {@link IContentOutlinePage} for this editor */
private OutlinePage mLayoutOutline;
/** The XML editor outline */
private IContentOutlinePage mEditorOutline;
/** Multiplexing outline, used for multi-page editors that have their own outline */
private XmlEditorMultiOutline mMultiOutline;
/**
* Temporary flag set by the editor caret listener which is used to cause
* the next getAdapter(IContentOutlinePage.class) call to return the editor
* outline rather than the multi-outline. See the {@link #delegateGetAdapter}
* method for details.
*/
private boolean mCheckOutlineAdapter;
/** Custom implementation of {@link IPropertySheetPage} for this editor */
private IPropertySheetPage mPropertyPage;
private final HashMap<String, ElementDescriptor> mUnknownDescriptorMap =
new HashMap<String, ElementDescriptor>();
private EclipseLintClient mClient;
/**
* Flag indicating if the replacement file is due to a config change.
* If false, it means the new file is due to an "open action" from the user.
*/
private boolean mNewFileOnConfigChange = false;
/**
* Checks whether an editor part is an instance of {@link CommonXmlEditor}
* with an associated {@link LayoutEditorDelegate} delegate.
*
* @param editorPart An editor part. Can be null.
* @return The {@link LayoutEditorDelegate} delegate associated with the editor or null.
*/
public static @Nullable LayoutEditorDelegate fromEditor(@Nullable IEditorPart editorPart) {
if (editorPart instanceof CommonXmlEditor) {
CommonXmlDelegate delegate = ((CommonXmlEditor) editorPart).getDelegate();
if (delegate instanceof LayoutEditorDelegate) {
return ((LayoutEditorDelegate) delegate);
}
} else if (editorPart instanceof GraphicalEditorPart) {
GraphicalEditorPart part = (GraphicalEditorPart) editorPart;
return part.getEditorDelegate();
}
return null;
}
/**
* Creates the form editor for resources XML files.
*/
@VisibleForTesting(visibility=Visibility.PRIVATE)
protected LayoutEditorDelegate(CommonXmlEditor editor) {
super(editor, new LayoutContentAssist());
// Note that LayoutEditor has its own listeners and does not
// need to call editor.addDefaultTargetListener().
}
/**
* Returns the {@link RulesEngine} associated with this editor
*
* @return the {@link RulesEngine} associated with this editor.
*/
public RulesEngine getRulesEngine() {
return mGraphicalEditor.getRulesEngine();
}
/**
* Returns the {@link GraphicalEditorPart} associated with this editor
*
* @return the {@link GraphicalEditorPart} associated with this editor
*/
public GraphicalEditorPart getGraphicalEditor() {
return mGraphicalEditor;
}
/**
* @return The root node of the UI element hierarchy
*/
@Override
public UiDocumentNode getUiRootNode() {
return mUiDocRootNode;
}
public void setNewFileOnConfigChange(boolean state) {
mNewFileOnConfigChange = state;
}
// ---- Base Class Overrides ----
@Override
public void dispose() {
super.dispose();
if (mGraphicalEditor != null) {
mGraphicalEditor.dispose();
mGraphicalEditor = null;
}
}
/**
* Save the XML.
* <p/>
* Clients must NOT call this directly. Instead they should always
* call {@link CommonXmlEditor#doSave(IProgressMonitor)} so that th
* editor super class can commit the data properly.
* <p/>
* Here we just need to tell the graphical editor that the model has
* been saved.
*/
@Override
public void delegateDoSave(IProgressMonitor monitor) {
super.delegateDoSave(monitor);
if (mGraphicalEditor != null) {
mGraphicalEditor.doSave(monitor);
}
}
/**
* Create the various form pages.
*/
@Override
public void delegateCreateFormPages() {
try {
// get the file being edited so that it can be passed to the layout editor.
IFile editedFile = null;
IEditorInput input = getEditor().getEditorInput();
if (input instanceof FileEditorInput) {
FileEditorInput fileInput = (FileEditorInput)input;
editedFile = fileInput.getFile();
if (!editedFile.isAccessible()) {
return;
}
} else {
AdtPlugin.log(IStatus.ERROR,
"Input is not of type FileEditorInput: %1$s", //$NON-NLS-1$
input.toString());
}
// It is possible that the Layout Editor already exits if a different version
// of the same layout is being opened (either through "open" action from
// the user, or through a configuration change in the configuration selector.)
if (mGraphicalEditor == null) {
// Instantiate GLE v2
mGraphicalEditor = new GraphicalEditorPart(this);
mGraphicalEditorIndex = getEditor().addPage(mGraphicalEditor,
getEditor().getEditorInput());
getEditor().setPageText(mGraphicalEditorIndex, mGraphicalEditor.getTitle());
mGraphicalEditor.openFile(editedFile);
} else {
if (mNewFileOnConfigChange) {
mGraphicalEditor.changeFileOnNewConfig(editedFile);
mNewFileOnConfigChange = false;
} else {
mGraphicalEditor.replaceFile(editedFile);
}
}
} catch (PartInitException e) {
AdtPlugin.log(e, "Error creating nested page"); //$NON-NLS-1$
}
}
@Override
public void delegatePostCreatePages() {
// 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),
// uncomment this line:
// setActivePage(getPageCount() - 1);
}
/* (non-java doc)
* Change the tab/title name to include the name of the layout.
*/
@Override
public void delegateSetInput(IEditorInput input) {
handleNewInput(input);
}
/*
* (non-Javadoc)
* @see org.eclipse.ui.part.EditorPart#setInputWithNotify(org.eclipse.ui.IEditorInput)
*/
public void delegateSetInputWithNotify(IEditorInput input) {
handleNewInput(input);
}
/**
* Called to replace the current {@link IEditorInput} with another one.
* <p/>
* This is used when {@link LayoutEditorMatchingStrategy} returned
* <code>true</code> which means we're opening a different configuration of
* the same layout.
*/
@Override
public void showEditorInput(IEditorInput editorInput) {
if (getEditor().getEditorInput().equals(editorInput)) {
return;
}
// Save the current editor input. This must be called on the editor itself
// since it's the base editor that commits pending changes.
getEditor().doSave(new NullProgressMonitor());
// Get the current page
int currentPage = getEditor().getActivePage();
// Remove the pages, except for the graphical editor, which will be dynamically adapted
// to the new model.
// page after the graphical editor:
int count = getEditor().getPageCount();
for (int i = count - 1 ; i > mGraphicalEditorIndex ; i--) {
getEditor().removePage(i);
}
// Pages before the graphical editor
for (int i = mGraphicalEditorIndex - 1 ; i >= 0 ; i--) {
getEditor().removePage(i);
}
// Set the current input. We're in the delegate, the input must
// be set into the actual editor instance.
getEditor().setInputWithNotify(editorInput);
// Re-create or reload the pages with the default page shown as the previous active page.
getEditor().createAndroidPages();
getEditor().selectDefaultPage(Integer.toString(currentPage));
// When changing an input file of an the editor, the titlebar is not refreshed to
// show the new path/to/file being edited. So we force a refresh
getEditor().firePropertyChange(IWorkbenchPart.PROP_TITLE);
}
/** Performs a complete refresh of the XML model */
public void refreshXmlModel() {
Document xmlDoc = mUiDocRootNode.getXmlDocument();
delegateInitUiRootNode(true /*force*/);
mUiDocRootNode.loadFromXmlNode(xmlDoc);
// Update the model first, since it is used by the viewers.
// No need to call AndroidXmlEditor.xmlModelChanged(xmlDoc) since it's
// a no-op. Instead call onXmlModelChanged on the graphical editor.
if (mGraphicalEditor != null) {
mGraphicalEditor.onXmlModelChanged();
}
}
/**
* Processes the new XML Model, which XML root node is given.
*
* @param xml_doc The XML document, if available, or null if none exists.
*/
@Override
public void delegateXmlModelChanged(Document xml_doc) {
// init the ui root on demand
delegateInitUiRootNode(false /*force*/);
mUiDocRootNode.loadFromXmlNode(xml_doc);
// Update the model first, since it is used by the viewers.
// No need to call AndroidXmlEditor.xmlModelChanged(xmlDoc) since it's
// a no-op. Instead call onXmlModelChanged on the graphical editor.
if (mGraphicalEditor != null) {
mGraphicalEditor.onXmlModelChanged();
}
}
/**
* Tells the graphical editor to recompute its layout.
*/
public void recomputeLayout() {
mGraphicalEditor.recomputeLayout();
}
/**
* Does this editor participate in the "format GUI editor changes" option?
*
* @return true since this editor supports automatically formatting XML
* affected by GUI changes
*/
@Override
public boolean delegateSupportsFormatOnGuiEdit() {
return true;
}
/**
* Returns one of the issues for the given node (there could be more than one)
*
* @param node the node to look up lint issues for
* @return the marker for one of the issues found for the given node
*/
@Nullable
public IMarker getIssueForNode(@Nullable UiViewElementNode node) {
if (node == null) {
return null;
}
if (mClient != null) {
return mClient.getIssueForNode(node);
}
return null;
}
/**
* Returns a collection of nodes that have one or more lint warnings
* associated with them (retrievable via
* {@link #getIssueForNode(UiViewElementNode)})
*
* @return a collection of nodes, which should <b>not</b> be modified by the
* caller
*/
@Nullable
public Collection<Node> getLintNodes() {
if (mClient != null) {
return mClient.getIssueNodes();
}
return null;
}
@Override
public Job delegateRunLint() {
// We want to customize the {@link EclipseLintClient} created to run this
// single file lint, in particular such that we can set the mode which collects
// nodes on that lint job, such that we can quickly look up error nodes
//Job job = super.delegateRunLint();
Job job = null;
IFile file = getEditor().getInputFile();
if (file != null) {
IssueRegistry registry = EclipseLintClient.getRegistry();
List<IFile> resources = Collections.singletonList(file);
mClient = new EclipseLintClient(registry,
resources, getEditor().getStructuredDocument(), false /*fatal*/);
mClient.setCollectNodes(true);
job = EclipseLintRunner.startLint(mClient, resources, file,
false /*show*/);
}
if (job != null) {
GraphicalEditorPart graphicalEditor = getGraphicalEditor();
if (graphicalEditor != null) {
job.addJobChangeListener(new LintJobListener(graphicalEditor));
}
}
return job;
}
private class LintJobListener extends JobChangeAdapter implements Runnable {
private final GraphicalEditorPart mEditor;
private final LayoutCanvas mCanvas;
LintJobListener(GraphicalEditorPart editor) {
mEditor = editor;
mCanvas = editor.getCanvasControl();
}
@Override
public void done(IJobChangeEvent event) {
LayoutActionBar bar = mEditor.getLayoutActionBar();
if (!bar.isDisposed()) {
bar.updateErrorIndicator();
}
// Redraw
if (!mCanvas.isDisposed()) {
mCanvas.getDisplay().asyncExec(this);
}
}
@Override
public void run() {
if (!mCanvas.isDisposed()) {
mCanvas.redraw();
OutlinePage outlinePage = mCanvas.getOutlinePage();
if (outlinePage != null) {
outlinePage.refreshIcons();
}
}
}
}
/**
* Returns the custom IContentOutlinePage or IPropertySheetPage when asked for it.
*/
@Override
public Object delegateGetAdapter(Class<?> adapter) {
if (adapter == IContentOutlinePage.class) {
// Somebody has requested the outline. Eclipse can only have a single outline page,
// even for a multi-part editor:
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=1917
// To work around this we use PDE's workaround of having a single multiplexing
// outline which switches its contents between the outline pages we register
// for it, and then on page switch we notify it to update itself.
// There is one complication: The XML editor outline listens for the editor
// selection and uses this to automatically expand its tree children and show
// the current node containing the caret as selected. Unfortunately, this
// listener code contains this:
//
// /* Bug 136310, unless this page is that part's
// * IContentOutlinePage, ignore the selection change */
// if (part.getAdapter(IContentOutlinePage.class) == this) {
//
// This means that when we return the multiplexing outline from this getAdapter
// method, the outline no longer updates to track the selection.
// To work around this, we use the following hack^H^H^H^H technique:
// - Add a selection listener *before* requesting the editor outline, such
// that the selection listener is told about the impending selection event
// right before the editor outline hears about it. Set the flag
// mCheckOutlineAdapter to true. (We also only set it if the editor view
// itself is active.)
// - In this getAdapter method, when somebody requests the IContentOutline.class,
// see if mCheckOutlineAdapter to see if this request is *likely* coming
// from the XML editor outline. If so, make sure it is by actually looking
// at the signature of the caller. If it's the editor outline, then return
// the editor outline instance itself rather than the multiplexing outline.
if (mCheckOutlineAdapter && mEditorOutline != null) {
mCheckOutlineAdapter = false;
// Make *sure* this is really the editor outline calling in case
// future versions of Eclipse changes the sequencing or dispatch of selection
// events:
StackTraceElement[] frames = new Throwable().fillInStackTrace().getStackTrace();
if (frames.length > 2) {
StackTraceElement frame = frames[2];
if (frame.getClassName().equals(
"org.eclipse.wst.sse.ui.internal.contentoutline." + //$NON-NLS-1$
"ConfigurableContentOutlinePage$PostSelectionServiceListener")) { //$NON-NLS-1$
return mEditorOutline;
}
}
}
// Use a multiplexing outline: workaround for
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=1917
if (mMultiOutline == null || mMultiOutline.isDisposed()) {
mMultiOutline = new XmlEditorMultiOutline();
mMultiOutline.addSelectionChangedListener(new ISelectionChangedListener() {
@Override
public void selectionChanged(SelectionChangedEvent event) {
ISelection selection = event.getSelection();
getEditor().getSite().getSelectionProvider().setSelection(selection);
if (getEditor().getIgnoreXmlUpdate()) {
return;
}
SelectionManager manager =
mGraphicalEditor.getCanvasControl().getSelectionManager();
manager.setSelection(selection);
}
});
updateOutline(getEditor().getActivePageInstance());
}
return mMultiOutline;
}
if (IPropertySheetPage.class == adapter && mGraphicalEditor != null) {
if (mPropertyPage == null) {
mPropertyPage = new PropertySheetPage(mGraphicalEditor);
}
return mPropertyPage;
}
// return default
return super.delegateGetAdapter(adapter);
}
/**
* Update the contents of the outline to show either the XML editor outline
* or the layout editor graphical outline depending on which tab is visible
*/
private void updateOutline(IFormPage page) {
if (mMultiOutline == null) {
return;
}
IContentOutlinePage outline;
CommonXmlEditor editor = getEditor();
if (!editor.isEditorPageActive()) {
outline = getGraphicalOutline();
} else {
// Use plain XML editor outline instead
if (mEditorOutline == null) {
StructuredTextEditor structuredTextEditor = editor.getStructuredTextEditor();
if (structuredTextEditor != null) {
IWorkbenchWindow window = editor.getSite().getWorkbenchWindow();
ISelectionService service = window.getSelectionService();
service.addPostSelectionListener(new ISelectionListener() {
@Override
public void selectionChanged(IWorkbenchPart part, ISelection selection) {
if (getEditor().isEditorPageActive()) {
mCheckOutlineAdapter = true;
}
}
});
mEditorOutline = (IContentOutlinePage) structuredTextEditor.getAdapter(
IContentOutlinePage.class);
}
}
outline = mEditorOutline;
}
mMultiOutline.setPageActive(outline);
}
/**
* Returns the graphical outline associated with the layout editor
*
* @return the outline page, never null
*/
@NonNull
public OutlinePage getGraphicalOutline() {
if (mLayoutOutline == null) {
mLayoutOutline = new OutlinePage(mGraphicalEditor);
}
return mLayoutOutline;
}
@Override
public void delegatePageChange(int newPageIndex) {
if (getEditor().getCurrentPage() == getEditor().getTextPageIndex() &&
newPageIndex == mGraphicalEditorIndex) {
// You're switching from the XML editor to the WYSIWYG editor;
// look at the caret position and figure out which node it corresponds to
// (if any) and if found, select the corresponding visual element.
ISourceViewer textViewer = getEditor().getStructuredSourceViewer();
int caretOffset = textViewer.getTextWidget().getCaretOffset();
if (caretOffset >= 0) {
Node node = DomUtilities.getNode(textViewer.getDocument(), caretOffset);
if (node != null && mGraphicalEditor != null) {
mGraphicalEditor.select(node);
}
}
}
super.delegatePageChange(newPageIndex);
if (mGraphicalEditor != null) {
if (newPageIndex == mGraphicalEditorIndex) {
mGraphicalEditor.activated();
} else {
mGraphicalEditor.deactivated();
}
}
}
@Override
public int delegateGetPersistenceCategory() {
return AndroidXmlEditor.CATEGORY_LAYOUT;
}
@Override
public void delegatePostPageChange(int newPageIndex) {
super.delegatePostPageChange(newPageIndex);
if (mGraphicalEditor != null) {
LayoutCanvas canvas = mGraphicalEditor.getCanvasControl();
if (canvas != null) {
IActionBars bars = getEditor().getEditorSite().getActionBars();
if (bars != null) {
canvas.updateGlobalActions(bars);
}
}
}
IFormPage page = getEditor().getActivePageInstance();
updateOutline(page);
}
@Override
public IFormPage delegatePostSetActivePage(IFormPage superReturned, String pageIndex) {
IFormPage page = superReturned;
if (page != null) {
updateOutline(page);
}
return page;
}
// ----- IActionContributorDelegate methods ----
@Override
public void setActiveEditor(IEditorPart part, IActionBars bars) {
if (mGraphicalEditor != null) {
LayoutCanvas canvas = mGraphicalEditor.getCanvasControl();
if (canvas != null) {
canvas.updateGlobalActions(bars);
}
}
}
@Override
public void delegateActivated() {
if (mGraphicalEditor != null) {
if (getEditor().getActivePage() == mGraphicalEditorIndex) {
mGraphicalEditor.activated();
} else {
mGraphicalEditor.deactivated();
}
}
}
@Override
public void delegateDeactivated() {
if (mGraphicalEditor != null && getEditor().getActivePage() == mGraphicalEditorIndex) {
mGraphicalEditor.deactivated();
}
}
@Override
public String delegateGetPartName() {
IEditorInput editorInput = getEditor().getEditorInput();
if (!AdtPrefs.getPrefs().isSharedLayoutEditor()
&& editorInput instanceof IFileEditorInput) {
IFileEditorInput fileInput = (IFileEditorInput) editorInput;
IFile file = fileInput.getFile();
IContainer parent = file.getParent();
if (parent != null) {
String parentName = parent.getName();
if (parentName.startsWith(LAYOUT_FOLDER_PREFIX)) {
parentName = parentName.substring(LAYOUT_FOLDER_PREFIX.length());
return parentName + File.separatorChar + file.getName();
}
}
}
return super.delegateGetPartName();
}
// ---- Local Methods ----
/**
* Returns true if the Graphics editor page is visible. This <b>must</b> be
* called from the UI thread.
*/
public boolean isGraphicalEditorActive() {
IWorkbenchPartSite workbenchSite = getEditor().getSite();
IWorkbenchPage workbenchPage = workbenchSite.getPage();
// check if the editor is visible in the workbench page
if (workbenchPage.isPartVisible(getEditor())
&& workbenchPage.getActiveEditor() == getEditor()) {
// and then if the page of the editor is visible (not to be confused with
// the workbench page)
return mGraphicalEditorIndex == getEditor().getActivePage();
}
return false;
}
@Override
public void delegateInitUiRootNode(boolean force) {
// The root UI node is always created, even if there's no corresponding XML node.
if (mUiDocRootNode == null || force) {
// get the target data from the opened file (and its project)
AndroidTargetData data = getEditor().getTargetData();
Document doc = null;
if (mUiDocRootNode != null) {
doc = mUiDocRootNode.getXmlDocument();
}
DocumentDescriptor desc;
if (data == null) {
desc = new DocumentDescriptor("temp", null /*children*/);
} else {
desc = data.getLayoutDescriptors().getDescriptor();
}
// get the descriptors from the data.
mUiDocRootNode = (UiDocumentNode) desc.createUiNode();
super.setUiRootNode(mUiDocRootNode);
mUiDocRootNode.setEditor(getEditor());
mUiDocRootNode.setUnknownDescriptorProvider(new IUnknownDescriptorProvider() {
@Override
public ElementDescriptor getDescriptor(String xmlLocalName) {
ElementDescriptor unknown = mUnknownDescriptorMap.get(xmlLocalName);
if (unknown == null) {
unknown = createUnknownDescriptor(xmlLocalName);
mUnknownDescriptorMap.put(xmlLocalName, unknown);
}
return unknown;
}
});
onDescriptorsChanged(doc);
}
}
/**
* Creates a new {@link ViewElementDescriptor} for an unknown XML local name
* (i.e. one that was not mapped by the current descriptors).
* <p/>
* Since we deal with layouts, we returns either a descriptor for a custom view
* or one for the base View.
*
* @param xmlLocalName The XML local name to match.
* @return A non-null {@link ViewElementDescriptor}.
*/
private ViewElementDescriptor createUnknownDescriptor(String xmlLocalName) {
ViewElementDescriptor desc = null;
IEditorInput editorInput = getEditor().getEditorInput();
if (editorInput instanceof IFileEditorInput) {
IFileEditorInput fileInput = (IFileEditorInput)editorInput;
IProject project = fileInput.getFile().getProject();
// Check if we can find a custom view specific to this project.
// This only works if there's an actual matching custom class in the project.
if (xmlLocalName.indexOf('.') != -1) {
desc = CustomViewDescriptorService.getInstance().getDescriptor(project,
xmlLocalName);
}
if (desc == null) {
// If we didn't find a custom view, create a synthetic one using the
// the base View descriptor as a model.
// This is a layout after all, so every XML node should represent
// a view.
Sdk currentSdk = Sdk.getCurrent();
if (currentSdk != null) {
IAndroidTarget target = currentSdk.getTarget(project);
if (target != null) {
AndroidTargetData data = currentSdk.getTargetData(target);
if (data != null) {
// data can be null when the target is still loading
ViewElementDescriptor viewDesc =
data.getLayoutDescriptors().getBaseViewDescriptor();
desc = new ViewElementDescriptor(
xmlLocalName, // xml local name
xmlLocalName, // ui_name
xmlLocalName, // canonical class name
null, // tooltip
null, // sdk_url
viewDesc.getAttributes(),
viewDesc.getLayoutAttributes(),
null, // children
false /* mandatory */);
desc.setSuperClass(viewDesc);
}
}
}
}
}
if (desc == null) {
// We can only arrive here if the SDK's android target has not finished
// loading. Just create a dummy descriptor with no attributes to be able
// to continue.
desc = new ViewElementDescriptor(xmlLocalName, xmlLocalName);
}
return desc;
}
private void onDescriptorsChanged(Document document) {
mUnknownDescriptorMap.clear();
if (document != null) {
mUiDocRootNode.loadFromXmlNode(document);
} else {
mUiDocRootNode.reloadFromXmlNode(mUiDocRootNode.getXmlDocument());
}
if (mGraphicalEditor != null) {
mGraphicalEditor.onTargetChange();
mGraphicalEditor.reloadPalette();
mGraphicalEditor.getCanvasControl().syncPreviewMode();
}
}
/**
* Handles a new input, and update the part name.
* @param input the new input.
*/
private void handleNewInput(IEditorInput input) {
if (input instanceof FileEditorInput) {
FileEditorInput fileInput = (FileEditorInput) input;
IFile file = fileInput.getFile();
getEditor().setPartName(String.format("%1$s", file.getName()));
}
}
/**
* Helper method 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.
*/
public ViewElementDescriptor getFqcnViewDescriptor(String fqcn) {
ViewElementDescriptor desc = null;
AndroidTargetData data = getEditor().getTargetData();
if (data != null) {
LayoutDescriptors layoutDesc = data.getLayoutDescriptors();
if (layoutDesc != null) {
DocumentDescriptor docDesc = layoutDesc.getDescriptor();
if (docDesc != null) {
desc = internalFindFqcnViewDescriptor(fqcn, docDesc.getChildren(), null);
}
}
}
if (desc == null) {
// We failed to find a descriptor for the given FQCN.
// Let's consider custom classes and create one as needed.
desc = createUnknownDescriptor(fqcn);
}
return desc;
}
/**
* Internal helper to recursively search for a {@link ViewElementDescriptor} that matches
* the requested FQCN.
*
* @param fqcn The target View FQCN to find.
* @param descriptors A list of children descriptors to iterate through.
* @param visited A set we use to remember which descriptors have already been visited,
* necessary since the view descriptor hierarchy is cyclic.
* @return Either a matching {@link ViewElementDescriptor} or null.
*/
private ViewElementDescriptor internalFindFqcnViewDescriptor(String fqcn,
ElementDescriptor[] descriptors,
Set<ElementDescriptor> visited) {
if (visited == null) {
visited = new HashSet<ElementDescriptor>();
}
if (descriptors != null) {
for (ElementDescriptor desc : descriptors) {
if (visited.add(desc)) {
// Set.add() returns true if this a new element that was added to the set.
// That means we haven't visited this descriptor yet.
// We want a ViewElementDescriptor with a matching FQCN.
if (desc instanceof ViewElementDescriptor &&
fqcn.equals(((ViewElementDescriptor) desc).getFullClassName())) {
return (ViewElementDescriptor) desc;
}
// Visit its children
ViewElementDescriptor vd =
internalFindFqcnViewDescriptor(fqcn, desc.getChildren(), visited);
if (vd != null) {
return vd;
}
}
}
}
return null;
}
}