| /* |
| * Copyright (C) 2012 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.common; |
| |
| import com.android.ide.common.resources.ResourceFolder; |
| import com.android.ide.eclipse.adt.AdtConstants; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.AdtUtils; |
| import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor; |
| import com.android.ide.eclipse.adt.internal.editors.animator.AnimationEditorDelegate; |
| import com.android.ide.eclipse.adt.internal.editors.color.ColorEditorDelegate; |
| import com.android.ide.eclipse.adt.internal.editors.common.CommonXmlDelegate.IDelegateCreator; |
| import com.android.ide.eclipse.adt.internal.editors.drawable.DrawableEditorDelegate; |
| import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate; |
| import com.android.ide.eclipse.adt.internal.editors.menu.MenuEditorDelegate; |
| import com.android.ide.eclipse.adt.internal.editors.otherxml.OtherXmlEditorDelegate; |
| import com.android.ide.eclipse.adt.internal.editors.otherxml.PlainXmlEditorDelegate; |
| import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode; |
| import com.android.ide.eclipse.adt.internal.editors.values.ValuesEditorDelegate; |
| import com.android.ide.eclipse.adt.internal.resources.manager.ResourceManager; |
| import com.android.resources.ResourceFolderType; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.jface.text.source.ISourceViewer; |
| import org.eclipse.jface.text.source.ISourceViewerExtension2; |
| import org.eclipse.ui.IEditorDescriptor; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorSite; |
| import org.eclipse.ui.IFileEditorInput; |
| import org.eclipse.ui.IShowEditorInput; |
| import org.eclipse.ui.IURIEditorInput; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.forms.editor.IFormPage; |
| import org.eclipse.ui.ide.IDE; |
| import org.w3c.dom.Document; |
| |
| /** |
| * Multi-page form editor for ALL /res XML files. |
| * <p/> |
| * This editor doesn't actually do anything. Instead, it defers actual implementation |
| * to {@link CommonXmlDelegate} instances. |
| */ |
| public class CommonXmlEditor extends AndroidXmlEditor implements IShowEditorInput { |
| |
| public static final String ID = AdtConstants.EDITORS_NAMESPACE + ".CommonXmlEditor"; //$NON-NLS-1$ |
| |
| /** |
| * Registered {@link CommonXmlDelegate}s. |
| * All delegates must have a {@code Creator} class which is instantiated |
| * once here statically. All the creators are invoked in the order they |
| * are defined and the first one to return a non-null delegate is used. |
| */ |
| private static final IDelegateCreator[] DELEGATES = { |
| new LayoutEditorDelegate.Creator(), |
| new ValuesEditorDelegate.Creator(), |
| new AnimationEditorDelegate.Creator(), |
| new ColorEditorDelegate.Creator(), |
| new DrawableEditorDelegate.Creator(), |
| new MenuEditorDelegate.Creator(), |
| new OtherXmlEditorDelegate.Creator(), |
| }; |
| |
| /** |
| * IDs of legacy editors replaced by the {@link CommonXmlEditor}. |
| */ |
| public static final String[] LEGACY_EDITOR_IDS = { |
| LayoutEditorDelegate.LEGACY_EDITOR_ID, |
| ValuesEditorDelegate.LEGACY_EDITOR_ID, |
| AnimationEditorDelegate.LEGACY_EDITOR_ID, |
| ColorEditorDelegate.LEGACY_EDITOR_ID, |
| DrawableEditorDelegate.LEGACY_EDITOR_ID, |
| MenuEditorDelegate.LEGACY_EDITOR_ID, |
| OtherXmlEditorDelegate.LEGACY_EDITOR_ID, |
| }; |
| |
| private CommonXmlDelegate mDelegate = null; |
| |
| /** |
| * Creates the form editor for resources XML files. |
| */ |
| public CommonXmlEditor() { |
| super(); |
| } |
| |
| @Override |
| public void init(IEditorSite site, final IEditorInput editorInput) |
| throws PartInitException { |
| if (editorInput instanceof IFileEditorInput) { |
| |
| IFileEditorInput fileInput = (IFileEditorInput) editorInput; |
| IFile file = fileInput.getFile(); |
| |
| // Adjust the default file editor ID |
| |
| IEditorDescriptor file_desc = IDE.getDefaultEditor(file); |
| String id = file_desc == null ? null : file_desc.getId(); |
| boolean mustChange = id != null && |
| !id.equals(ID) && |
| id.startsWith(AdtConstants.EDITORS_NAMESPACE); |
| if (!mustChange) { |
| // Maybe this was opened by a manual Open With with a legacy ID? |
| id = site.getId(); |
| mustChange = id != null && |
| !id.equals(ID) && |
| id.startsWith(AdtConstants.EDITORS_NAMESPACE); |
| } |
| |
| if (mustChange) { |
| // It starts by our editor namespace but it's not the right ID. |
| // This is an old Android XML ID. Change it to our new ID. |
| IDE.setDefaultEditor(file, ID); |
| AdtPlugin.log(IStatus.INFO, |
| "Changed legacy editor ID %s for %s", //$NON-NLS-1$ |
| id, |
| file.getFullPath()); |
| } |
| |
| // Now find the delegate for the file. |
| |
| ResourceFolder resFolder = ResourceManager.getInstance().getResourceFolder(file); |
| ResourceFolderType type = resFolder == null ? null : resFolder.getType(); |
| |
| if (type == null) { |
| // We lack any real resource information about that file. |
| // Let's take a guess using the actual path. |
| String folderName = AdtUtils.getParentFolderName(editorInput); |
| type = ResourceFolderType.getFolderType(folderName); |
| } |
| |
| if (type != null) { |
| for (IDelegateCreator creator : DELEGATES) { |
| mDelegate = creator.createForFile(this, type); |
| if (mDelegate != null) { |
| break; |
| } |
| } |
| } |
| |
| if (mDelegate == null) { |
| // We didn't find any editor. |
| // We'll use the PlainXmlEditorDelegate as a catch-all editor. |
| AdtPlugin.log(IStatus.INFO, |
| "No valid Android XML Editor Delegate found for file %1$s [Res %2$s, type %3$s]", |
| file.getFullPath(), |
| resFolder, |
| type); |
| mDelegate = new PlainXmlEditorDelegate(this); |
| } |
| } else if (editorInput instanceof IURIEditorInput) { |
| String folderName = AdtUtils.getParentFolderName(editorInput); |
| ResourceFolderType type = ResourceFolderType.getFolderType(folderName); |
| if (type == ResourceFolderType.LAYOUT) { |
| // The layout editor has a lot of hardcoded requirements for real IFiles |
| // and IProjects so for now just use a plain XML editor for project-less layout |
| // files |
| mDelegate = new OtherXmlEditorDelegate(this); |
| } else if (type != null) { |
| for (IDelegateCreator creator : DELEGATES) { |
| mDelegate = creator.createForFile(this, type); |
| if (mDelegate != null) { |
| break; |
| } |
| } |
| } |
| |
| if (mDelegate == null) { |
| // We didn't find any editor. |
| // We'll use the PlainXmlEditorDelegate as a catch-all editor. |
| AdtPlugin.log(IStatus.INFO, |
| "No valid Android XML Editor Delegate found for file %1$s [Res %2$s, type %3$s]", |
| ((IURIEditorInput) editorInput).getURI().toString(), |
| folderName, |
| type); |
| mDelegate = new PlainXmlEditorDelegate(this); |
| } |
| } |
| |
| if (mDelegate == null) { |
| // We can't do anything if we don't have a valid file. |
| AdtPlugin.log(IStatus.INFO, |
| "Android XML Editor cannot process non-file input %1$s", //$NON-NLS-1$ |
| (editorInput == null ? "null" : editorInput.toString())); //$NON-NLS-1$ |
| throw new PartInitException("Android XML Editor cannot process this input."); |
| } else { |
| // Invoke the editor's init after setting up the delegate. This will call setInput(). |
| super.init(site, editorInput); |
| } |
| } |
| |
| /** |
| * @return The root node of the UI element hierarchy |
| */ |
| @Override |
| public UiElementNode getUiRootNode() { |
| return mDelegate == null ? null : mDelegate.getUiRootNode(); |
| } |
| |
| public CommonXmlDelegate getDelegate() { |
| return mDelegate; |
| } |
| |
| // ---- Base Class Overrides ---- |
| |
| @Override |
| public void dispose() { |
| if (mDelegate != null) { |
| mDelegate.dispose(); |
| } |
| |
| super.dispose(); |
| } |
| |
| /** |
| * Save the XML. |
| * <p/> |
| * The actual save operation is done in the super class by committing |
| * all data to the XML model and then having the Structured XML Editor |
| * save the XML. |
| * <p/> |
| * Here we just need to tell the delegate that the model has |
| * been saved. |
| */ |
| @Override |
| public void doSave(IProgressMonitor monitor) { |
| super.doSave(monitor); |
| if (mDelegate != null) { |
| mDelegate.delegateDoSave(monitor); |
| } |
| } |
| |
| /** |
| * Returns whether the "save as" operation is supported by this editor. |
| * <p/> |
| * Save-As is a valid operation for the ManifestEditor since it acts on a |
| * single source file. |
| * |
| * @see IEditorPart |
| */ |
| @Override |
| public boolean isSaveAsAllowed() { |
| return mDelegate == null ? false : mDelegate.isSaveAsAllowed(); |
| } |
| |
| /** |
| * Create the various form pages. |
| */ |
| @Override |
| protected void createFormPages() { |
| if (mDelegate != null) { |
| mDelegate.delegateCreateFormPages(); |
| } |
| } |
| |
| @Override |
| protected void postCreatePages() { |
| super.postCreatePages(); |
| |
| if (mDelegate != null) { |
| mDelegate.delegatePostCreatePages(); |
| } |
| } |
| |
| @Override |
| protected void addPages() { |
| // Create the editor pages. |
| // This will also create the EditorPart. |
| super.addPages(); |
| |
| // When the EditorPart is being created, it configures the SourceViewer |
| // and will try to use our CommonSourceViewerConfig. Our config needs to |
| // know which ContentAssist processor to use (since we have one per resource |
| // folder type) but it doesn't have the necessary info to do so. |
| // Consequently, once the part is created, we can now unconfigure the source |
| // viewer and reconfigure it with the right settings. |
| ISourceViewer ssv = getStructuredSourceViewer(); |
| if (mDelegate != null && ssv instanceof ISourceViewerExtension2) { |
| ((ISourceViewerExtension2) ssv).unconfigure(); |
| ssv.configure(new CommonSourceViewerConfig( |
| mDelegate.getAndroidContentAssistProcessor())); |
| } |
| } |
| |
| /* (non-java doc) |
| * Change the tab/title name to include the name of the layout. |
| */ |
| @Override |
| protected void setInput(IEditorInput input) { |
| super.setInput(input); |
| assert mDelegate != null; |
| if (mDelegate != null) { |
| mDelegate.delegateSetInput(input); |
| } |
| } |
| |
| @Override |
| public void setInputWithNotify(IEditorInput input) { |
| super.setInputWithNotify(input); |
| if (mDelegate instanceof LayoutEditorDelegate) { |
| ((LayoutEditorDelegate) mDelegate).delegateSetInputWithNotify(input); |
| } |
| } |
| |
| /** |
| * 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 |
| protected void xmlModelChanged(Document xml_doc) { |
| if (mDelegate != null) { |
| mDelegate.delegateXmlModelChanged(xml_doc); |
| } |
| } |
| |
| @Override |
| protected Job runLint() { |
| if (mDelegate != null && getEditorInput() instanceof IFileEditorInput) { |
| return mDelegate.delegateRunLint(); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the custom IContentOutlinePage or IPropertySheetPage when asked for it. |
| */ |
| @Override |
| public Object getAdapter(@SuppressWarnings("rawtypes") Class adapter) { |
| if (mDelegate != null) { |
| Object value = mDelegate.delegateGetAdapter(adapter); |
| if (value != null) { |
| return value; |
| } |
| } |
| |
| // return default |
| return super.getAdapter(adapter); |
| } |
| |
| @Override |
| protected void pageChange(int newPageIndex) { |
| if (mDelegate != null) { |
| mDelegate.delegatePageChange(newPageIndex); |
| } |
| |
| super.pageChange(newPageIndex); |
| |
| if (mDelegate != null) { |
| mDelegate.delegatePostPageChange(newPageIndex); |
| } |
| } |
| |
| @Override |
| protected int getPersistenceCategory() { |
| if (mDelegate != null) { |
| return mDelegate.delegateGetPersistenceCategory(); |
| } |
| return CATEGORY_OTHER; |
| } |
| |
| @Override |
| public void initUiRootNode(boolean force) { |
| if (mDelegate != null) { |
| mDelegate.delegateInitUiRootNode(force); |
| } |
| } |
| |
| @Override |
| public IFormPage setActivePage(String pageId) { |
| IFormPage page = super.setActivePage(pageId); |
| |
| if (mDelegate != null) { |
| return mDelegate.delegatePostSetActivePage(page, pageId); |
| } |
| |
| return page; |
| } |
| |
| /* Implements showEditorInput(...) in IShowEditorInput */ |
| @Override |
| public void showEditorInput(IEditorInput editorInput) { |
| if (mDelegate instanceof LayoutEditorDelegate) { |
| ((LayoutEditorDelegate) mDelegate).showEditorInput(editorInput); |
| } |
| } |
| |
| @Override |
| public boolean supportsFormatOnGuiEdit() { |
| if (mDelegate != null) { |
| return mDelegate.delegateSupportsFormatOnGuiEdit(); |
| } |
| return super.supportsFormatOnGuiEdit(); |
| } |
| |
| @Override |
| public void activated() { |
| super.activated(); |
| if (mDelegate != null) { |
| mDelegate.delegateActivated(); |
| } |
| } |
| |
| @Override |
| public void deactivated() { |
| super.deactivated(); |
| if (mDelegate != null) { |
| mDelegate.delegateDeactivated(); |
| } |
| } |
| |
| @Override |
| public String getPartName() { |
| if (mDelegate != null) { |
| String name = mDelegate.delegateGetPartName(); |
| if (name != null) { |
| return name; |
| } |
| } |
| |
| return super.getPartName(); |
| } |
| |
| // -------------------- |
| // Base methods exposed so that XmlEditorDelegate can access them |
| |
| @Override |
| public void setPartName(String partName) { |
| super.setPartName(partName); |
| } |
| |
| @Override |
| public void setPageText(int pageIndex, String text) { |
| super.setPageText(pageIndex, text); |
| } |
| |
| @Override |
| public void firePropertyChange(int propertyId) { |
| super.firePropertyChange(propertyId); |
| } |
| |
| @Override |
| public int getPageCount() { |
| return super.getPageCount(); |
| } |
| |
| @Override |
| public int getCurrentPage() { |
| return super.getCurrentPage(); |
| } |
| } |
