1 files changed, 243 insertions, 0 deletions
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/AndroidSourceViewerConfig.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/AndroidSourceViewerConfig.java
new file mode 100644
index 000000000..b2c10ec3b
--- /dev/null
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/AndroidSourceViewerConfig.java
@@ -0,0 +1,243 @@
+/*
+ * 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 com.android.ide.eclipse.adt.internal.editors.formatting.AndroidXmlFormatter;
+import com.android.ide.eclipse.adt.internal.editors.formatting.AndroidXmlFormattingStrategy;
+
+import org.eclipse.jface.text.DefaultAutoIndentStrategy;
+import org.eclipse.jface.text.IAutoEditStrategy;
+import org.eclipse.jface.text.ITextHover;
+import org.eclipse.jface.text.ITextViewer;
+import org.eclipse.jface.text.contentassist.ICompletionProposal;
+import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
+import org.eclipse.jface.text.contentassist.IContentAssistant;
+import org.eclipse.jface.text.contentassist.IContextInformation;
+import org.eclipse.jface.text.contentassist.IContextInformationValidator;
+import org.eclipse.jface.text.formatter.IContentFormatter;
+import org.eclipse.jface.text.formatter.MultiPassContentFormatter;
+import org.eclipse.jface.text.source.ISourceViewer;
+import org.eclipse.wst.sse.core.text.IStructuredPartitions;
+import org.eclipse.wst.xml.core.text.IXMLPartitions;
+import org.eclipse.wst.xml.ui.StructuredTextViewerConfigurationXML;
+import org.eclipse.wst.xml.ui.internal.contentassist.XMLContentAssistProcessor;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Base Source Viewer Configuration for Android resources.
+ */
+@SuppressWarnings({"restriction", "deprecation"}) // XMLContentAssistProcessor etc
+public abstract class AndroidSourceViewerConfig extends StructuredTextViewerConfigurationXML {
+
+    public AndroidSourceViewerConfig() {
+        super();
+    }
+
+    @Override
+    public IContentAssistant getContentAssistant(ISourceViewer sourceViewer) {
+        return super.getContentAssistant(sourceViewer);
+    }
+
+    /**
+     * Returns the IContentAssistProcessor that
+     * {@link #getContentAssistProcessors(ISourceViewer, String)} should use
+     * for XML and default/unknown partitions.
+     *
+     * @return An {@link IContentAssistProcessor} or null.
+     */
+    public abstract IContentAssistProcessor getAndroidContentAssistProcessor(
+            ISourceViewer sourceViewer,
+            String partitionType);
+
+    /**
+     * Returns the content assist processors that will be used for content
+     * assist in the given source viewer and for the given partition type.
+     *
+     * @param sourceViewer the source viewer to be configured by this
+     *        configuration
+     * @param partitionType the partition type for which the content assist
+     *        processors are applicable
+     * @return IContentAssistProcessors or null if should not be supported
+     */
+    @Override
+    protected IContentAssistProcessor[] getContentAssistProcessors(
+            ISourceViewer sourceViewer, String partitionType) {
+        ArrayList<IContentAssistProcessor> processors = new ArrayList<IContentAssistProcessor>();
+        if (partitionType == IStructuredPartitions.UNKNOWN_PARTITION ||
+            partitionType == IStructuredPartitions.DEFAULT_PARTITION ||
+            partitionType == IXMLPartitions.XML_DEFAULT) {
+
+            IContentAssistProcessor processor =
+                getAndroidContentAssistProcessor(sourceViewer, partitionType);
+
+            if (processor != null) {
+                processors.add(processor);
+            }
+        }
+
+        IContentAssistProcessor[] others = super.getContentAssistProcessors(sourceViewer,
+                partitionType);
+        if (others != null && others.length > 0) {
+            for (IContentAssistProcessor p : others) {
+                // Builtin Eclipse WTP code completion assistant? If so,
+                // wrap it with our own filter which hides some unwanted completions.
+                if (p instanceof XMLContentAssistProcessor
+                        // On Eclipse 3.7, XMLContentAssistProcessor is no longer used,
+                        // and instead org.eclipse.wst.xml.ui.internal.contentassist.
+                        // XMLStructuredContentAssistProcessor is used - which isn't available
+                        // at compile time in 3.5.
+                        || p.getClass().getSimpleName().equals(
+                            "XMLStructuredContentAssistProcessor")) { //$NON-NLS-1$
+                    processors.add(new FilteringContentAssistProcessor(p));
+                } else {
+                    processors.add(p);
+                }
+            }
+        }
+
+        if (processors.size() > 0) {
+            return processors.toArray(new IContentAssistProcessor[processors.size()]);
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public ITextHover getTextHover(ISourceViewer sourceViewer, String contentType) {
+        // TODO text hover for android xml
+        return super.getTextHover(sourceViewer, contentType);
+    }
+
+    @Override
+    public IAutoEditStrategy[] getAutoEditStrategies(
+            ISourceViewer sourceViewer, String contentType) {
+        IAutoEditStrategy[] strategies = super.getAutoEditStrategies(sourceViewer, contentType);
+        List<IAutoEditStrategy> s = new ArrayList<IAutoEditStrategy>(strategies.length + 1);
+        s.add(new AndroidXmlAutoEditStrategy());
+
+        // Add other registered strategies, except the builtin indentation strategy which is
+        // now handled by the above AndroidXmlAutoEditStrategy
+        for (IAutoEditStrategy strategy : strategies) {
+            if (strategy instanceof DefaultAutoIndentStrategy) {
+                continue;
+            }
+            s.add(strategy);
+        }
+
+        return s.toArray(new IAutoEditStrategy[s.size()]);
+    }
+
+    @Override
+    public IContentFormatter getContentFormatter(ISourceViewer sourceViewer) {
+        IContentFormatter formatter = super.getContentFormatter(sourceViewer);
+
+        if (formatter instanceof MultiPassContentFormatter) {
+            ((MultiPassContentFormatter) formatter).setMasterStrategy(
+                    new AndroidXmlFormattingStrategy());
+            return formatter;
+        } else {
+            return new AndroidXmlFormatter();
+        }
+    }
+
+    @Override
+    protected Map<String, ?> getHyperlinkDetectorTargets(final ISourceViewer sourceViewer) {
+        @SuppressWarnings("unchecked")
+        Map<String, ?> targets = super.getHyperlinkDetectorTargets(sourceViewer);
+        // If we want to look up more context in our HyperlinkDetector via the
+        // getAdapter method, we should place an IAdaptable object into the map here.
+        targets.put("com.android.ide.eclipse.xmlCode", null); //$NON-NLS-1$
+        return targets;
+    }
+
+    /**
+     * A delegating {@link IContentAssistProcessor} whose purpose is to filter out some
+     * default Eclipse XML completions which are distracting in Android XML files
+     */
+    private static class FilteringContentAssistProcessor implements IContentAssistProcessor {
+        private IContentAssistProcessor mDelegate;
+
+        public FilteringContentAssistProcessor(IContentAssistProcessor delegate) {
+            super();
+            mDelegate = delegate;
+        }
+
+        @Override
+        public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {
+            ICompletionProposal[] result = mDelegate.computeCompletionProposals(viewer, offset);
+            if (result == null) {
+                return null;
+            }
+
+            List<ICompletionProposal> proposals =
+                new ArrayList<ICompletionProposal>(result.length);
+            for (ICompletionProposal proposal : result) {
+                String replacement = proposal.getDisplayString();
+                if (replacement.charAt(0) == '"' &&
+                        replacement.charAt(replacement.length() - 1) == '"') {
+                    // Filter out attribute values. In Android XML files (where there is no DTD
+                    // etc) the default Eclipse XML code completion simply provides the
+                    // existing value as a completion. This is often misleading, since if you
+                    // for example have a typo, completion will show your current (wrong)
+                    // value as a valid completion.
+                } else if (replacement.contains("Namespace")  //$NON-NLS-1$
+                        || replacement.startsWith("XSL ")  //$NON-NLS-1$
+                        || replacement.contains("Schema")) {  //$NON-NLS-1$
+                    // Eclipse adds in a number of namespace and schema related completions which
+                    // are not usually applicable in our files.
+                } else {
+                    proposals.add(proposal);
+                }
+            }
+
+            if (proposals.size() == result.length) {
+                return result;
+            } else {
+                return proposals.toArray(new ICompletionProposal[proposals.size()]);
+            }
+        }
+
+        @Override
+        public IContextInformation[] computeContextInformation(ITextViewer viewer, int offset) {
+            return mDelegate.computeContextInformation(viewer, offset);
+        }
+
+        @Override
+        public char[] getCompletionProposalAutoActivationCharacters() {
+            return mDelegate.getCompletionProposalAutoActivationCharacters();
+        }
+
+        @Override
+        public char[] getContextInformationAutoActivationCharacters() {
+            return mDelegate.getContextInformationAutoActivationCharacters();
+        }
+
+        @Override
+        public IContextInformationValidator getContextInformationValidator() {
+            return mDelegate.getContextInformationValidator();
+        }
+
+        @Override
+        public String getErrorMessage() {
+            return mDelegate.getErrorMessage();
+        }
+    }
+}