| /* |
| * 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; |
| |
| import static org.eclipse.wst.sse.ui.internal.actions.StructuredTextEditorActionConstants.ACTION_NAME_FORMAT_DOCUMENT; |
| |
| import com.android.annotations.Nullable; |
| 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.uimodel.UiElementNode; |
| 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.refactorings.core.RenameResourceXmlTextAction; |
| import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk.ITargetChangeListener; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk.TargetChangeListener; |
| import com.android.sdklib.IAndroidTarget; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.QualifiedName; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.jdt.ui.actions.IJavaEditorActionDefinitionIds; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.dialogs.ErrorDialog; |
| import org.eclipse.jface.text.BadLocationException; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.text.IRegion; |
| import org.eclipse.jface.text.ITextViewer; |
| import org.eclipse.jface.text.source.ISourceViewer; |
| import org.eclipse.swt.custom.StyledText; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IEditorSite; |
| import org.eclipse.ui.IFileEditorInput; |
| import org.eclipse.ui.IURIEditorInput; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.actions.ActionFactory; |
| import org.eclipse.ui.browser.IWorkbenchBrowserSupport; |
| import org.eclipse.ui.forms.IManagedForm; |
| import org.eclipse.ui.forms.editor.FormEditor; |
| import org.eclipse.ui.forms.editor.IFormPage; |
| import org.eclipse.ui.forms.events.HyperlinkAdapter; |
| import org.eclipse.ui.forms.events.HyperlinkEvent; |
| import org.eclipse.ui.forms.events.IHyperlinkListener; |
| import org.eclipse.ui.forms.widgets.FormText; |
| import org.eclipse.ui.ide.IDEActionFactory; |
| import org.eclipse.ui.ide.IGotoMarker; |
| import org.eclipse.ui.internal.browser.WorkbenchBrowserSupport; |
| import org.eclipse.ui.part.MultiPageEditorPart; |
| import org.eclipse.ui.part.WorkbenchPart; |
| import org.eclipse.ui.views.contentoutline.IContentOutlinePage; |
| import org.eclipse.wst.sse.core.StructuredModelManager; |
| import org.eclipse.wst.sse.core.internal.provisional.IModelManager; |
| import org.eclipse.wst.sse.core.internal.provisional.IModelStateListener; |
| import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel; |
| import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion; |
| import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument; |
| import org.eclipse.wst.sse.ui.StructuredTextEditor; |
| import org.eclipse.wst.sse.ui.internal.StructuredTextViewer; |
| import org.eclipse.wst.xml.core.internal.document.NodeContainer; |
| import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Node; |
| |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.util.Collections; |
| |
| /** |
| * Multi-page form editor for Android XML files. |
| * <p/> |
| * It is designed to work with a {@link StructuredTextEditor} that will display an XML file. |
| * <br/> |
| * Derived classes must implement createFormPages to create the forms before the |
| * source editor. This can be a no-op if desired. |
| */ |
| @SuppressWarnings("restriction") // Uses XML model, which has no non-restricted replacement yet |
| public abstract class AndroidXmlEditor extends FormEditor { |
| |
| /** Icon used for the XML source page. */ |
| public static final String ICON_XML_PAGE = "editor_page_source"; //$NON-NLS-1$ |
| |
| /** Preference name for the current page of this file */ |
| private static final String PREF_CURRENT_PAGE = "_current_page"; //$NON-NLS-1$ |
| |
| /** Id string used to create the Android SDK browser */ |
| private static String BROWSER_ID = "android"; //$NON-NLS-1$ |
| |
| /** Page id of the XML source editor, used for switching tabs programmatically */ |
| public final static String TEXT_EDITOR_ID = "editor_part"; //$NON-NLS-1$ |
| |
| /** Width hint for text fields. Helps the grid layout resize properly on smaller screens */ |
| public static final int TEXT_WIDTH_HINT = 50; |
| |
| /** Page index of the text editor (always the last page) */ |
| protected int mTextPageIndex; |
| /** The text editor */ |
| private StructuredTextEditor mTextEditor; |
| /** Listener for the XML model from the StructuredEditor */ |
| private XmlModelStateListener mXmlModelStateListener; |
| /** Listener to update the root node if the target of the file is changed because of a |
| * SDK location change or a project target change */ |
| private TargetChangeListener mTargetListener = null; |
| |
| /** flag set during page creation */ |
| private boolean mIsCreatingPage = false; |
| |
| /** |
| * Flag used to ignore XML model updates. For example, the flag is set during |
| * formatting. A format operation should completely preserve the semantics of the XML |
| * so the document listeners can use this flag to skip updating the model when edits |
| * are observed during a formatting operation |
| */ |
| private boolean mIgnoreXmlUpdate; |
| |
| /** |
| * Flag indicating we're inside {@link #wrapEditXmlModel(Runnable)}. |
| * This is a counter, which allows us to nest the edit XML calls. |
| * There is no pending operation when the counter is at zero. |
| */ |
| private int mIsEditXmlModelPending; |
| |
| /** |
| * Usually null, but during an editing operation, represents the highest |
| * node which should be formatted when the editing operation is complete. |
| */ |
| private UiElementNode mFormatNode; |
| |
| /** |
| * Whether {@link #mFormatNode} should be formatted recursively, or just |
| * the node itself (its arguments) |
| */ |
| private boolean mFormatChildren; |
| |
| /** |
| * Creates a form editor. |
| * <p/> |
| * Some derived classes will want to use {@link #addDefaultTargetListener()} |
| * to setup the default listener to monitor SDK target changes. This |
| * is no longer the default. |
| */ |
| public AndroidXmlEditor() { |
| super(); |
| } |
| |
| @Override |
| public void init(IEditorSite site, IEditorInput input) throws PartInitException { |
| super.init(site, input); |
| // Trigger a check to see if the SDK needs to be reloaded (which will |
| // invoke onSdkLoaded or ITargetChangeListener asynchronously as needed). |
| AdtPlugin.getDefault().refreshSdk(); |
| } |
| |
| /** |
| * Setups a default {@link ITargetChangeListener} that will call |
| * {@link #initUiRootNode(boolean)} when the SDK or the target changes. |
| */ |
| public void addDefaultTargetListener() { |
| if (mTargetListener == null) { |
| mTargetListener = new TargetChangeListener() { |
| @Override |
| public IProject getProject() { |
| return AndroidXmlEditor.this.getProject(); |
| } |
| |
| @Override |
| public void reload() { |
| commitPages(false /* onSave */); |
| |
| // recreate the ui root node always |
| initUiRootNode(true /*force*/); |
| } |
| }; |
| AdtPlugin.getDefault().addTargetListener(mTargetListener); |
| } |
| } |
| |
| // ---- Abstract Methods ---- |
| |
| /** |
| * Returns the root node of the UI element hierarchy manipulated by the current |
| * UI node editor. |
| */ |
| abstract public UiElementNode getUiRootNode(); |
| |
| /** |
| * Creates the various form pages. |
| * <p/> |
| * Derived classes must implement this to add their own specific tabs. |
| */ |
| abstract protected void createFormPages(); |
| |
| /** |
| * Called by the base class {@link AndroidXmlEditor} once all pages (custom form pages |
| * as well as text editor page) have been created. This give a chance to deriving |
| * classes to adjust behavior once the text page has been created. |
| */ |
| protected void postCreatePages() { |
| // Nothing in the base class. |
| } |
| |
| /** |
| * Creates the initial UI Root Node, including the known mandatory elements. |
| * @param force if true, a new UiManifestNode is recreated even if it already exists. |
| */ |
| abstract protected void initUiRootNode(boolean force); |
| |
| /** |
| * Subclasses should override this method to process the new XML Model, which XML |
| * root node is given. |
| * |
| * The base implementation is empty. |
| * |
| * @param xml_doc The XML document, if available, or null if none exists. |
| */ |
| abstract protected void xmlModelChanged(Document xml_doc); |
| |
| /** |
| * Controls whether XML models are ignored or not. |
| * |
| * @param ignore when true, ignore all subsequent XML model updates, when false start |
| * processing XML model updates again |
| */ |
| public void setIgnoreXmlUpdate(boolean ignore) { |
| mIgnoreXmlUpdate = ignore; |
| } |
| |
| /** |
| * Returns whether XML model events are ignored or not. This is the case |
| * when we are deliberately modifying the document in a way which does not |
| * change the semantics (such as formatting), or when we have already |
| * directly updated the model ourselves. |
| * |
| * @return true if XML events should be ignored |
| */ |
| public boolean getIgnoreXmlUpdate() { |
| return mIgnoreXmlUpdate; |
| } |
| |
| // ---- Base Class Overrides, Interfaces Implemented ---- |
| |
| @Override |
| public Object getAdapter(@SuppressWarnings("rawtypes") Class adapter) { |
| Object result = super.getAdapter(adapter); |
| |
| if (result != null && adapter.equals(IGotoMarker.class) ) { |
| final IGotoMarker gotoMarker = (IGotoMarker) result; |
| return new IGotoMarker() { |
| @Override |
| public void gotoMarker(IMarker marker) { |
| gotoMarker.gotoMarker(marker); |
| try { |
| // Lint markers should always jump to XML text |
| if (marker.getType().equals(AdtConstants.MARKER_LINT)) { |
| IEditorPart editor = AdtUtils.getActiveEditor(); |
| if (editor instanceof AndroidXmlEditor) { |
| AndroidXmlEditor xmlEditor = (AndroidXmlEditor) editor; |
| xmlEditor.setActivePage(AndroidXmlEditor.TEXT_EDITOR_ID); |
| } |
| } |
| } catch (CoreException e) { |
| AdtPlugin.log(e, null); |
| } |
| } |
| }; |
| } |
| |
| if (result == null && adapter == IContentOutlinePage.class) { |
| return getStructuredTextEditor().getAdapter(adapter); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Creates the pages of the multi-page editor. |
| */ |
| @Override |
| protected void addPages() { |
| createAndroidPages(); |
| selectDefaultPage(null /* defaultPageId */); |
| } |
| |
| /** |
| * Creates the page for the Android Editors |
| */ |
| public void createAndroidPages() { |
| mIsCreatingPage = true; |
| createFormPages(); |
| createTextEditor(); |
| updateActionBindings(); |
| postCreatePages(); |
| mIsCreatingPage = false; |
| } |
| |
| /** |
| * Returns whether the editor is currently creating its pages. |
| */ |
| public boolean isCreatingPages() { |
| return mIsCreatingPage; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * <p/> |
| * If the page is an instance of {@link IPageImageProvider}, the image returned by |
| * by {@link IPageImageProvider#getPageImage()} will be set on the page's tab. |
| */ |
| @Override |
| public int addPage(IFormPage page) throws PartInitException { |
| int index = super.addPage(page); |
| if (page instanceof IPageImageProvider) { |
| setPageImage(index, ((IPageImageProvider) page).getPageImage()); |
| } |
| return index; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * <p/> |
| * If the editor is an instance of {@link IPageImageProvider}, the image returned by |
| * by {@link IPageImageProvider#getPageImage()} will be set on the page's tab. |
| */ |
| @Override |
| public int addPage(IEditorPart editor, IEditorInput input) throws PartInitException { |
| int index = super.addPage(editor, input); |
| if (editor instanceof IPageImageProvider) { |
| setPageImage(index, ((IPageImageProvider) editor).getPageImage()); |
| } |
| return index; |
| } |
| |
| /** |
| * Creates undo redo (etc) actions for the editor site (so that it works for any page of this |
| * multi-page editor) by re-using the actions defined by the {@link StructuredTextEditor} |
| * (aka the XML text editor.) |
| */ |
| protected void updateActionBindings() { |
| IActionBars bars = getEditorSite().getActionBars(); |
| if (bars != null) { |
| IAction action = mTextEditor.getAction(ActionFactory.UNDO.getId()); |
| bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), action); |
| |
| action = mTextEditor.getAction(ActionFactory.REDO.getId()); |
| bars.setGlobalActionHandler(ActionFactory.REDO.getId(), action); |
| |
| bars.setGlobalActionHandler(ActionFactory.DELETE.getId(), |
| mTextEditor.getAction(ActionFactory.DELETE.getId())); |
| bars.setGlobalActionHandler(ActionFactory.CUT.getId(), |
| mTextEditor.getAction(ActionFactory.CUT.getId())); |
| bars.setGlobalActionHandler(ActionFactory.COPY.getId(), |
| mTextEditor.getAction(ActionFactory.COPY.getId())); |
| bars.setGlobalActionHandler(ActionFactory.PASTE.getId(), |
| mTextEditor.getAction(ActionFactory.PASTE.getId())); |
| bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), |
| mTextEditor.getAction(ActionFactory.SELECT_ALL.getId())); |
| bars.setGlobalActionHandler(ActionFactory.FIND.getId(), |
| mTextEditor.getAction(ActionFactory.FIND.getId())); |
| bars.setGlobalActionHandler(IDEActionFactory.BOOKMARK.getId(), |
| mTextEditor.getAction(IDEActionFactory.BOOKMARK.getId())); |
| |
| bars.updateActionBars(); |
| } |
| } |
| |
| /** |
| * Clears the action bindings for the editor site. |
| */ |
| protected void clearActionBindings(boolean includeUndoRedo) { |
| IActionBars bars = getEditorSite().getActionBars(); |
| if (bars != null) { |
| // For some reason, undo/redo doesn't seem to work in the form editor. |
| // This appears to be the case for pure Eclipse form editors too, e.g. see |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=68423 |
| // However, as a workaround we can use the *text* editor's underlying undo |
| // to revert operations being done in the UI, and the form automatically updates. |
| // Therefore, to work around this, we simply leave the text editor bindings |
| // in place if {@code includeUndoRedo} is not set |
| if (includeUndoRedo) { |
| bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), null); |
| bars.setGlobalActionHandler(ActionFactory.REDO.getId(), null); |
| } |
| bars.setGlobalActionHandler(ActionFactory.DELETE.getId(), null); |
| bars.setGlobalActionHandler(ActionFactory.CUT.getId(), null); |
| bars.setGlobalActionHandler(ActionFactory.COPY.getId(), null); |
| bars.setGlobalActionHandler(ActionFactory.PASTE.getId(), null); |
| bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), null); |
| bars.setGlobalActionHandler(ActionFactory.FIND.getId(), null); |
| bars.setGlobalActionHandler(IDEActionFactory.BOOKMARK.getId(), null); |
| |
| bars.updateActionBars(); |
| } |
| } |
| |
| /** |
| * Selects the default active page. |
| * @param defaultPageId the id of the page to show. If <code>null</code> the editor attempts to |
| * find the default page in the properties of the {@link IResource} object being edited. |
| */ |
| public void selectDefaultPage(String defaultPageId) { |
| if (defaultPageId == null) { |
| IFile file = getInputFile(); |
| if (file != null) { |
| QualifiedName qname = new QualifiedName(AdtPlugin.PLUGIN_ID, |
| getClass().getSimpleName() + PREF_CURRENT_PAGE); |
| String pageId; |
| try { |
| pageId = file.getPersistentProperty(qname); |
| if (pageId != null) { |
| defaultPageId = pageId; |
| } |
| } catch (CoreException e) { |
| // ignored |
| } |
| } |
| } |
| |
| if (defaultPageId != null) { |
| try { |
| setActivePage(Integer.parseInt(defaultPageId)); |
| } catch (Exception e) { |
| // We can get NumberFormatException from parseInt but also |
| // AssertionError from setActivePage when the index is out of bounds. |
| // Generally speaking we just want to ignore any exception and fall back on the |
| // first page rather than crash the editor load. Logging the error is enough. |
| AdtPlugin.log(e, "Selecting page '%s' in AndroidXmlEditor failed", defaultPageId); |
| } |
| } else if (AdtPrefs.getPrefs().isXmlEditorPreferred(getPersistenceCategory())) { |
| setActivePage(mTextPageIndex); |
| } |
| } |
| |
| /** The layout editor */ |
| public static final int CATEGORY_LAYOUT = 1 << 0; |
| /** The manifest editor */ |
| public static final int CATEGORY_MANIFEST = 1 << 1; |
| /** Any other XML editor */ |
| public static final int CATEGORY_OTHER = 1 << 2; |
| |
| /** |
| * Returns the persistence category to use for this editor; this should be |
| * one of the {@code CATEGORY_} constants such as {@link #CATEGORY_MANIFEST}, |
| * {@link #CATEGORY_LAYOUT}, {@link #CATEGORY_OTHER}, ... |
| * <p> |
| * The persistence category is used to group editors together when it comes |
| * to certain types of persistence metadata. For example, whether this type |
| * of file was most recently edited graphically or with an XML text editor. |
| * We'll open new files in the same text or graphical mode as the last time |
| * the user edited a file of the same persistence category. |
| * <p> |
| * Before we added the persistence category, we had a single boolean flag |
| * recording whether the XML files were most recently edited graphically or |
| * not. However, this meant that users can't for example prefer to edit |
| * Manifest files graphically and string files via XML. By splitting the |
| * editors up into categories, we can track the mode at a finer granularity, |
| * and still allow similar editors such as those used for animations and |
| * colors to be treated the same way. |
| * |
| * @return the persistence category constant |
| */ |
| protected int getPersistenceCategory() { |
| return CATEGORY_OTHER; |
| } |
| |
| /** |
| * Removes all the pages from the editor. |
| */ |
| protected void removePages() { |
| int count = getPageCount(); |
| for (int i = count - 1 ; i >= 0 ; i--) { |
| removePage(i); |
| } |
| } |
| |
| /** |
| * Overrides the parent's setActivePage to be able to switch to the xml editor. |
| * |
| * If the special pageId TEXT_EDITOR_ID is given, switches to the mTextPageIndex page. |
| * This is needed because the editor doesn't actually derive from IFormPage and thus |
| * doesn't have the get-by-page-id method. In this case, the method returns null since |
| * IEditorPart does not implement IFormPage. |
| */ |
| @Override |
| public IFormPage setActivePage(String pageId) { |
| if (pageId.equals(TEXT_EDITOR_ID)) { |
| super.setActivePage(mTextPageIndex); |
| return null; |
| } else { |
| return super.setActivePage(pageId); |
| } |
| } |
| |
| /** |
| * Notifies this multi-page editor that the page with the given id has been |
| * activated. This method is called when the user selects a different tab. |
| * |
| * @see MultiPageEditorPart#pageChange(int) |
| */ |
| @Override |
| protected void pageChange(int newPageIndex) { |
| super.pageChange(newPageIndex); |
| |
| // Do not record page changes during creation of pages |
| if (mIsCreatingPage) { |
| return; |
| } |
| |
| IFile file = getInputFile(); |
| if (file != null) { |
| QualifiedName qname = new QualifiedName(AdtPlugin.PLUGIN_ID, |
| getClass().getSimpleName() + PREF_CURRENT_PAGE); |
| try { |
| file.setPersistentProperty(qname, Integer.toString(newPageIndex)); |
| } catch (CoreException e) { |
| // ignore |
| } |
| } |
| |
| boolean isTextPage = newPageIndex == mTextPageIndex; |
| AdtPrefs.getPrefs().setXmlEditorPreferred(getPersistenceCategory(), isTextPage); |
| } |
| |
| /** |
| * Returns true if the active page is the editor page |
| * |
| * @return true if the active page is the editor page |
| */ |
| public boolean isEditorPageActive() { |
| return getActivePage() == mTextPageIndex; |
| } |
| |
| /** |
| * Returns the {@link IFile} matching the editor's input or null. |
| */ |
| @Nullable |
| public IFile getInputFile() { |
| IEditorInput input = getEditorInput(); |
| if (input instanceof IFileEditorInput) { |
| return ((IFileEditorInput) input).getFile(); |
| } |
| return null; |
| } |
| |
| /** |
| * Removes attached listeners. |
| * |
| * @see WorkbenchPart |
| */ |
| @Override |
| public void dispose() { |
| IStructuredModel xml_model = getModelForRead(); |
| if (xml_model != null) { |
| try { |
| if (mXmlModelStateListener != null) { |
| xml_model.removeModelStateListener(mXmlModelStateListener); |
| } |
| |
| } finally { |
| xml_model.releaseFromRead(); |
| } |
| } |
| |
| if (mTargetListener != null) { |
| AdtPlugin.getDefault().removeTargetListener(mTargetListener); |
| mTargetListener = null; |
| } |
| |
| super.dispose(); |
| } |
| |
| /** |
| * Commit all dirty pages then saves the contents of the text editor. |
| * <p/> |
| * This works by committing all data to the XML model and then |
| * asking the Structured XML Editor to save the XML. |
| * |
| * @see IEditorPart |
| */ |
| @Override |
| public void doSave(IProgressMonitor monitor) { |
| commitPages(true /* onSave */); |
| |
| if (AdtPrefs.getPrefs().isFormatOnSave()) { |
| IAction action = mTextEditor.getAction(ACTION_NAME_FORMAT_DOCUMENT); |
| if (action != null) { |
| try { |
| mIgnoreXmlUpdate = true; |
| action.run(); |
| } finally { |
| mIgnoreXmlUpdate = false; |
| } |
| } |
| } |
| |
| // The actual "save" operation is done by the Structured XML Editor |
| getEditor(mTextPageIndex).doSave(monitor); |
| |
| // Check for errors on save, if enabled |
| if (AdtPrefs.getPrefs().isLintOnSave()) { |
| runLint(); |
| } |
| } |
| |
| /** |
| * Tells the editor to start a Lint check. |
| * It's up to the caller to check whether this should be done depending on preferences. |
| * <p/> |
| * The default implementation is to call {@link #startLintJob()}. |
| * |
| * @return The Job started by {@link EclipseLintRunner} or null if no job was started. |
| */ |
| protected Job runLint() { |
| return startLintJob(); |
| } |
| |
| /** |
| * Utility method that creates a Job to run Lint on the current document. |
| * Does not wait for the job to finish - just returns immediately. |
| * |
| * @return a new job, or null |
| * @see EclipseLintRunner#startLint(java.util.List, IResource, IDocument, |
| * boolean, boolean) |
| */ |
| @Nullable |
| public Job startLintJob() { |
| IFile file = getInputFile(); |
| if (file != null) { |
| return EclipseLintRunner.startLint(Collections.singletonList(file), file, |
| getStructuredDocument(), false /*fatalOnly*/, false /*show*/); |
| } |
| |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * Saves the contents of this editor to another object. |
| * <p> |
| * Subclasses must override this method to implement the open-save-close lifecycle |
| * for an editor. For greater details, see <code>IEditorPart</code> |
| * </p> |
| * |
| * @see IEditorPart |
| */ |
| @Override |
| public void doSaveAs() { |
| commitPages(true /* onSave */); |
| |
| IEditorPart editor = getEditor(mTextPageIndex); |
| editor.doSaveAs(); |
| setPageText(mTextPageIndex, editor.getTitle()); |
| setInput(editor.getEditorInput()); |
| } |
| |
| /** |
| * Commits all dirty pages in the editor. This method should |
| * be called as a first step of a 'save' operation. |
| * <p/> |
| * This is the same implementation as in {@link FormEditor} |
| * except it fixes two bugs: a cast to IFormPage is done |
| * from page.get(i) <em>before</em> being tested with instanceof. |
| * Another bug is that the last page might be a null pointer. |
| * <p/> |
| * The incorrect casting makes the original implementation crash due |
| * to our {@link StructuredTextEditor} not being an {@link IFormPage} |
| * so we have to override and duplicate to fix it. |
| * |
| * @param onSave <code>true</code> if commit is performed as part |
| * of the 'save' operation, <code>false</code> otherwise. |
| * @since 3.3 |
| */ |
| @Override |
| public void commitPages(boolean onSave) { |
| if (pages != null) { |
| for (int i = 0; i < pages.size(); i++) { |
| Object page = pages.get(i); |
| if (page != null && page instanceof IFormPage) { |
| IFormPage form_page = (IFormPage) page; |
| IManagedForm managed_form = form_page.getManagedForm(); |
| if (managed_form != null && managed_form.isDirty()) { |
| managed_form.commit(onSave); |
| } |
| } |
| } |
| } |
| } |
| |
| /* (non-Javadoc) |
| * Returns whether the "save as" operation is supported by this editor. |
| * <p> |
| * Subclasses must override this method to implement the open-save-close lifecycle |
| * for an editor. For greater details, see <code>IEditorPart</code> |
| * </p> |
| * |
| * @see IEditorPart |
| */ |
| @Override |
| public boolean isSaveAsAllowed() { |
| return false; |
| } |
| |
| /** |
| * Returns the page index of the text editor (always the last page) |
| |
| * @return the page index of the text editor (always the last page) |
| */ |
| public int getTextPageIndex() { |
| return mTextPageIndex; |
| } |
| |
| // ---- Local methods ---- |
| |
| |
| /** |
| * Helper method that creates a new hyper-link Listener. |
| * Used by derived classes which need active links in {@link FormText}. |
| * <p/> |
| * This link listener handles two kinds of URLs: |
| * <ul> |
| * <li> Links starting with "http" are simply sent to a local browser. |
| * <li> Links starting with "file:/" are simply sent to a local browser. |
| * <li> Links starting with "page:" are expected to be an editor page id to switch to. |
| * <li> Other links are ignored. |
| * </ul> |
| * |
| * @return A new hyper-link listener for FormText to use. |
| */ |
| public final IHyperlinkListener createHyperlinkListener() { |
| return new HyperlinkAdapter() { |
| /** |
| * Switch to the page corresponding to the link that has just been clicked. |
| * For this purpose, the HREF of the <a> tags above is the page ID to switch to. |
| */ |
| @Override |
| public void linkActivated(HyperlinkEvent e) { |
| super.linkActivated(e); |
| String link = e.data.toString(); |
| if (link.startsWith("http") || //$NON-NLS-1$ |
| link.startsWith("file:/")) { //$NON-NLS-1$ |
| openLinkInBrowser(link); |
| } else if (link.startsWith("page:")) { //$NON-NLS-1$ |
| // Switch to an internal page |
| setActivePage(link.substring(5 /* strlen("page:") */)); |
| } |
| } |
| }; |
| } |
| |
| /** |
| * Open the http link into a browser |
| * |
| * @param link The URL to open in a browser |
| */ |
| private void openLinkInBrowser(String link) { |
| try { |
| IWorkbenchBrowserSupport wbs = WorkbenchBrowserSupport.getInstance(); |
| wbs.createBrowser(BROWSER_ID).openURL(new URL(link)); |
| } catch (PartInitException e1) { |
| // pass |
| } catch (MalformedURLException e1) { |
| // pass |
| } |
| } |
| |
| /** |
| * Creates the XML source editor. |
| * <p/> |
| * Memorizes the index page of the source editor (it's always the last page, but the number |
| * of pages before can change.) |
| * <br/> |
| * Retrieves the underlying XML model from the StructuredEditor and attaches a listener to it. |
| * Finally triggers modelChanged() on the model listener -- derived classes can use this |
| * to initialize the model the first time. |
| * <p/> |
| * Called only once <em>after</em> createFormPages. |
| */ |
| private void createTextEditor() { |
| try { |
| mTextEditor = new StructuredTextEditor() { |
| @Override |
| protected void createActions() { |
| super.createActions(); |
| |
| Action action = new RenameResourceXmlTextAction(mTextEditor); |
| action.setActionDefinitionId(IJavaEditorActionDefinitionIds.RENAME_ELEMENT); |
| setAction(IJavaEditorActionDefinitionIds.RENAME_ELEMENT, action); |
| } |
| }; |
| int index = addPage(mTextEditor, getEditorInput()); |
| mTextPageIndex = index; |
| setPageText(index, mTextEditor.getTitle()); |
| setPageImage(index, |
| IconFactory.getInstance().getIcon(ICON_XML_PAGE)); |
| |
| if (!(mTextEditor.getTextViewer().getDocument() instanceof IStructuredDocument)) { |
| Status status = new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| "Error opening the Android XML editor. Is the document an XML file?"); |
| throw new RuntimeException("Android XML Editor Error", new CoreException(status)); |
| } |
| |
| IStructuredModel xml_model = getModelForRead(); |
| if (xml_model != null) { |
| try { |
| mXmlModelStateListener = new XmlModelStateListener(); |
| xml_model.addModelStateListener(mXmlModelStateListener); |
| mXmlModelStateListener.modelChanged(xml_model); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "Error while loading editor"); //$NON-NLS-1$ |
| } finally { |
| xml_model.releaseFromRead(); |
| } |
| } |
| } catch (PartInitException e) { |
| ErrorDialog.openError(getSite().getShell(), |
| "Android XML Editor Error", null, e.getStatus()); |
| } |
| } |
| |
| /** |
| * Returns the ISourceViewer associated with the Structured Text editor. |
| */ |
| public final ISourceViewer getStructuredSourceViewer() { |
| if (mTextEditor != null) { |
| // We can't access mDelegate.getSourceViewer() because it is protected, |
| // however getTextViewer simply returns the SourceViewer casted, so we |
| // can use it instead. |
| return mTextEditor.getTextViewer(); |
| } |
| return null; |
| } |
| |
| /** |
| * Return the {@link StructuredTextEditor} associated with this XML editor |
| * |
| * @return the associated {@link StructuredTextEditor} |
| */ |
| public StructuredTextEditor getStructuredTextEditor() { |
| return mTextEditor; |
| } |
| |
| /** |
| * Returns the {@link IStructuredDocument} used by the StructuredTextEditor (aka Source |
| * Editor) or null if not available. |
| */ |
| public IStructuredDocument getStructuredDocument() { |
| if (mTextEditor != null && mTextEditor.getTextViewer() != null) { |
| return (IStructuredDocument) mTextEditor.getTextViewer().getDocument(); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns a version of the model that has been shared for read. |
| * <p/> |
| * Callers <em>must</em> call model.releaseFromRead() when done, typically |
| * in a try..finally clause. |
| * |
| * Portability note: this uses getModelManager which is part of wst.sse.core; however |
| * the interface returned is part of wst.sse.core.internal.provisional so we can |
| * expect it to change in a distant future if they start cleaning their codebase, |
| * however unlikely that is. |
| * |
| * @return The model for the XML document or null if cannot be obtained from the editor |
| */ |
| public IStructuredModel getModelForRead() { |
| IStructuredDocument document = getStructuredDocument(); |
| if (document != null) { |
| IModelManager mm = StructuredModelManager.getModelManager(); |
| if (mm != null) { |
| // TODO simplify this by not using the internal IStructuredDocument. |
| // Instead we can now use mm.getModelForRead(getFile()). |
| // However we must first check that SSE for Eclipse 3.3 or 3.4 has this |
| // method. IIRC 3.3 didn't have it. |
| |
| return mm.getModelForRead(document); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns a version of the model that has been shared for edit. |
| * <p/> |
| * Callers <em>must</em> call model.releaseFromEdit() when done, typically |
| * in a try..finally clause. |
| * <p/> |
| * Because of this, it is mandatory to use the wrapper |
| * {@link #wrapEditXmlModel(Runnable)} which executes a runnable into a |
| * properly configured model and then performs whatever cleanup is necessary. |
| * |
| * @return The model for the XML document or null if cannot be obtained from the editor |
| */ |
| private IStructuredModel getModelForEdit() { |
| IStructuredDocument document = getStructuredDocument(); |
| if (document != null) { |
| IModelManager mm = StructuredModelManager.getModelManager(); |
| if (mm != null) { |
| // TODO simplify this by not using the internal IStructuredDocument. |
| // Instead we can now use mm.getModelForRead(getFile()). |
| // However we must first check that SSE for Eclipse 3.3 or 3.4 has this |
| // method. IIRC 3.3 didn't have it. |
| |
| return mm.getModelForEdit(document); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Helper class to perform edits on the XML model whilst making sure the |
| * model has been prepared to be changed. |
| * <p/> |
| * It first gets a model for edition using {@link #getModelForEdit()}, |
| * then calls {@link IStructuredModel#aboutToChangeModel()}, |
| * then performs the requested action |
| * and finally calls {@link IStructuredModel#changedModel()} |
| * and {@link IStructuredModel#releaseFromEdit()}. |
| * <p/> |
| * The method is synchronous. As soon as the {@link IStructuredModel#changedModel()} method |
| * is called, XML model listeners will be triggered. |
| * <p/> |
| * Calls can be nested: only the first outer call will actually start and close the edit |
| * session. |
| * <p/> |
| * This method is <em>not synchronized</em> and is not thread safe. |
| * Callers must be using it from the the main UI thread. |
| * |
| * @param editAction Something that will change the XML. |
| */ |
| public final void wrapEditXmlModel(Runnable editAction) { |
| wrapEditXmlModel(editAction, null); |
| } |
| |
| /** |
| * Perform any editor-specific hooks after applying an edit. When edits are |
| * nested, the hooks will only run after the final top level edit has been |
| * performed. |
| * <p> |
| * Note that the edit hooks are performed outside of the edit lock so |
| * the hooks should not perform edits on the model without acquiring |
| * a lock first. |
| */ |
| public void runEditHooks() { |
| if (!mIgnoreXmlUpdate) { |
| // Check for errors, if enabled |
| if (AdtPrefs.getPrefs().isLintOnSave()) { |
| runLint(); |
| } |
| } |
| } |
| |
| /** |
| * Executor which performs the given action under an edit lock (and optionally as a |
| * single undo event). |
| * |
| * @param editAction the action to be executed |
| * @param undoLabel if non null, the edit action will be run as a single undo event |
| * and the label used as the name of the undoable action |
| */ |
| private final void wrapEditXmlModel(final Runnable editAction, final String undoLabel) { |
| Display display = mTextEditor.getSite().getShell().getDisplay(); |
| if (display.getThread() != Thread.currentThread()) { |
| display.syncExec(new Runnable() { |
| @Override |
| public void run() { |
| if (!mTextEditor.getTextViewer().getControl().isDisposed()) { |
| wrapEditXmlModel(editAction, undoLabel); |
| } |
| } |
| }); |
| return; |
| } |
| |
| IStructuredModel model = null; |
| int undoReverseCount = 0; |
| try { |
| |
| if (mIsEditXmlModelPending == 0) { |
| try { |
| model = getModelForEdit(); |
| if (undoLabel != null) { |
| // Run this action as an undoable unit. |
| // We have to do it more than once, because in some scenarios |
| // Eclipse WTP decides to cancel the current undo command on its |
| // own -- see http://code.google.com/p/android/issues/detail?id=15901 |
| // for one such call chain. By nesting these calls several times |
| // we've incrementing the command count such that a couple of |
| // cancellations are ignored. Interfering with this mechanism may |
| // sound dangerous, but it appears that this undo-termination is |
| // done for UI reasons to anticipate what the user wants, and we know |
| // that in *our* scenarios we want the entire unit run as a single |
| // unit. Here's what the documentation for |
| // IStructuredTextUndoManager#forceEndOfPendingCommand says |
| // "Normally, the undo manager can figure out the best |
| // times when to end a pending command and begin a new |
| // one ... to the structure of a structured |
| // document. There are times, however, when clients may |
| // wish to override those algorithms and end one earlier |
| // than normal. The one known case is for multi-page |
| // editors. If a user is on one page, and type '123' as |
| // attribute value, then click around to other parts of |
| // page, or different pages, then return to '123|' and |
| // type 456, then "undo" they typically expect the undo |
| // to just undo what they just typed, the 456, not the |
| // whole attribute value." |
| for (int i = 0; i < 4; i++) { |
| model.beginRecording(this, undoLabel); |
| undoReverseCount++; |
| } |
| } |
| model.aboutToChangeModel(); |
| } catch (Throwable t) { |
| // This is never supposed to happen unless we suddenly don't have a model. |
| // If it does, we don't want to even try to modify anyway. |
| AdtPlugin.log(t, "XML Editor failed to get model to edit"); //$NON-NLS-1$ |
| return; |
| } |
| } |
| mIsEditXmlModelPending++; |
| editAction.run(); |
| } finally { |
| mIsEditXmlModelPending--; |
| if (model != null) { |
| try { |
| boolean oldIgnore = mIgnoreXmlUpdate; |
| try { |
| mIgnoreXmlUpdate = true; |
| |
| if (AdtPrefs.getPrefs().getFormatGuiXml() && mFormatNode != null) { |
| if (mFormatNode == getUiRootNode()) { |
| reformatDocument(); |
| } else { |
| Node node = mFormatNode.getXmlNode(); |
| if (node instanceof IndexedRegion) { |
| IndexedRegion region = (IndexedRegion) node; |
| int begin = region.getStartOffset(); |
| int end = region.getEndOffset(); |
| |
| if (!mFormatChildren) { |
| // This will format just the attribute list |
| end = begin + 1; |
| } |
| |
| if (mFormatChildren |
| && node == node.getOwnerDocument().getDocumentElement()) { |
| reformatDocument(); |
| } else { |
| reformatRegion(begin, end); |
| } |
| } |
| } |
| mFormatNode = null; |
| mFormatChildren = false; |
| } |
| |
| // Notify the model we're done modifying it. This must *always* be executed. |
| model.changedModel(); |
| |
| // Clean up the undo unit. This is done more than once as explained |
| // above for beginRecording. |
| for (int i = 0; i < undoReverseCount; i++) { |
| model.endRecording(this); |
| } |
| } finally { |
| mIgnoreXmlUpdate = oldIgnore; |
| } |
| } catch (Exception e) { |
| AdtPlugin.log(e, "Failed to clean up undo unit"); |
| } |
| model.releaseFromEdit(); |
| |
| if (mIsEditXmlModelPending < 0) { |
| AdtPlugin.log(IStatus.ERROR, |
| "wrapEditXmlModel finished with invalid nested counter==%1$d", //$NON-NLS-1$ |
| mIsEditXmlModelPending); |
| mIsEditXmlModelPending = 0; |
| } |
| |
| runEditHooks(); |
| |
| // Notify listeners |
| IStructuredModel readModel = getModelForRead(); |
| if (readModel != null) { |
| try { |
| mXmlModelStateListener.modelChanged(readModel); |
| } catch (Exception e) { |
| AdtPlugin.log(e, "Error while notifying changes"); //$NON-NLS-1$ |
| } finally { |
| readModel.releaseFromRead(); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Does this editor participate in the "format GUI editor changes" option? |
| * |
| * @return true if this editor supports automatically formatting XML |
| * affected by GUI changes |
| */ |
| public boolean supportsFormatOnGuiEdit() { |
| return false; |
| } |
| |
| /** |
| * Mark the given node as needing to be formatted when the current edits are |
| * done, provided the user has turned that option on (see |
| * {@link AdtPrefs#getFormatGuiXml()}). |
| * |
| * @param node the node to be scheduled for formatting |
| * @param attributesOnly if true, only update the attributes list of the |
| * node, otherwise update the node recursively (e.g. all children |
| * too) |
| */ |
| public void scheduleNodeReformat(UiElementNode node, boolean attributesOnly) { |
| if (!supportsFormatOnGuiEdit()) { |
| return; |
| } |
| |
| if (node == mFormatNode) { |
| if (!attributesOnly) { |
| mFormatChildren = true; |
| } |
| } else if (mFormatNode == null) { |
| mFormatNode = node; |
| mFormatChildren = !attributesOnly; |
| } else { |
| if (mFormatNode.isAncestorOf(node)) { |
| mFormatChildren = true; |
| } else if (node.isAncestorOf(mFormatNode)) { |
| mFormatNode = node; |
| mFormatChildren = true; |
| } else { |
| // Two independent nodes; format their closest common ancestor. |
| // Later we could consider having a small number of independent nodes |
| // and formatting those, and only switching to formatting the common ancestor |
| // when the number of individual nodes gets large. |
| mFormatChildren = true; |
| mFormatNode = UiElementNode.getCommonAncestor(mFormatNode, node); |
| } |
| } |
| } |
| |
| /** |
| * Creates an "undo recording" session by calling the undoableAction runnable |
| * under an undo session. |
| * <p/> |
| * This also automatically starts an edit XML session, as if |
| * {@link #wrapEditXmlModel(Runnable)} had been called. |
| * <p> |
| * You can nest several calls to {@link #wrapUndoEditXmlModel(String, Runnable)}, only one |
| * recording session will be created. |
| * |
| * @param label The label for the undo operation. Can be null. Ideally we should really try |
| * to put something meaningful if possible. |
| * @param undoableAction the action to be run as a single undoable unit |
| */ |
| public void wrapUndoEditXmlModel(String label, Runnable undoableAction) { |
| assert label != null : "All undoable actions should have a label"; |
| wrapEditXmlModel(undoableAction, label == null ? "" : label); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Returns true when the runnable of {@link #wrapEditXmlModel(Runnable)} is currently |
| * being executed. This means it is safe to actually edit the XML model. |
| * |
| * @return true if the XML model is already locked for edits |
| */ |
| public boolean isEditXmlModelPending() { |
| return mIsEditXmlModelPending > 0; |
| } |
| |
| /** |
| * Returns the XML {@link Document} or null if we can't get it |
| */ |
| public final Document getXmlDocument(IStructuredModel model) { |
| if (model == null) { |
| AdtPlugin.log(IStatus.WARNING, "Android Editor: No XML model for root node."); //$NON-NLS-1$ |
| return null; |
| } |
| |
| if (model instanceof IDOMModel) { |
| IDOMModel dom_model = (IDOMModel) model; |
| return dom_model.getDocument(); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the {@link IProject} for the edited file. |
| */ |
| @Nullable |
| public IProject getProject() { |
| IFile file = getInputFile(); |
| if (file != null) { |
| return file.getProject(); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns the {@link AndroidTargetData} for the edited file. |
| */ |
| @Nullable |
| public AndroidTargetData getTargetData() { |
| IProject project = getProject(); |
| if (project != null) { |
| Sdk currentSdk = Sdk.getCurrent(); |
| if (currentSdk != null) { |
| IAndroidTarget target = currentSdk.getTarget(project); |
| |
| if (target != null) { |
| return currentSdk.getTargetData(target); |
| } |
| } |
| } |
| |
| IEditorInput input = getEditorInput(); |
| if (input instanceof IURIEditorInput) { |
| IURIEditorInput urlInput = (IURIEditorInput) input; |
| Sdk currentSdk = Sdk.getCurrent(); |
| if (currentSdk != null) { |
| try { |
| String path = AdtUtils.getFile(urlInput.getURI().toURL()).getPath(); |
| IAndroidTarget[] targets = currentSdk.getTargets(); |
| for (IAndroidTarget target : targets) { |
| if (path.startsWith(target.getLocation())) { |
| return currentSdk.getTargetData(target); |
| } |
| } |
| } catch (MalformedURLException e) { |
| // File might be in some other weird random location we can't |
| // handle: Just ignore these |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Shows the editor range corresponding to the given XML node. This will |
| * front the editor and select the text range. |
| * |
| * @param xmlNode The DOM node to be shown. The DOM node should be an XML |
| * node from the existing XML model used by the structured XML |
| * editor; it will not do attribute matching to find a |
| * "corresponding" element in the document from some foreign DOM |
| * tree. |
| * @return True if the node was shown. |
| */ |
| public boolean show(Node xmlNode) { |
| if (xmlNode instanceof IndexedRegion) { |
| IndexedRegion region = (IndexedRegion)xmlNode; |
| |
| IEditorPart textPage = getEditor(mTextPageIndex); |
| if (textPage instanceof StructuredTextEditor) { |
| StructuredTextEditor editor = (StructuredTextEditor) textPage; |
| |
| setActivePage(AndroidXmlEditor.TEXT_EDITOR_ID); |
| |
| // Note - we cannot use region.getLength() because that seems to |
| // always return 0. |
| int regionLength = region.getEndOffset() - region.getStartOffset(); |
| editor.selectAndReveal(region.getStartOffset(), regionLength); |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Selects and reveals the given range in the text editor |
| * |
| * @param start the beginning offset |
| * @param length the length of the region to show |
| * @param frontTab if true, front the tab, otherwise just make the selection but don't |
| * change the active tab |
| */ |
| public void show(int start, int length, boolean frontTab) { |
| IEditorPart textPage = getEditor(mTextPageIndex); |
| if (textPage instanceof StructuredTextEditor) { |
| StructuredTextEditor editor = (StructuredTextEditor) textPage; |
| if (frontTab) { |
| setActivePage(AndroidXmlEditor.TEXT_EDITOR_ID); |
| } |
| editor.selectAndReveal(start, length); |
| if (frontTab) { |
| editor.setFocus(); |
| } |
| } |
| } |
| |
| /** |
| * Returns true if this editor has more than one page (usually a graphical view and an |
| * editor) |
| * |
| * @return true if this editor has multiple pages |
| */ |
| public boolean hasMultiplePages() { |
| return getPageCount() > 1; |
| } |
| |
| /** |
| * Get the XML text directly from the editor. |
| * |
| * @param xmlNode The node whose XML text we want to obtain. |
| * @return The XML representation of the {@link Node}, or null if there was an error. |
| */ |
| public String getXmlText(Node xmlNode) { |
| String data = null; |
| IStructuredModel model = getModelForRead(); |
| try { |
| IStructuredDocument document = getStructuredDocument(); |
| if (xmlNode instanceof NodeContainer) { |
| // The easy way to get the source of an SSE XML node. |
| data = ((NodeContainer) xmlNode).getSource(); |
| } else if (xmlNode instanceof IndexedRegion && document != null) { |
| // Try harder. |
| IndexedRegion region = (IndexedRegion) xmlNode; |
| int start = region.getStartOffset(); |
| int end = region.getEndOffset(); |
| |
| if (end > start) { |
| data = document.get(start, end - start); |
| } |
| } |
| } catch (BadLocationException e) { |
| // the region offset was invalid. ignore. |
| } finally { |
| model.releaseFromRead(); |
| } |
| return data; |
| } |
| |
| /** |
| * Formats the text around the given caret range, using the current Eclipse |
| * XML formatter settings. |
| * |
| * @param begin The starting offset of the range to be reformatted. |
| * @param end The ending offset of the range to be reformatted. |
| */ |
| public void reformatRegion(int begin, int end) { |
| ISourceViewer textViewer = getStructuredSourceViewer(); |
| |
| // Clamp text range to valid offsets. |
| IDocument document = textViewer.getDocument(); |
| int documentLength = document.getLength(); |
| end = Math.min(end, documentLength); |
| begin = Math.min(begin, end); |
| |
| if (!AdtPrefs.getPrefs().getUseCustomXmlFormatter()) { |
| // Workarounds which only apply to the builtin Eclipse formatter: |
| // |
| // It turns out the XML formatter does *NOT* format things correctly if you |
| // select just a region of text. You *MUST* also include the leading whitespace |
| // on the line, or it will dedent all the content to column 0. Therefore, |
| // we must figure out the offset of the start of the line that contains the |
| // beginning of the tag. |
| try { |
| IRegion lineInformation = document.getLineInformationOfOffset(begin); |
| if (lineInformation != null) { |
| int lineBegin = lineInformation.getOffset(); |
| if (lineBegin != begin) { |
| begin = lineBegin; |
| } else if (begin > 0) { |
| // Trick #2: It turns out that, if an XML element starts in column 0, |
| // then the XML formatter will NOT indent it (even if its parent is |
| // indented). If you on the other hand include the end of the previous |
| // line (the newline), THEN the formatter also correctly inserts the |
| // element. Therefore, we adjust the beginning range to include the |
| // previous line (if we are not already in column 0 of the first line) |
| // in the case where the element starts the line. |
| begin--; |
| } |
| } |
| } catch (BadLocationException e) { |
| // This cannot happen because we already clamped the offsets |
| AdtPlugin.log(e, e.toString()); |
| } |
| } |
| |
| if (textViewer instanceof StructuredTextViewer) { |
| StructuredTextViewer structuredTextViewer = (StructuredTextViewer) textViewer; |
| int operation = ISourceViewer.FORMAT; |
| boolean canFormat = structuredTextViewer.canDoOperation(operation); |
| if (canFormat) { |
| StyledText textWidget = textViewer.getTextWidget(); |
| textWidget.setSelection(begin, end); |
| |
| boolean oldIgnore = mIgnoreXmlUpdate; |
| try { |
| // Formatting does not affect the XML model so ignore notifications |
| // about model edits from this |
| mIgnoreXmlUpdate = true; |
| structuredTextViewer.doOperation(operation); |
| } finally { |
| mIgnoreXmlUpdate = oldIgnore; |
| } |
| |
| textWidget.setSelection(0, 0); |
| } |
| } |
| } |
| |
| /** |
| * Invokes content assist in this editor at the given offset |
| * |
| * @param offset the offset to invoke content assist at, or -1 to leave |
| * caret alone |
| */ |
| public void invokeContentAssist(int offset) { |
| ISourceViewer textViewer = getStructuredSourceViewer(); |
| if (textViewer instanceof StructuredTextViewer) { |
| StructuredTextViewer structuredTextViewer = (StructuredTextViewer) textViewer; |
| int operation = ISourceViewer.CONTENTASSIST_PROPOSALS; |
| boolean allowed = structuredTextViewer.canDoOperation(operation); |
| if (allowed) { |
| if (offset != -1) { |
| StyledText textWidget = textViewer.getTextWidget(); |
| // Clamp text range to valid offsets. |
| IDocument document = textViewer.getDocument(); |
| int documentLength = document.getLength(); |
| offset = Math.max(0, Math.min(offset, documentLength)); |
| textWidget.setSelection(offset, offset); |
| } |
| structuredTextViewer.doOperation(operation); |
| } |
| } |
| } |
| |
| /** |
| * Formats the XML region corresponding to the given node. |
| * |
| * @param node The node to be formatted. |
| */ |
| public void reformatNode(Node node) { |
| if (mIsCreatingPage) { |
| return; |
| } |
| |
| if (node instanceof IndexedRegion) { |
| IndexedRegion region = (IndexedRegion) node; |
| int begin = region.getStartOffset(); |
| int end = region.getEndOffset(); |
| reformatRegion(begin, end); |
| } |
| } |
| |
| /** |
| * Formats the XML document according to the user's XML formatting settings. |
| */ |
| public void reformatDocument() { |
| ISourceViewer textViewer = getStructuredSourceViewer(); |
| if (textViewer instanceof StructuredTextViewer) { |
| StructuredTextViewer structuredTextViewer = (StructuredTextViewer) textViewer; |
| int operation = StructuredTextViewer.FORMAT_DOCUMENT; |
| boolean canFormat = structuredTextViewer.canDoOperation(operation); |
| if (canFormat) { |
| boolean oldIgnore = mIgnoreXmlUpdate; |
| try { |
| // Formatting does not affect the XML model so ignore notifications |
| // about model edits from this |
| mIgnoreXmlUpdate = true; |
| structuredTextViewer.doOperation(operation); |
| } finally { |
| mIgnoreXmlUpdate = oldIgnore; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns the indentation String of the given node. |
| * |
| * @param xmlNode The node whose indentation we want. |
| * @return The indent-string of the given node, or "" if the indentation for some reason could |
| * not be computed. |
| */ |
| public String getIndent(Node xmlNode) { |
| return getIndent(getStructuredDocument(), xmlNode); |
| } |
| |
| /** |
| * Returns the indentation String of the given node. |
| * |
| * @param document The Eclipse document containing the XML |
| * @param xmlNode The node whose indentation we want. |
| * @return The indent-string of the given node, or "" if the indentation for some reason could |
| * not be computed. |
| */ |
| public static String getIndent(IDocument document, Node xmlNode) { |
| if (xmlNode instanceof IndexedRegion) { |
| IndexedRegion region = (IndexedRegion)xmlNode; |
| int startOffset = region.getStartOffset(); |
| return getIndentAtOffset(document, startOffset); |
| } |
| |
| return ""; //$NON-NLS-1$ |
| } |
| |
| /** |
| * Returns the indentation String at the line containing the given offset |
| * |
| * @param document the document containing the offset |
| * @param offset The offset of a character on a line whose indentation we seek |
| * @return The indent-string of the given node, or "" if the indentation for some |
| * reason could not be computed. |
| */ |
| public static String getIndentAtOffset(IDocument document, int offset) { |
| try { |
| IRegion lineInformation = document.getLineInformationOfOffset(offset); |
| if (lineInformation != null) { |
| int lineBegin = lineInformation.getOffset(); |
| if (lineBegin != offset) { |
| String prefix = document.get(lineBegin, offset - lineBegin); |
| |
| // It's possible that the tag whose indentation we seek is not |
| // at the beginning of the line. In that case we'll just return |
| // the indentation of the line itself. |
| for (int i = 0; i < prefix.length(); i++) { |
| if (!Character.isWhitespace(prefix.charAt(i))) { |
| return prefix.substring(0, i); |
| } |
| } |
| |
| return prefix; |
| } |
| } |
| } catch (BadLocationException e) { |
| AdtPlugin.log(e, "Could not obtain indentation"); //$NON-NLS-1$ |
| } |
| |
| return ""; //$NON-NLS-1$ |
| } |
| |
| /** |
| * Returns the active {@link AndroidXmlEditor}, provided it matches the given source |
| * viewer |
| * |
| * @param viewer the source viewer to ensure the active editor is associated with |
| * @return the active editor provided it matches the given source viewer or null. |
| */ |
| public static AndroidXmlEditor fromTextViewer(ITextViewer viewer) { |
| IWorkbenchWindow wwin = PlatformUI.getWorkbench().getActiveWorkbenchWindow(); |
| if (wwin != null) { |
| // Try the active editor first. |
| IWorkbenchPage page = wwin.getActivePage(); |
| if (page != null) { |
| IEditorPart editor = page.getActiveEditor(); |
| if (editor instanceof AndroidXmlEditor) { |
| ISourceViewer ssviewer = |
| ((AndroidXmlEditor) editor).getStructuredSourceViewer(); |
| if (ssviewer == viewer) { |
| return (AndroidXmlEditor) editor; |
| } |
| } |
| } |
| |
| // If that didn't work, try all the editors |
| for (IWorkbenchPage page2 : wwin.getPages()) { |
| if (page2 != null) { |
| for (IEditorReference editorRef : page2.getEditorReferences()) { |
| IEditorPart editor = editorRef.getEditor(false /*restore*/); |
| if (editor instanceof AndroidXmlEditor) { |
| ISourceViewer ssviewer = |
| ((AndroidXmlEditor) editor).getStructuredSourceViewer(); |
| if (ssviewer == viewer) { |
| return (AndroidXmlEditor) editor; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| /** Called when this editor is activated */ |
| public void activated() { |
| if (getActivePage() == mTextPageIndex) { |
| updateActionBindings(); |
| } |
| } |
| |
| /** Called when this editor is deactivated */ |
| public void deactivated() { |
| } |
| |
| /** |
| * Listen to changes in the underlying XML model in the structured editor. |
| */ |
| private class XmlModelStateListener implements IModelStateListener { |
| |
| /** |
| * A model is about to be changed. This typically is initiated by one |
| * client of the model, to signal a large change and/or a change to the |
| * model's ID or base Location. A typical use might be if a client might |
| * want to suspend processing until all changes have been made. |
| * <p/> |
| * This AndroidXmlEditor implementation of IModelChangedListener is empty. |
| */ |
| @Override |
| public void modelAboutToBeChanged(IStructuredModel model) { |
| // pass |
| } |
| |
| /** |
| * Signals that the changes foretold by modelAboutToBeChanged have been |
| * made. A typical use might be to refresh, or to resume processing that |
| * was suspended as a result of modelAboutToBeChanged. |
| * <p/> |
| * This AndroidXmlEditor implementation calls the xmlModelChanged callback. |
| */ |
| @Override |
| public void modelChanged(IStructuredModel model) { |
| if (mIgnoreXmlUpdate) { |
| return; |
| } |
| xmlModelChanged(getXmlDocument(model)); |
| } |
| |
| /** |
| * Notifies that a model's dirty state has changed, and passes that state |
| * in isDirty. A model becomes dirty when any change is made, and becomes |
| * not-dirty when the model is saved. |
| * <p/> |
| * This AndroidXmlEditor implementation of IModelChangedListener is empty. |
| */ |
| @Override |
| public void modelDirtyStateChanged(IStructuredModel model, boolean isDirty) { |
| // pass |
| } |
| |
| /** |
| * A modelDeleted means the underlying resource has been deleted. The |
| * model itself is not removed from model management until all have |
| * released it. Note: baseLocation is not (necessarily) changed in this |
| * event, but may not be accurate. |
| * <p/> |
| * This AndroidXmlEditor implementation of IModelChangedListener is empty. |
| */ |
| @Override |
| public void modelResourceDeleted(IStructuredModel model) { |
| // pass |
| } |
| |
| /** |
| * A model has been renamed or copied (as in saveAs..). In the renamed |
| * case, the two parameters are the same instance, and only contain the |
| * new info for id and base location. |
| * <p/> |
| * This AndroidXmlEditor implementation of IModelChangedListener is empty. |
| */ |
| @Override |
| public void modelResourceMoved(IStructuredModel oldModel, IStructuredModel newModel) { |
| // pass |
| } |
| |
| /** |
| * This AndroidXmlEditor implementation of IModelChangedListener is empty. |
| */ |
| @Override |
| public void modelAboutToBeReinitialized(IStructuredModel structuredModel) { |
| // pass |
| } |
| |
| /** |
| * This AndroidXmlEditor implementation of IModelChangedListener is empty. |
| */ |
| @Override |
| public void modelReinitialized(IStructuredModel structuredModel) { |
| // pass |
| } |
| } |
| } |
