diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/AndroidXmlAutoEditStrategy.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/AndroidXmlAutoEditStrategy.java
index c5aa8cd..8a078ef 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/AndroidXmlAutoEditStrategy.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/AndroidXmlAutoEditStrategy.java
@@ -24,7 +24,7 @@
 
 import com.android.ide.eclipse.adt.AdtPlugin;
 import com.android.ide.eclipse.adt.AdtUtils;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatPreferences;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlFormatPreferences;
 import com.android.utils.Pair;
 
 import org.eclipse.jface.text.BadLocationException;
@@ -148,7 +148,7 @@
 
                         StringBuilder sb = new StringBuilder(c.text);
                         sb.append(lineIndent);
-                        String oneIndentUnit = XmlFormatPreferences.create().getOneIndentUnit();
+                        String oneIndentUnit = EclipseXmlFormatPreferences.create().getOneIndentUnit();
                         if (addIndent) {
                             sb.append(oneIndentUnit);
                         }
@@ -276,7 +276,7 @@
                                     }
 
                                     if (addIndent) {
-                                        sb.append(XmlFormatPreferences.create()
+                                        sb.append(EclipseXmlFormatPreferences.create()
                                                 .getOneIndentUnit());
                                     }
                                     c.text = sb.toString();
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/AndroidXmlFormattingStrategy.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/AndroidXmlFormattingStrategy.java
index 7c7b2cb..94c5299 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/AndroidXmlFormattingStrategy.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/AndroidXmlFormattingStrategy.java
@@ -29,6 +29,9 @@
 
 import com.android.SdkConstants;
 import com.android.annotations.VisibleForTesting;
+import com.android.ide.common.xml.XmlFormatPreferences;
+import com.android.ide.common.xml.XmlFormatStyle;
+import com.android.ide.common.xml.XmlPrettyPrinter;
 import com.android.ide.eclipse.adt.AdtPlugin;
 import com.android.ide.eclipse.adt.AdtUtils;
 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.DomUtilities;
@@ -78,7 +81,7 @@
  * Formatter which formats XML content according to the established Android coding
  * conventions. It performs the format by computing the smallest set of DOM nodes
  * overlapping the formatted region, then it pretty-prints that XML region
- * using the {@link XmlPrettyPrinter}, and then it replaces the affected region
+ * using the {@link EclipseXmlPrettyPrinter}, and then it replaces the affected region
  * by the pretty-printed region.
  * <p>
  * This strategy is also used for delegation. If the user has chosen to use the
@@ -332,7 +335,7 @@
         }
 
         XmlFormatStyle style = guessStyle(model, domDocument);
-        XmlFormatPreferences prefs = XmlFormatPreferences.create();
+        XmlFormatPreferences prefs = EclipseXmlFormatPreferences.create();
         String delimiter = TextUtilities.getDefaultLineDelimiter(document);
         XmlPrettyPrinter printer = new XmlPrettyPrinter(prefs, style, delimiter);
 
@@ -517,7 +520,10 @@
     static XmlFormatStyle guessStyle(IStructuredModel model, Document domDocument) {
         // The "layout" style is used for most XML resource file types:
         // layouts, color-lists and state-lists, animations, drawables, menus, etc
-        XmlFormatStyle style = XmlFormatStyle.LAYOUT;
+        XmlFormatStyle style = XmlFormatStyle.get(domDocument);
+        if (style == XmlFormatStyle.FILE) {
+            style = XmlFormatStyle.LAYOUT;
+        }
 
         // The "resource" style is used for most value-based XML files:
         // strings, dimensions, booleans, colors, integers, plurals,
@@ -546,7 +552,7 @@
                     String[] segments = resourceFolder.split("-"); //$NON-NLS-1$
                     ResourceType type = ResourceType.getEnum(segments[0]);
                     if (type != null) {
-                        style = XmlFormatStyle.get(type);
+                        style = EclipseXmlPrettyPrinter.get(type);
                     }
                 }
             }
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/XmlFormatPreferences.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/EclipseXmlFormatPreferences.java
similarity index 70%
rename from eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/XmlFormatPreferences.java
rename to eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/EclipseXmlFormatPreferences.java
index 05c8a7f..6c00b8e 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/XmlFormatPreferences.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/EclipseXmlFormatPreferences.java
@@ -16,61 +16,40 @@
 package com.android.ide.eclipse.adt.internal.editors.formatting;
 
 import com.android.annotations.NonNull;
+import com.android.annotations.Nullable;
 import com.android.annotations.VisibleForTesting;
+import com.android.ide.common.xml.XmlFormatPreferences;
 import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs;
-import com.android.ide.eclipse.adt.internal.preferences.AttributeSortOrder;
+import com.android.ide.common.xml.XmlAttributeSortOrder;
 
 import org.eclipse.core.runtime.Preferences;
 import org.eclipse.jface.preference.IPreferenceStore;
 import org.eclipse.ui.internal.editors.text.EditorsPlugin;
 import org.eclipse.ui.texteditor.AbstractDecoratedTextEditorPreferenceConstants;
+import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
 import org.eclipse.wst.xml.core.internal.XMLCorePlugin;
 import org.eclipse.wst.xml.core.internal.preferences.XMLCorePreferenceNames;
+import org.w3c.dom.Attr;
+
+import java.util.Comparator;
 
 /**
  * Formatting preferences used by the Android XML formatter.
  */
-public class XmlFormatPreferences {
-    /** Use the Eclipse indent (tab/space, indent size) settings? */
-    public boolean useEclipseIndent = false;
-
-    /** Remove empty lines in all cases? */
-    public boolean removeEmptyLines = false;
-
-    /** Reformat the text and comment blocks? */
-    public boolean reflowText = false;
-
-    /** Join lines when reformatting text and comment blocks? */
-    public boolean joinLines = false;
-
-    /** Can attributes appear on the same line as the opening line if there is just one of them? */
-    public boolean oneAttributeOnFirstLine = true;
-
-    /** The sorting order to use when formatting */
-    public AttributeSortOrder sortAttributes = AttributeSortOrder.LOGICAL;
-
-    /** Should there be a space before the closing > or /> ? */
-    public boolean spaceBeforeClose = true;
-
-    /** The string to insert for each indentation level */
-    private String mOneIndentUnit = "    "; //$NON-NLS-1$
-
-    /** Tab width (number of spaces to display for a tab) */
-    private int mTabWidth = -1; // -1: uninitialized
-
+public class EclipseXmlFormatPreferences extends XmlFormatPreferences {
     @VisibleForTesting
-    protected XmlFormatPreferences() {
+    protected EclipseXmlFormatPreferences() {
     }
 
     /**
-     * Creates a new {@link XmlFormatPreferences} based on the current settings
+     * Creates a new {@link EclipseXmlFormatPreferences} based on the current settings
      * in {@link AdtPrefs}
      *
-     * @return an {@link XmlFormatPreferences} object
+     * @return an {@link EclipseXmlFormatPreferences} object
      */
     @NonNull
-    public static XmlFormatPreferences create() {
-        XmlFormatPreferences p = new XmlFormatPreferences();
+    public static EclipseXmlFormatPreferences create() {
+        EclipseXmlFormatPreferences p = new EclipseXmlFormatPreferences();
         AdtPrefs prefs = AdtPrefs.getPrefs();
 
         p.useEclipseIndent = prefs.isUseEclipseIndent();
@@ -82,24 +61,37 @@
         return p;
     }
 
-    /**
-     * Returns a new preferences object initialized with the defaults
-     *
-     * @return an {@link XmlFormatPreferences} object
-     */
-    @NonNull
-    static XmlFormatPreferences defaults() {
-        return new XmlFormatPreferences();
+    @Override
+    @Nullable
+    public Comparator<Attr> getAttributeComparator() {
+        // Can't just skip sorting; the attribute table moves attributes out of order
+        // due to hashing, so sort by node positions
+        if (sortAttributes == XmlAttributeSortOrder.NO_SORTING) {
+            return EXISTING_ORDER_COMPARATOR;
+        }
+        return sortAttributes.getAttributeComparator();
     }
 
+    private static final Comparator<Attr> EXISTING_ORDER_COMPARATOR = new Comparator<Attr>() {
+        @Override
+        public int compare(Attr attr1, Attr attr2) {
+            IndexedRegion region1 = (IndexedRegion) attr1;
+            IndexedRegion region2 = (IndexedRegion) attr2;
+
+            return region1.getStartOffset() - region2.getStartOffset();
+        }
+    };
+
     // The XML module settings do not have a public API. We should replace this with JDT
     // settings anyway since that's more likely what users have configured and want applied
     // to their XML files
+
     /**
      * Returns the string to use to indent one indentation level
      *
      * @return the string used to indent one indentation level
      */
+    @Override
     @SuppressWarnings({
             "restriction", "deprecation"
     })
@@ -131,6 +123,7 @@
      *
      * @return the number of spaces used to display a single tab character
      */
+    @Override
     @SuppressWarnings("restriction") // Editor settings
     public int getTabWidth() {
         if (mTabWidth == -1) {
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/EclipseXmlPrettyPrinter.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/EclipseXmlPrettyPrinter.java
new file mode 100644
index 0000000..2051e5a
--- /dev/null
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/EclipseXmlPrettyPrinter.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright (C) 2011 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.formatting;
+
+import com.android.SdkConstants;
+import com.android.annotations.NonNull;
+import com.android.annotations.Nullable;
+import com.android.ide.common.xml.XmlFormatPreferences;
+import com.android.ide.common.xml.XmlFormatStyle;
+import com.android.ide.common.xml.XmlPrettyPrinter;
+import com.android.ide.eclipse.adt.internal.editors.layout.gle2.DomUtilities;
+import com.android.resources.ResourceFolderType;
+import com.android.resources.ResourceType;
+import com.android.utils.SdkUtils;
+import com.android.utils.XmlUtils;
+
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+
+/**
+ * Eclipse customization of the {@link EclipseXmlPrettyPrinter} which takes advantage of the
+ * Eclipse DOM Api to track additional information, such as whether an element with no children
+ * was of the open form ({@code <foo></foo>}) or the closed form ({@code <foo/>}), the ability to
+ * look up the original source (for proper entity handling), the ability to preserve attribute
+ * source order, etc.
+ */
+@SuppressWarnings("restriction") // WST XML API
+public class EclipseXmlPrettyPrinter extends XmlPrettyPrinter {
+
+    /**
+     * Creates a new {@link com.android.ide.common.xml.XmlPrettyPrinter}
+     *
+     * @param prefs         the preferences to format with
+     * @param style         the style to format with
+     * @param lineSeparator the line separator to use, such as "\n" (can be null, in which case the
+     *                      system default is looked up via the line.separator property)
+     */
+    public EclipseXmlPrettyPrinter(
+            XmlFormatPreferences prefs,
+            XmlFormatStyle style,
+            String lineSeparator) {
+        super(prefs, style, lineSeparator);
+    }
+
+    /**
+     * Pretty-prints the given XML document, which must be well-formed. If it is not,
+     * the original unformatted XML document is returned
+     *
+     * @param xml the XML content to format
+     * @param prefs the preferences to format with
+     * @param style the style to format with
+     * @param lineSeparator the line separator to use, such as "\n" (can be null, in which
+     *     case the system default is looked up via the line.separator property)
+     * @return the formatted document (or if a parsing error occurred, returns the
+     *     unformatted document)
+     */
+    @NonNull
+    public static String prettyPrint(
+            @NonNull String xml,
+            @NonNull XmlFormatPreferences prefs,
+            @NonNull XmlFormatStyle style,
+            @Nullable String lineSeparator) {
+        Document document = DomUtilities.parseStructuredDocument(xml);
+        if (document != null) {
+            EclipseXmlPrettyPrinter printer = new EclipseXmlPrettyPrinter(prefs, style,
+                    lineSeparator);
+            StringBuilder sb = new StringBuilder(3 * xml.length() / 2);
+            printer.prettyPrint(-1, document, null, null, sb, false /*openTagOnly*/);
+            return sb.toString();
+        } else {
+            // Parser error: just return the unformatted content
+            return xml;
+        }
+    }
+
+    @NonNull
+    public static String prettyPrint(@NonNull Node node) {
+        return prettyPrint(node, EclipseXmlFormatPreferences.create(), XmlFormatStyle.get(node),
+                SdkUtils.getLineSeparator());
+    }
+
+    /**
+     * Pretty prints the given node
+     *
+     * @param node the node, usually a document, to be printed
+     * @param prefs the formatting preferences
+     * @param style the formatting style to use
+     * @param lineSeparator the line separator to use, or null to use the
+     *            default
+     * @return a formatted string
+     */
+    @NonNull
+    public static String prettyPrint(
+            @NonNull Node node,
+            @NonNull XmlFormatPreferences prefs,
+            @NonNull XmlFormatStyle style,
+            @Nullable String lineSeparator) {
+        XmlPrettyPrinter printer = new EclipseXmlPrettyPrinter(prefs, style, lineSeparator);
+        StringBuilder sb = new StringBuilder(1000);
+        printer.prettyPrint(-1, node, null, null, sb, false /*openTagOnly*/);
+        String xml = sb.toString();
+        if (node.getNodeType() == Node.DOCUMENT_NODE && !xml.startsWith("<?")) { //$NON-NLS-1$
+            xml = XmlUtils.XML_PROLOG + xml;
+        }
+        return xml;
+    }
+
+    @Nullable
+    @Override
+    protected String getSource(@NonNull Node node) {
+        // In Eclipse, org.w3c.dom.DocumentType.getTextContent() returns null
+        if (node instanceof IDOMNode) {
+            // Get the original source string. This will contain the actual entities
+            // such as "&gt;" instead of ">" which it gets turned into for the DOM nodes.
+            // By operating on source we can preserve the user's entities rather than
+            // having &gt; for example always turned into >.
+            IDOMNode textImpl = (IDOMNode) node;
+            return textImpl.getSource();
+        }
+
+        return super.getSource(node);
+    }
+
+    @Override
+    protected boolean isEmptyTag(Element element) {
+        if (element instanceof IDOMElement) {
+            IDOMElement elementImpl = (IDOMElement) element;
+            if (elementImpl.isEmptyTag()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Returns the {@link XmlFormatStyle} to use for a resource of the given type
+     *
+     * @param resourceType the type of resource to be formatted
+     * @return the suitable format style to use
+     */
+    public static XmlFormatStyle get(ResourceType resourceType) {
+        switch (resourceType) {
+            case ARRAY:
+            case ATTR:
+            case BOOL:
+            case DECLARE_STYLEABLE:
+            case DIMEN:
+            case FRACTION:
+            case ID:
+            case INTEGER:
+            case STRING:
+            case PLURALS:
+            case STYLE:
+            case STYLEABLE:
+            case COLOR:
+                return XmlFormatStyle.RESOURCE;
+
+            case LAYOUT:
+                return XmlFormatStyle.LAYOUT;
+
+            case DRAWABLE:
+            case MENU:
+            case ANIM:
+            case ANIMATOR:
+            case INTERPOLATOR:
+            default:
+                return XmlFormatStyle.FILE;
+        }
+    }
+
+    /**
+     * Returns the {@link XmlFormatStyle} to use for resource files in the given resource
+     * folder
+     *
+     * @param folderType the type of folder containing the resource file
+     * @return the suitable format style to use
+     */
+    public static XmlFormatStyle getForFolderType(ResourceFolderType folderType) {
+        switch (folderType) {
+            case LAYOUT:
+                return XmlFormatStyle.LAYOUT;
+            case COLOR:
+            case VALUES:
+                return XmlFormatStyle.RESOURCE;
+            case ANIM:
+            case ANIMATOR:
+            case DRAWABLE:
+            case INTERPOLATOR:
+            case MENU:
+            default:
+                return XmlFormatStyle.FILE;
+        }
+    }
+
+    /**
+     * Returns the {@link XmlFormatStyle} to use for resource files of the given path.
+     *
+     * @param path the path to the resource file
+     * @return the suitable format style to use
+     */
+    public static XmlFormatStyle getForFile(IPath path) {
+        if (SdkConstants.FN_ANDROID_MANIFEST_XML.equals(path.lastSegment())) {
+            return XmlFormatStyle.MANIFEST;
+        }
+
+        if (path.segmentCount() > 2) {
+            String parentName = path.segment(path.segmentCount() - 2);
+            ResourceFolderType folderType = ResourceFolderType.getFolderType(parentName);
+            return getForFolderType(folderType);
+        }
+
+        return XmlFormatStyle.FILE;
+    }
+}
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/XmlFormatStyle.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/XmlFormatStyle.java
deleted file mode 100644
index cb6ee5d..0000000
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/XmlFormatStyle.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright (C) 2011 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.formatting;
-
-import com.android.SdkConstants;
-import com.android.resources.ResourceFolderType;
-import com.android.resources.ResourceType;
-
-import org.eclipse.core.runtime.IPath;
-
-/**
- * Style to use when printing the XML. Different types of Android XML files use slightly
- * different preferred formats. For example, in layout files there is typically always a
- * newline between successive elements, whereas in a manifest file there is typically only
- * newlines between different types of elements. As another example, in resource files,
- * the format is typically much more compact: the text content of {@code <item>} tags is
- * included on the same line whereas for other layout styles the children are typically
- * placed on a line of their own.
- */
-public enum XmlFormatStyle {
-    /** Layout formatting style: blank lines between elements, attributes on separate lines */
-    LAYOUT,
-
-    /** Similar to layout formatting style, but no blank lines inside opening elements */
-    FILE,
-
-    /** Resource style: one line per complete element including text child content */
-    RESOURCE,
-
-    /**
-     * Similar to layout style, but no newlines between related elements such as
-     * successive {@code <uses-permission>} declarations, and no newlines inside
-     * the second level elements (so an {@code <activity>} declaration appears as a
-     * single block with no whitespace within it)
-     */
-    MANIFEST;
-
-    /**
-     * Returns the {@link XmlFormatStyle} to use for a resource of the given type
-     *
-     * @param resourceType the type of resource to be formatted
-     * @return the suitable format style to use
-     */
-    public static XmlFormatStyle get(ResourceType resourceType) {
-        switch (resourceType) {
-            case ARRAY:
-            case ATTR:
-            case BOOL:
-            case DECLARE_STYLEABLE:
-            case DIMEN:
-            case FRACTION:
-            case ID:
-            case INTEGER:
-            case STRING:
-            case PLURALS:
-            case STYLE:
-            case STYLEABLE:
-            case COLOR:
-                return RESOURCE;
-
-            case LAYOUT:
-                return LAYOUT;
-
-            case DRAWABLE:
-            case MENU:
-            case ANIM:
-            case ANIMATOR:
-            case INTERPOLATOR:
-            default:
-                return FILE;
-        }
-    }
-
-    /**
-     * Returns the {@link XmlFormatStyle} to use for resource files in the given resource
-     * folder
-     *
-     * @param folderType the type of folder containing the resource file
-     * @return the suitable format style to use
-     */
-    public static XmlFormatStyle getForFolderType(ResourceFolderType folderType) {
-        switch (folderType) {
-            case LAYOUT:
-                return LAYOUT;
-            case COLOR:
-            case VALUES:
-                return RESOURCE;
-            case ANIM:
-            case ANIMATOR:
-            case DRAWABLE:
-            case INTERPOLATOR:
-            case MENU:
-            default:
-                return FILE;
-        }
-    }
-
-    /**
-     * Returns the {@link XmlFormatStyle} to use for resource files of the given path.
-     *
-     * @param path the path to the resource file
-     * @return the suitable format style to use
-     */
-    public static XmlFormatStyle getForFile(IPath path) {
-        if (SdkConstants.FN_ANDROID_MANIFEST_XML.equals(path.lastSegment())) {
-            return MANIFEST;
-        }
-
-        if (path.segmentCount() > 2) {
-            String parentName = path.segment(path.segmentCount() - 2);
-            ResourceFolderType folderType = ResourceFolderType.getFolderType(parentName);
-            return getForFolderType(folderType);
-        }
-
-        return FILE;
-    }
-}
\ No newline at end of file
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/XmlPrettyPrinter.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/XmlPrettyPrinter.java
deleted file mode 100644
index 969d45a..0000000
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/formatting/XmlPrettyPrinter.java
+++ /dev/null
@@ -1,1014 +0,0 @@
-/*
- * Copyright (C) 2011 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.formatting;
-
-import static com.android.SdkConstants.TAG_COLOR;
-import static com.android.SdkConstants.TAG_DIMEN;
-import static com.android.SdkConstants.TAG_ITEM;
-import static com.android.SdkConstants.TAG_STRING;
-import static com.android.SdkConstants.TAG_STYLE;
-import static com.android.SdkConstants.XMLNS;
-
-import com.android.annotations.NonNull;
-import com.android.annotations.Nullable;
-import com.android.ide.eclipse.adt.internal.editors.layout.gle2.DomUtilities;
-import com.android.utils.SdkUtils;
-import com.android.utils.XmlUtils;
-
-import org.eclipse.wst.xml.core.internal.document.DocumentTypeImpl;
-import org.eclipse.wst.xml.core.internal.document.ElementImpl;
-import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
-import org.w3c.dom.Attr;
-import org.w3c.dom.Document;
-import org.w3c.dom.Element;
-import org.w3c.dom.NamedNodeMap;
-import org.w3c.dom.Node;
-import org.w3c.dom.NodeList;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-
-/**
- * Visitor which walks over the subtree of the DOM to be formatted and pretty prints
- * the DOM into the given {@link StringBuilder}
- */
-@SuppressWarnings("restriction")
-public class XmlPrettyPrinter {
-    private static final String COMMENT_BEGIN = "<!--"; //$NON-NLS-1$
-    private static final String COMMENT_END = "-->";    //$NON-NLS-1$
-
-    /** The style to print the XML in */
-    private final XmlFormatStyle mStyle;
-    /** Formatting preferences to use when formatting the XML */
-    private final XmlFormatPreferences mPrefs;
-    /** Start node to start formatting at */
-    private Node mStartNode;
-    /** Start node to stop formatting after */
-    private Node mEndNode;
-    /** Whether the visitor is currently in range */
-    private boolean mInRange;
-    /** Output builder */
-    private StringBuilder mOut;
-    /** String to insert for a single indentation level */
-    private String mIndentString;
-    /** Line separator to use */
-    private String mLineSeparator;
-    /** If true, we're only formatting an open tag */
-    private boolean mOpenTagOnly;
-    /** List of indentation to use for each given depth */
-    private String[] mIndentationLevels;
-
-    /**
-     * Creates a new {@link XmlPrettyPrinter}
-     *
-     * @param prefs the preferences to format with
-     * @param style the style to format with
-     * @param lineSeparator the line separator to use, such as "\n" (can be null, in which
-     *            case the system default is looked up via the line.separator property)
-     */
-    public XmlPrettyPrinter(XmlFormatPreferences prefs, XmlFormatStyle style,
-            String lineSeparator) {
-        mPrefs = prefs;
-        mStyle = style;
-        if (lineSeparator == null) {
-            lineSeparator = SdkUtils.getLineSeparator();
-        }
-        mLineSeparator = lineSeparator;
-    }
-
-    /**
-     * Sets the indentation levels to use (indentation string to use for each depth,
-     * indexed by depth
-     *
-     * @param indentationLevels an array of strings to use for the various indentation
-     *            levels
-     */
-    public void setIndentationLevels(String[] indentationLevels) {
-        mIndentationLevels = indentationLevels;
-    }
-
-    /**
-     * Pretty-prints the given XML document, which must be well-formed. If it is not,
-     * the original unformatted XML document is returned
-     *
-     * @param xml the XML content to format
-     * @param prefs the preferences to format with
-     * @param style the style to format with
-     * @param lineSeparator the line separator to use, such as "\n" (can be null, in which
-     *     case the system default is looked up via the line.separator property)
-     * @return the formatted document (or if a parsing error occurred, returns the
-     *     unformatted document)
-     */
-    @NonNull
-    public static String prettyPrint(
-            @NonNull String xml,
-            @NonNull XmlFormatPreferences prefs,
-            @NonNull XmlFormatStyle style,
-            @Nullable String lineSeparator) {
-        Document document = DomUtilities.parseStructuredDocument(xml);
-        if (document != null) {
-            XmlPrettyPrinter printer = new XmlPrettyPrinter(prefs, style, lineSeparator);
-            StringBuilder sb = new StringBuilder(3 * xml.length() / 2);
-            printer.prettyPrint(-1, document, null, null, sb, false /*openTagOnly*/);
-            return sb.toString();
-        } else {
-            // Parser error: just return the unformatted content
-            return xml;
-        }
-    }
-
-    /**
-     * Pretty prints the given node
-     *
-     * @param node the node, usually a document, to be printed
-     * @param prefs the formatting preferences
-     * @param style the formatting style to use
-     * @param lineSeparator the line separator to use, or null to use the
-     *            default
-     * @return a formatted string
-     */
-    @NonNull
-    public static String prettyPrint(
-            @NonNull Node node,
-            @NonNull XmlFormatPreferences prefs,
-            @NonNull XmlFormatStyle style,
-            @Nullable String lineSeparator) {
-        XmlPrettyPrinter printer = new XmlPrettyPrinter(prefs, style, lineSeparator);
-        StringBuilder sb = new StringBuilder(1000);
-        printer.prettyPrint(-1, node, null, null, sb, false /*openTagOnly*/);
-        String xml = sb.toString();
-        if (node.getNodeType() == Node.DOCUMENT_NODE && !xml.startsWith("<?")) { //$NON-NLS-1$
-            xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" + xml; //$NON-NLS-1$
-        }
-        return xml;
-    }
-
-    /**
-     * Pretty prints the given node using default styles
-     *
-     * @param node the node, usually a document, to be printed
-     * @return the resulting formatted string
-     */
-    @NonNull
-    public static String prettyPrint(@NonNull Node node) {
-        return prettyPrint(node, XmlFormatPreferences.create(), XmlFormatStyle.FILE,
-                SdkUtils.getLineSeparator());
-    }
-
-    /**
-     * Start pretty-printing at the given node, which must either be the
-     * startNode or contain it as a descendant.
-     *
-     * @param rootDepth the depth of the given node, used to determine indentation
-     * @param root the node to start pretty printing from (which may not itself be
-     *            included in the start to end node range but should contain it)
-     * @param startNode the node to start formatting at
-     * @param endNode the node to end formatting at
-     * @param out the {@link StringBuilder} to pretty print into
-     * @param openTagOnly if true, only format the open tag of the startNode (and nothing
-     *     else)
-     */
-    public void prettyPrint(int rootDepth, Node root, Node startNode, Node endNode,
-            StringBuilder out, boolean openTagOnly) {
-        if (startNode == null) {
-            startNode = root;
-        }
-        if (endNode == null) {
-            endNode = root;
-        }
-        assert !openTagOnly || startNode == endNode;
-
-        mStartNode = startNode;
-        mOpenTagOnly = openTagOnly;
-        mEndNode = endNode;
-        mOut = out;
-        mInRange = false;
-        mIndentString = mPrefs.getOneIndentUnit();
-
-        visitNode(rootDepth, root);
-    }
-
-    /** Visit the given node at the given depth */
-    private void visitNode(int depth, Node node) {
-        if (node == mStartNode) {
-            mInRange = true;
-        }
-
-        if (mInRange) {
-            visitBeforeChildren(depth, node);
-            if (mOpenTagOnly && mStartNode == node) {
-                mInRange = false;
-                return;
-            }
-        }
-
-        NodeList children = node.getChildNodes();
-        for (int i = 0, n = children.getLength(); i < n; i++) {
-            Node child = children.item(i);
-            visitNode(depth + 1, child);
-        }
-
-        if (mInRange) {
-            visitAfterChildren(depth, node);
-        }
-
-        if (node == mEndNode) {
-            mInRange = false;
-        }
-    }
-
-    private void visitBeforeChildren(int depth, Node node) {
-        short type = node.getNodeType();
-        switch (type) {
-            case Node.DOCUMENT_NODE:
-            case Node.DOCUMENT_FRAGMENT_NODE:
-                // Nothing to do
-                break;
-
-            case Node.ATTRIBUTE_NODE:
-                // Handled as part of processing elements
-                break;
-
-            case Node.ELEMENT_NODE: {
-                printOpenElementTag(depth, node);
-                break;
-            }
-
-            case Node.TEXT_NODE: {
-                printText(node);
-                break;
-            }
-
-            case Node.CDATA_SECTION_NODE:
-                printCharacterData(depth, node);
-                break;
-
-            case Node.PROCESSING_INSTRUCTION_NODE:
-                printProcessingInstruction(node);
-                break;
-
-            case Node.COMMENT_NODE: {
-                printComment(depth, node);
-                break;
-            }
-
-            case Node.DOCUMENT_TYPE_NODE:
-                printDocType(node);
-                break;
-
-            case Node.ENTITY_REFERENCE_NODE:
-            case Node.ENTITY_NODE:
-            case Node.NOTATION_NODE:
-                break;
-            default:
-                assert false : type;
-        }
-    }
-
-    private void visitAfterChildren(int depth, Node node) {
-        short type = node.getNodeType();
-        switch (type) {
-            case Node.ATTRIBUTE_NODE:
-                // Handled as part of processing elements
-                break;
-            case Node.ELEMENT_NODE: {
-                printCloseElementTag(depth, node);
-                break;
-            }
-        }
-    }
-
-    private void printProcessingInstruction(Node node) {
-        mOut.append("<?xml "); //$NON-NLS-1$
-        mOut.append(node.getNodeValue().trim());
-        mOut.append('?').append('>').append(mLineSeparator);
-    }
-
-    private void printDocType(Node node) {
-        // In Eclipse, org.w3c.dom.DocumentType.getTextContent() returns null
-        if (node instanceof DocumentTypeImpl) {
-            String content = ((DocumentTypeImpl) node).getSource();
-            mOut.append(content);
-            mOut.append(mLineSeparator);
-        }
-    }
-
-    private void printCharacterData(int depth, Node node) {
-        String nodeValue = node.getNodeValue();
-        boolean separateLine = nodeValue.indexOf('\n') != -1;
-        if (separateLine && !endsWithLineSeparator()) {
-            mOut.append(mLineSeparator);
-        }
-        mOut.append("<![CDATA["); //$NON-NLS-1$
-        mOut.append(nodeValue);
-        mOut.append("]]>");       //$NON-NLS-1$
-        if (separateLine) {
-            mOut.append(mLineSeparator);
-        }
-    }
-
-    private void printText(Node node) {
-        boolean escape = true;
-        String text = node.getNodeValue();
-
-        if (node instanceof IDOMNode) {
-            // Get the original source string. This will contain the actual entities
-            // such as "&gt;" instead of ">" which it gets turned into for the DOM nodes.
-            // By operating on source we can preserve the user's entities rather than
-            // having &gt; for example always turned into >.
-            IDOMNode textImpl = (IDOMNode) node;
-            text = textImpl.getSource();
-            escape = false;
-        }
-
-        // Most text nodes are just whitespace for formatting (which we're replacing)
-        // so look for actual text content and extract that part out
-        String trimmed = text.trim();
-        if (trimmed.length() > 0) {
-            // TODO: Reformat the contents if it is too wide?
-
-            // Note that we append the actual text content, NOT the trimmed content,
-            // since the whitespace may be significant, e.g.
-            // <string name="toast_sync_error">Sync error: <xliff:g id="error">%1$s</xliff:g>...
-
-            // However, we should remove all blank lines in the prefix and suffix of the
-            // text node, or we will end up inserting additional blank lines each time you're
-            // formatting a text node within an outer element (which also adds spacing lines)
-            int lastPrefixNewline = -1;
-            for (int i = 0, n = text.length(); i < n; i++) {
-                char c = text.charAt(i);
-                if (c == '\n') {
-                    lastPrefixNewline = i;
-                } else if (!Character.isWhitespace(c)) {
-                    break;
-                }
-            }
-            int firstSuffixNewline = -1;
-            for (int i = text.length() - 1; i >= 0; i--) {
-                char c = text.charAt(i);
-                if (c == '\n') {
-                    firstSuffixNewline = i;
-                } else if (!Character.isWhitespace(c)) {
-                    break;
-                }
-            }
-            if (lastPrefixNewline != -1 || firstSuffixNewline != -1) {
-                if (firstSuffixNewline == -1) {
-                    firstSuffixNewline = text.length();
-                }
-                text = text.substring(lastPrefixNewline + 1, firstSuffixNewline);
-            }
-
-            if (escape) {
-                XmlUtils.appendXmlTextValue(mOut, text);
-            } else {
-                // Text is already escaped
-                mOut.append(text);
-            }
-
-            if (mStyle != XmlFormatStyle.RESOURCE) {
-                mOut.append(mLineSeparator);
-            }
-        }
-    }
-
-    private void printComment(int depth, Node node) {
-        String comment = node.getNodeValue();
-        boolean multiLine = comment.indexOf('\n') != -1;
-        String trimmed = comment.trim();
-
-        // See if this is an "end-of-the-line" comment, e.g. it is not a multi-line
-        // comment and it appears on the same line as an opening or closing element tag;
-        // if so, continue to place it as a suffix comment
-        boolean isSuffixComment = false;
-        if (!multiLine) {
-            Node previous = node.getPreviousSibling();
-            isSuffixComment = true;
-            while (previous != null) {
-                short type = previous.getNodeType();
-                if (type == Node.TEXT_NODE || type == Node.COMMENT_NODE) {
-                    if (previous.getNodeValue().indexOf('\n') != -1) {
-                        isSuffixComment = false;
-                        break;
-                    }
-                } else {
-                    break;
-                }
-                previous = previous.getPreviousSibling();
-            }
-            if (isSuffixComment) {
-                // Remove newline added by element open tag or element close tag
-                if (endsWithLineSeparator()) {
-                    removeLastLineSeparator();
-                }
-                mOut.append(' ');
-            }
-        }
-
-        // Put the comment on a line on its own? Only if it was separated by a blank line
-        // in the previous version of the document. In other words, if the document
-        // adds blank lines between comments this formatter will preserve that fact, and vice
-        // versa for a tightly formatted document it will preserve that convention as well.
-        if (!mPrefs.removeEmptyLines && depth > 0 && !isSuffixComment) {
-            Node curr = node.getPreviousSibling();
-            if (curr == null) {
-                mOut.append(mLineSeparator);
-            } else if (curr.getNodeType() == Node.TEXT_NODE) {
-                String text = curr.getNodeValue();
-                // Count how many newlines we find in the trailing whitespace of the
-                // text node
-                int newLines = 0;
-                for (int i = text.length() - 1; i >= 0; i--) {
-                    char c = text.charAt(i);
-                    if (Character.isWhitespace(c)) {
-                        if (c == '\n') {
-                            newLines++;
-                            if (newLines == 2) {
-                                break;
-                            }
-                        }
-                    } else {
-                        break;
-                    }
-                }
-                if (newLines >= 2) {
-                    mOut.append(mLineSeparator);
-                } else if (text.trim().length() == 0 && curr.getPreviousSibling() == null) {
-                    // Comment before first child in node
-                    mOut.append(mLineSeparator);
-                }
-            }
-        }
-
-
-        // TODO: Reformat the comment text?
-        if (!multiLine) {
-            if (!isSuffixComment) {
-                indent(depth);
-            }
-            mOut.append(COMMENT_BEGIN).append(' ');
-            mOut.append(trimmed);
-            mOut.append(' ').append(COMMENT_END);
-            mOut.append(mLineSeparator);
-        } else {
-            // Strip off blank lines at the beginning and end of the comment text.
-            // Find last newline at the beginning of the text:
-            int index = 0;
-            int end = comment.length();
-            int recentNewline = -1;
-            while (index < end) {
-                char c = comment.charAt(index);
-                if (c == '\n') {
-                    recentNewline = index;
-                }
-                if (!Character.isWhitespace(c)) {
-                    break;
-                }
-                index++;
-            }
-
-            int start = recentNewline + 1;
-
-            // Find last newline at the end of the text
-            index = end - 1;
-            recentNewline = -1;
-            while (index > start) {
-                char c = comment.charAt(index);
-                if (c == '\n') {
-                    recentNewline = index;
-                }
-                if (!Character.isWhitespace(c)) {
-                    break;
-                }
-                index--;
-            }
-
-            end = recentNewline == -1 ? index + 1 : recentNewline;
-            if (start >= end) {
-                // It's a blank comment like <!-- \n\n--> - just clean it up
-                if (!isSuffixComment) {
-                    indent(depth);
-                }
-                mOut.append(COMMENT_BEGIN).append(' ').append(COMMENT_END);
-                mOut.append(mLineSeparator);
-                return;
-            }
-
-            trimmed = comment.substring(start, end);
-
-            // When stripping out prefix and suffix blank lines we might have ended up
-            // with a single line comment again so check and format single line comments
-            // without newlines inside the <!-- --> delimiters
-            multiLine = trimmed.indexOf('\n') != -1;
-            if (multiLine) {
-                indent(depth);
-                mOut.append(COMMENT_BEGIN);
-                mOut.append(mLineSeparator);
-
-                // See if we need to add extra spacing to keep alignment. Consider a comment
-                // like this:
-                // <!-- Deprecated strings - Move the identifiers to this section,
-                //      and remove the actual text. -->
-                // This String will be
-                // " Deprecated strings - Move the identifiers to this section,\n" +
-                // "     and remove the actual text. -->"
-                // where the left side column no longer lines up.
-                // To fix this, we need to insert some extra whitespace into the first line
-                // of the string; in particular, the exact number of characters that the
-                // first line of the comment was indented with!
-
-                // However, if the comment started like this:
-                // <!--
-                // /** Copyright
-                // -->
-                // then obviously the align-indent is 0, so we only want to compute an
-                // align indent when we don't find a newline before the content
-                boolean startsWithNewline = false;
-                for (int i = 0; i < start; i++) {
-                    if (comment.charAt(i) == '\n') {
-                        startsWithNewline = true;
-                        break;
-                    }
-                }
-                if (!startsWithNewline) {
-                    Node previous = node.getPreviousSibling();
-                    if (previous != null && previous.getNodeType() == Node.TEXT_NODE) {
-                        String prevText = previous.getNodeValue();
-                        int indentation = COMMENT_BEGIN.length();
-                        for (int i = prevText.length() - 1; i >= 0; i--) {
-                            char c = prevText.charAt(i);
-                            if (c == '\n') {
-                                break;
-                            } else {
-                                indentation += (c == '\t') ? mPrefs.getTabWidth() : 1;
-                            }
-                        }
-
-                        // See if the next line after the newline has indentation; if it doesn't,
-                        // leave things alone. This fixes a case like this:
-                        //     <!-- This is the
-                        //     comment block -->
-                        // such that it doesn't turn it into
-                        //     <!--
-                        //          This is the
-                        //     comment block
-                        //     -->
-                        // In this case we instead want
-                        //     <!--
-                        //     This is the
-                        //     comment block
-                        //     -->
-                        int minIndent = Integer.MAX_VALUE;
-                        String[] lines = trimmed.split("\n"); //$NON-NLS-1$
-                        // Skip line 0 since we know that it doesn't start with a newline
-                        for (int i = 1; i < lines.length; i++) {
-                            int indent = 0;
-                            String line = lines[i];
-                            for (int j = 0; j < line.length(); j++) {
-                                char c = line.charAt(j);
-                                if (!Character.isWhitespace(c)) {
-                                    // Only set minIndent if there's text content on the line;
-                                    // blank lines can exist in the comment without affecting
-                                    // the overall minimum indentation boundary.
-                                    if (indent < minIndent) {
-                                        minIndent = indent;
-                                    }
-                                    break;
-                                } else {
-                                    indent += (c == '\t') ? mPrefs.getTabWidth() : 1;
-                                }
-                            }
-                        }
-
-                        if (minIndent < indentation) {
-                            indentation = minIndent;
-
-                            // Subtract any indentation that is already present on the line
-                            String line = lines[0];
-                            for (int j = 0; j < line.length(); j++) {
-                                char c = line.charAt(j);
-                                if (!Character.isWhitespace(c)) {
-                                    break;
-                                } else {
-                                    indentation -= (c == '\t') ? mPrefs.getTabWidth() : 1;
-                                }
-                            }
-                        }
-
-                        for (int i = 0; i < indentation; i++) {
-                            mOut.append(' ');
-                        }
-
-                        if (indentation < 0) {
-                            boolean prefixIsSpace = true;
-                            for (int i = 0; i < -indentation && i < trimmed.length(); i++) {
-                                if (!Character.isWhitespace(trimmed.charAt(i))) {
-                                    prefixIsSpace = false;
-                                    break;
-                                }
-                            }
-                            if (prefixIsSpace) {
-                                trimmed = trimmed.substring(-indentation);
-                            }
-                        }
-                    }
-                }
-
-                mOut.append(trimmed);
-                mOut.append(mLineSeparator);
-                indent(depth);
-                mOut.append(COMMENT_END);
-                mOut.append(mLineSeparator);
-            } else {
-                mOut.append(COMMENT_BEGIN).append(' ');
-                mOut.append(trimmed);
-                mOut.append(' ').append(COMMENT_END);
-                mOut.append(mLineSeparator);
-            }
-        }
-
-        // Preserve whitespace after comment: See if the original document had two or
-        // more newlines after the comment, and if so have a blank line between this
-        // comment and the next
-        Node next = node.getNextSibling();
-        if (!mPrefs.removeEmptyLines && next != null && next.getNodeType() == Node.TEXT_NODE) {
-            String text = next.getNodeValue();
-            int newLinesBeforeText = 0;
-            for (int i = 0, n = text.length(); i < n; i++) {
-                char c = text.charAt(i);
-                if (c == '\n') {
-                    newLinesBeforeText++;
-                    if (newLinesBeforeText == 2) {
-                        // Yes
-                        mOut.append(mLineSeparator);
-                        break;
-                    }
-                } else if (!Character.isWhitespace(c)) {
-                    break;
-                }
-            }
-        }
-    }
-
-    private boolean endsWithLineSeparator() {
-        int separatorLength = mLineSeparator.length();
-        if (mOut.length() >= separatorLength) {
-            for (int i = 0, j = mOut.length() - separatorLength; i < separatorLength; i++) {
-               if (mOut.charAt(j) != mLineSeparator.charAt(i)) {
-                   return false;
-               }
-            }
-        }
-
-        return true;
-    }
-
-    private void removeLastLineSeparator() {
-        mOut.setLength(mOut.length() - mLineSeparator.length());
-    }
-
-    private void printOpenElementTag(int depth, Node node) {
-        Element element = (Element) node;
-        if (newlineBeforeElementOpen(element, depth)) {
-            mOut.append(mLineSeparator);
-        }
-        if (indentBeforeElementOpen(element, depth)) {
-            indent(depth);
-        }
-        mOut.append('<').append(element.getTagName());
-
-        NamedNodeMap attributes = element.getAttributes();
-        int attributeCount = attributes.getLength();
-        if (attributeCount > 0) {
-            // Sort the attributes
-            List<Attr> attributeList = new ArrayList<Attr>();
-            for (int i = 0, n = attributeCount; i < n; i++) {
-                attributeList.add((Attr) attributes.item(i));
-            }
-            Comparator<Attr> comparator = mPrefs.sortAttributes.getAttributeComparator();
-            Collections.sort(attributeList, comparator);
-
-            // Put the single attribute on the same line as the element tag?
-            boolean singleLine = mPrefs.oneAttributeOnFirstLine && attributeCount == 1
-                    // In resource files we always put all the attributes (which is
-                    // usually just zero, one or two) on the same line
-                    || mStyle == XmlFormatStyle.RESOURCE;
-
-            // We also place the namespace declaration on the same line as the root element,
-            // but this doesn't also imply singleLine handling; subsequent attributes end up
-            // on their own lines
-            boolean indentNextAttribute;
-            if (singleLine || (depth == 0 && XMLNS.equals(attributeList.get(0).getPrefix()))) {
-                mOut.append(' ');
-                indentNextAttribute = false;
-            } else {
-                mOut.append(mLineSeparator);
-                indentNextAttribute = true;
-            }
-
-            Attr last = attributeList.get(attributeCount - 1);
-            for (Attr attribute : attributeList) {
-                if (indentNextAttribute) {
-                    indent(depth + 1);
-                }
-                mOut.append(attribute.getName());
-                mOut.append('=').append('"');
-                XmlUtils.appendXmlAttributeValue(mOut, attribute.getValue());
-                mOut.append('"');
-
-                // Don't add a newline at the last attribute line; the > should
-                // immediately follow the last attribute
-                if (attribute != last) {
-                    mOut.append(singleLine ? " " : mLineSeparator); //$NON-NLS-1$
-                    indentNextAttribute = !singleLine;
-                }
-            }
-        }
-
-        boolean isClosed = isEmptyTag(element);
-
-        // Add a space before the > or /> ? In resource files, only do this when closing the
-        // element
-        if (mPrefs.spaceBeforeClose && (mStyle != XmlFormatStyle.RESOURCE || isClosed)
-                // in <selector> files etc still treat the <item> entries as in resource files
-                && !TAG_ITEM.equals(element.getTagName())
-                && (isClosed || element.getAttributes().getLength() > 0)) {
-            mOut.append(' ');
-        }
-
-        if (isClosed) {
-            mOut.append('/');
-        }
-
-        mOut.append('>');
-
-        if (newlineAfterElementOpen(element, depth, isClosed)) {
-            mOut.append(mLineSeparator);
-        }
-    }
-
-    private void printCloseElementTag(int depth, Node node) {
-        Element element = (Element) node;
-        if (isEmptyTag(element)) {
-            // Empty tag: Already handled as part of opening tag
-            return;
-        }
-
-        // Put the closing declaration on its own line - unless it's a compact
-        // resource file format
-        // If the element had element children, separate the end tag from them
-        if (newlineBeforeElementClose(element, depth)) {
-            mOut.append(mLineSeparator);
-        }
-        if (indentBeforeElementClose(element, depth)) {
-            indent(depth);
-        }
-        mOut.append('<').append('/');
-        mOut.append(node.getNodeName());
-        mOut.append('>');
-
-        if (newlineAfterElementClose(element, depth)) {
-            mOut.append(mLineSeparator);
-        }
-    }
-
-    private boolean newlineBeforeElementOpen(Element element, int depth) {
-        if (hasBlankLineAbove()) {
-            return false;
-        }
-
-        if (mPrefs.removeEmptyLines || depth <= 0) {
-            return false;
-        }
-
-        if (isMarkupElement(element)) {
-            return false;
-        }
-
-        // See if this element should be separated from the previous element.
-        // This is the case if we are not compressing whitespace (checked above),
-        // or if we are not immediately following a comment (in which case the
-        // newline would have been added above it), or if we are not in a formatting
-        // style where
-        if (mStyle == XmlFormatStyle.LAYOUT) {
-            // In layouts we always separate elements
-            return true;
-        }
-
-        if (mStyle == XmlFormatStyle.MANIFEST || mStyle == XmlFormatStyle.RESOURCE
-                || mStyle == XmlFormatStyle.FILE) {
-            Node curr = element.getPreviousSibling();
-
-            // <style> elements are traditionally separated unless it follows a comment
-            if (TAG_STYLE.equals(element.getTagName())) {
-                if (curr == null
-                        || curr.getNodeType() == Node.ELEMENT_NODE
-                        || (curr.getNodeType() == Node.TEXT_NODE
-                                && curr.getNodeValue().trim().length() == 0
-                                && (curr.getPreviousSibling() == null
-                                || curr.getPreviousSibling().getNodeType()
-                                        == Node.ELEMENT_NODE))) {
-                    return true;
-                }
-            }
-
-            // In all other styles, we separate elements if they have a different tag than
-            // the previous one (but we don't insert a newline inside tags)
-            while (curr != null) {
-                short nodeType = curr.getNodeType();
-                if (nodeType == Node.ELEMENT_NODE) {
-                    Element sibling = (Element) curr;
-                    if (!element.getTagName().equals(sibling.getTagName())) {
-                        return true;
-                    }
-                    break;
-                } else if (nodeType == Node.TEXT_NODE) {
-                    String text = curr.getNodeValue();
-                    if (text.trim().length() > 0) {
-                        break;
-                    }
-                    // If there is just whitespace, continue looking for a previous sibling
-                } else {
-                    // Any other previous node type, such as a comment, means we don't
-                    // continue looking: this element should not be separated
-                    break;
-                }
-                curr = curr.getPreviousSibling();
-            }
-            if (curr == null && depth <= 1) {
-                // Insert new line inside tag if it's the first element inside the root tag
-                return true;
-            }
-
-            return false;
-        }
-
-        return false;
-    }
-
-    private boolean indentBeforeElementOpen(Element element, int depth) {
-        if (isMarkupElement(element)) {
-            return false;
-        }
-
-        if (element.getParentNode().getNodeType() == Node.ELEMENT_NODE
-                && keepElementAsSingleLine(depth - 1, (Element) element.getParentNode())) {
-            return false;
-        }
-
-        return true;
-    }
-
-    private boolean indentBeforeElementClose(Element element, int depth) {
-        if (isMarkupElement(element)) {
-            return false;
-        }
-
-        char lastOutChar = mOut.charAt(mOut.length() - 1);
-        char lastDelimiterChar = mLineSeparator.charAt(mLineSeparator.length() - 1);
-        return lastOutChar == lastDelimiterChar;
-    }
-
-    private boolean newlineAfterElementOpen(Element element, int depth, boolean isClosed) {
-        if (hasBlankLineAbove()) {
-            return false;
-        }
-
-        if (isMarkupElement(element)) {
-            return false;
-        }
-
-        // In resource files we keep the child content directly on the same
-        // line as the element (unless it has children). in other files, separate them
-        return isClosed || !keepElementAsSingleLine(depth, element);
-    }
-
-    private boolean newlineBeforeElementClose(Element element, int depth) {
-        if (hasBlankLineAbove()) {
-            return false;
-        }
-
-        if (isMarkupElement(element)) {
-            return false;
-        }
-
-        return depth == 0 && !mPrefs.removeEmptyLines;
-    }
-
-    private boolean hasBlankLineAbove() {
-        if (mOut.length() < 2 * mLineSeparator.length()) {
-            return false;
-        }
-
-        return SdkUtils.endsWith(mOut, mLineSeparator) &&
-                SdkUtils.endsWith(mOut, mOut.length() - mLineSeparator.length(), mLineSeparator);
-    }
-
-    private boolean newlineAfterElementClose(Element element, int depth) {
-        if (hasBlankLineAbove()) {
-            return false;
-        }
-
-        if (isMarkupElement(element)) {
-            return false;
-        }
-
-        return element.getParentNode().getNodeType() == Node.ELEMENT_NODE
-                && !keepElementAsSingleLine(depth - 1, (Element) element.getParentNode());
-    }
-
-    private boolean isMarkupElement(Element element) {
-        // The documentation suggests that the allowed tags are <u>, <b> and <i>:
-        //   developer.android.com/guide/topics/resources/string-resource.html#FormattingAndStyling
-        // However, the full set of tags accepted by Html.fromHtml is much larger. Therefore,
-        // instead consider *any* element nested inside a <string> definition to be a markup
-        // element. See frameworks/base/core/java/android/text/Html.java and look for
-        // HtmlToSpannedConverter#handleStartTag.
-
-        if (mStyle != XmlFormatStyle.RESOURCE) {
-            return false;
-        }
-
-        Node curr = element.getParentNode();
-        while (curr != null) {
-            if (TAG_STRING.equals(curr.getNodeName())) {
-                return true;
-            }
-
-            curr = curr.getParentNode();
-        }
-
-        return false;
-    }
-
-    /**
-     * TODO: Explain why we need to do per-tag decisions on whether to keep them on the
-     * same line or not. Show that we can't just do it by depth, or by file type.
-     * (style versus plurals example)
-     * @param tag
-     * @return
-     */
-    private boolean isSingleLineTag(Element element) {
-        String tag = element.getTagName();
-
-        return (tag.equals(TAG_ITEM) && mStyle == XmlFormatStyle.RESOURCE)
-                || tag.equals(TAG_STRING)
-                || tag.equals(TAG_DIMEN)
-                || tag.equals(TAG_COLOR);
-    }
-
-    private boolean keepElementAsSingleLine(int depth, Element element) {
-        if (depth == 0) {
-            return false;
-        }
-
-        return isSingleLineTag(element)
-                || (mStyle == XmlFormatStyle.RESOURCE
-                    && !DomUtilities.hasElementChildren(element));
-    }
-
-    private void indent(int depth) {
-        int i = 0;
-
-        if (mIndentationLevels != null) {
-            for (int j = Math.min(depth, mIndentationLevels.length - 1); j >= 0; j--) {
-                String indent = mIndentationLevels[j];
-                if (indent != null) {
-                    mOut.append(indent);
-                    i = j;
-                    break;
-                }
-            }
-        }
-
-        for (; i < depth; i++) {
-            mOut.append(mIndentString);
-        }
-    }
-
-    private boolean isEmptyTag(Element element) {
-        boolean isClosed = false;
-        if (element instanceof ElementImpl) {
-            ElementImpl elementImpl = (ElementImpl) element;
-            if (elementImpl.isEmptyTag()) {
-                isClosed = true;
-            }
-        }
-        return isClosed;
-    }
-}
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/RenderPreviewList.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/RenderPreviewList.java
index 05f1005..d3c4fab 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/RenderPreviewList.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/gle2/RenderPreviewList.java
@@ -18,7 +18,7 @@
 import com.android.annotations.NonNull;
 import com.android.ide.eclipse.adt.AdtPlugin;
 import com.android.ide.eclipse.adt.AdtUtils;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlPrettyPrinter;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlPrettyPrinter;
 import com.android.ide.eclipse.adt.internal.editors.layout.configuration.Configuration;
 import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationChooser;
 import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationDescription;
@@ -107,7 +107,7 @@
             for (ConfigurationDescription description : mList) {
                 description.toXml(document);
             }
-            String xml = XmlPrettyPrinter.prettyPrint(document);
+            String xml = EclipseXmlPrettyPrinter.prettyPrint(document);
             Files.write(xml, file, Charsets.UTF_8);
         }
     }
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/ChangeLayoutRefactoring.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/ChangeLayoutRefactoring.java
index b01b4b1..d8c85aa 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/ChangeLayoutRefactoring.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/ChangeLayoutRefactoring.java
@@ -41,9 +41,9 @@
 import com.android.SdkConstants;
 import com.android.annotations.NonNull;
 import com.android.annotations.VisibleForTesting;
+import com.android.ide.common.xml.XmlFormatStyle;
 import com.android.ide.eclipse.adt.AdtPlugin;
 import com.android.ide.eclipse.adt.internal.editors.descriptors.AttributeDescriptor;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatStyle;
 import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate;
 import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.ViewElementDescriptor;
 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.CanvasViewInfo;
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/ExtractIncludeRefactoring.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/ExtractIncludeRefactoring.java
index 65edd54..f58ac55 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/ExtractIncludeRefactoring.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/ExtractIncludeRefactoring.java
@@ -37,10 +37,10 @@
 
 import com.android.annotations.NonNull;
 import com.android.annotations.VisibleForTesting;
+import com.android.ide.common.xml.XmlFormatStyle;
 import com.android.ide.eclipse.adt.AdtPlugin;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatPreferences;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatStyle;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlPrettyPrinter;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlFormatPreferences;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlPrettyPrinter;
 import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate;
 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.CanvasViewInfo;
 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.DomUtilities;
@@ -330,8 +330,9 @@
 
         String newFile = sb.toString();
         if (AdtPrefs.getPrefs().getFormatGuiXml()) {
-            newFile = XmlPrettyPrinter.prettyPrint(newFile,
-                    XmlFormatPreferences.create(), XmlFormatStyle.LAYOUT, null /*lineSeparator*/);
+            newFile = EclipseXmlPrettyPrinter.prettyPrint(newFile,
+                    EclipseXmlFormatPreferences.create(), XmlFormatStyle.LAYOUT,
+                    null /*lineSeparator*/);
         }
         addFile.setEdit(new InsertEdit(0, newFile));
 
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/ExtractStyleRefactoring.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/ExtractStyleRefactoring.java
index ffe6892..9b1770d 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/ExtractStyleRefactoring.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/ExtractStyleRefactoring.java
@@ -43,10 +43,10 @@
 import com.android.annotations.VisibleForTesting;
 import com.android.ide.common.rendering.api.ResourceValue;
 import com.android.ide.common.resources.ResourceResolver;
+import com.android.ide.common.xml.XmlFormatStyle;
 import com.android.ide.eclipse.adt.AdtPlugin;
 import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor;
 import com.android.ide.eclipse.adt.internal.editors.descriptors.DescriptorsUtils;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatStyle;
 import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate;
 import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs;
 import com.android.ide.eclipse.adt.internal.wizards.newxmlfile.NewXmlFileWizard;
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/RelativeLayoutConversionHelper.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/RelativeLayoutConversionHelper.java
index 7f9cc71..e0d6313 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/RelativeLayoutConversionHelper.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/RelativeLayoutConversionHelper.java
@@ -15,15 +15,7 @@
  */
 package com.android.ide.eclipse.adt.internal.editors.layout.refactoring;
 
-import static com.android.ide.common.layout.GravityHelper.GRAVITY_BOTTOM;
-import static com.android.ide.common.layout.GravityHelper.GRAVITY_CENTER_HORIZ;
-import static com.android.ide.common.layout.GravityHelper.GRAVITY_CENTER_VERT;
-import static com.android.ide.common.layout.GravityHelper.GRAVITY_FILL_HORIZ;
-import static com.android.ide.common.layout.GravityHelper.GRAVITY_FILL_VERT;
-import static com.android.ide.common.layout.GravityHelper.GRAVITY_LEFT;
-import static com.android.ide.common.layout.GravityHelper.GRAVITY_RIGHT;
-import static com.android.ide.common.layout.GravityHelper.GRAVITY_TOP;
-import static com.android.ide.common.layout.GravityHelper.GRAVITY_VERT_MASK;
+import static com.android.SdkConstants.ANDROID_URI;
 import static com.android.SdkConstants.ATTR_BACKGROUND;
 import static com.android.SdkConstants.ATTR_BASELINE_ALIGNED;
 import static com.android.SdkConstants.ATTR_LAYOUT_ABOVE;
@@ -58,10 +50,16 @@
 import static com.android.SdkConstants.VALUE_TRUE;
 import static com.android.SdkConstants.VALUE_VERTICAL;
 import static com.android.SdkConstants.VALUE_WRAP_CONTENT;
+import static com.android.ide.common.layout.GravityHelper.GRAVITY_BOTTOM;
+import static com.android.ide.common.layout.GravityHelper.GRAVITY_CENTER_HORIZ;
+import static com.android.ide.common.layout.GravityHelper.GRAVITY_CENTER_VERT;
+import static com.android.ide.common.layout.GravityHelper.GRAVITY_FILL_HORIZ;
+import static com.android.ide.common.layout.GravityHelper.GRAVITY_FILL_VERT;
+import static com.android.ide.common.layout.GravityHelper.GRAVITY_LEFT;
+import static com.android.ide.common.layout.GravityHelper.GRAVITY_RIGHT;
+import static com.android.ide.common.layout.GravityHelper.GRAVITY_TOP;
+import static com.android.ide.common.layout.GravityHelper.GRAVITY_VERT_MASK;
 
-
-import com.android.SdkConstants;
-import static com.android.SdkConstants.ANDROID_URI;
 import com.android.ide.common.layout.GravityHelper;
 import com.android.ide.eclipse.adt.AdtPlugin;
 import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescriptor;
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/UnwrapRefactoring.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/UnwrapRefactoring.java
index 1dcc1b7..4eff2cd 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/UnwrapRefactoring.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/UnwrapRefactoring.java
@@ -22,7 +22,7 @@
 
 import com.android.annotations.NonNull;
 import com.android.annotations.VisibleForTesting;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatStyle;
+import com.android.ide.common.xml.XmlFormatStyle;
 import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate;
 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.DomUtilities;
 
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/UseCompoundDrawableRefactoring.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/UseCompoundDrawableRefactoring.java
index b96d31a..a775686 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/UseCompoundDrawableRefactoring.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/UseCompoundDrawableRefactoring.java
@@ -42,10 +42,10 @@
 import com.android.annotations.NonNull;
 import com.android.annotations.Nullable;
 import com.android.annotations.VisibleForTesting;
+import com.android.ide.common.xml.XmlFormatStyle;
 import com.android.ide.eclipse.adt.AdtUtils;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatPreferences;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatStyle;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlPrettyPrinter;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlFormatPreferences;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlPrettyPrinter;
 import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate;
 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.CanvasViewInfo;
 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.DomUtilities;
@@ -353,8 +353,9 @@
             }
         }
 
-        String xml = XmlPrettyPrinter.prettyPrint(tempDocument.getDocumentElement(),
-                XmlFormatPreferences.create(),
+        String xml = EclipseXmlPrettyPrinter.prettyPrint(
+                tempDocument.getDocumentElement(),
+                EclipseXmlFormatPreferences.create(),
                 XmlFormatStyle.LAYOUT, null);
 
         TextEdit replace = new ReplaceEdit(mSelectionStart, mSelectionEnd - mSelectionStart, xml);
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/VisualRefactoring.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/VisualRefactoring.java
index 5939a8a..904a3a0 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/VisualRefactoring.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/VisualRefactoring.java
@@ -29,11 +29,11 @@
 
 import com.android.annotations.NonNull;
 import com.android.annotations.VisibleForTesting;
+import com.android.ide.common.xml.XmlFormatStyle;
 import com.android.ide.eclipse.adt.AdtPlugin;
 import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatPreferences;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatStyle;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlPrettyPrinter;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlFormatPreferences;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlPrettyPrinter;
 import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate;
 import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationDescription;
 import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.ViewElementDescriptor;
@@ -1312,8 +1312,8 @@
         //int end = actual.length() - distanceFromEnd;
         //int length = end - start;
         //TextEdit format = AndroidXmlFormattingStrategy.format(model, start, length);
-        XmlFormatPreferences formatPrefs = XmlFormatPreferences.create();
-        String formatted = XmlPrettyPrinter.prettyPrint(actual, formatPrefs, style,
+        EclipseXmlFormatPreferences formatPrefs = EclipseXmlFormatPreferences.create();
+        String formatted = EclipseXmlPrettyPrinter.prettyPrint(actual, formatPrefs, style,
                 null /*lineSeparator*/);
 
 
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/WrapInRefactoring.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/WrapInRefactoring.java
index ff2e9bd..07b00b8 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/WrapInRefactoring.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/refactoring/WrapInRefactoring.java
@@ -28,8 +28,8 @@
 
 import com.android.annotations.NonNull;
 import com.android.annotations.VisibleForTesting;
+import com.android.ide.common.xml.XmlFormatStyle;
 import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatStyle;
 import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate;
 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.CanvasViewInfo;
 import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs;
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/uimodel/UiAttributeNode.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/uimodel/UiAttributeNode.java
index 71cb35d..ffe637c 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/uimodel/UiAttributeNode.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/uimodel/UiAttributeNode.java
@@ -16,17 +16,7 @@
 
 package com.android.ide.eclipse.adt.internal.editors.uimodel;
 
-import static com.android.SdkConstants.ATTR_ID;
-import static com.android.SdkConstants.ATTR_LAYOUT_HEIGHT;
-import static com.android.SdkConstants.ATTR_LAYOUT_RESOURCE_PREFIX;
-import static com.android.SdkConstants.ATTR_LAYOUT_WIDTH;
-import static com.android.SdkConstants.ATTR_NAME;
-import static com.android.SdkConstants.ATTR_STYLE;
-import static com.android.ide.eclipse.adt.internal.editors.color.ColorDescriptors.ATTR_COLOR;
-import static com.google.common.base.Strings.nullToEmpty;
-
-import com.android.annotations.NonNull;
-import com.android.annotations.Nullable;
+import com.android.ide.common.xml.XmlAttributeSortOrder;
 import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor;
 import com.android.ide.eclipse.adt.internal.editors.descriptors.AttributeDescriptor;
 
@@ -34,8 +24,6 @@
 import org.eclipse.ui.forms.IManagedForm;
 import org.w3c.dom.Node;
 
-import java.util.Comparator;
-
 /**
  * Represents an XML attribute that can be modified by the XML editor's user interface.
  * <p/>
@@ -177,107 +165,10 @@
     public abstract void commit();
 
     // ---- Implements Comparable ----
+
     @Override
     public int compareTo(UiAttributeNode o) {
-        return compareAttributes(mDescriptor.getXmlLocalName(), o.mDescriptor.getXmlLocalName());
-    }
-
-    /**
-     * Returns {@link Comparator} values for ordering attributes in the following
-     * order:
-     * <ul>
-     *   <li> id
-     *   <li> style
-     *   <li> layout_width
-     *   <li> layout_height
-     *   <li> other layout params, sorted alphabetically
-     *   <li> other attributes, sorted alphabetically
-     * </ul>
-     *
-     * @param name1 the first attribute name to compare
-     * @param name2 the second attribute name to compare
-     * @return a negative number if name1 should be ordered before name2
-     */
-    public static int compareAttributes(String name1, String name2) {
-        int priority1 = getAttributePriority(name1);
-        int priority2 = getAttributePriority(name2);
-        if (priority1 != priority2) {
-            return priority1 - priority2;
-        }
-
-        // Sort remaining attributes alphabetically
-        return name1.compareTo(name2);
-    }
-
-    /**
-     * Returns {@link Comparator} values for ordering attributes in the following
-     * order:
-     * <ul>
-     *   <li> id
-     *   <li> style
-     *   <li> layout_width
-     *   <li> layout_height
-     *   <li> other layout params, sorted alphabetically
-     *   <li> other attributes, sorted alphabetically, first by namespace, then by name
-     * </ul>
-     * @param prefix1 the namespace prefix, if any, of {@code name1}
-     * @param name1 the first attribute name to compare
-     * @param prefix2  the namespace prefix, if any, of {@code name2}
-     * @param name2 the second attribute name to compare
-     * @return a negative number if name1 should be ordered before name2
-     */
-    public static int compareAttributes(
-            @Nullable String prefix1, @NonNull String name1,
-            @Nullable String prefix2, @NonNull String name2) {
-        int priority1 = getAttributePriority(name1);
-        int priority2 = getAttributePriority(name2);
-        if (priority1 != priority2) {
-            return priority1 - priority2;
-        }
-
-        int namespaceDelta = nullToEmpty(prefix1).compareTo(nullToEmpty(prefix2));
-        if (namespaceDelta != 0) {
-            return namespaceDelta;
-        }
-
-        // Sort remaining attributes alphabetically
-        return name1.compareTo(name2);
-    }
-
-
-    /** Returns a sorting priority for the given attribute name */
-    private static int getAttributePriority(String name) {
-        if (ATTR_ID.equals(name)) {
-            return 10;
-        }
-
-        if (ATTR_NAME.equals(name)) {
-            return 15;
-        }
-
-        if (ATTR_STYLE.equals(name)) {
-            return 20;
-        }
-
-        if (name.startsWith(ATTR_LAYOUT_RESOURCE_PREFIX)) {
-            // Width and height are special cased because we (a) want width and height
-            // before the other layout attributes, and (b) we want width to sort before height
-            // even though it comes after it alphabetically.
-            if (name.equals(ATTR_LAYOUT_WIDTH)) {
-                return 30;
-            }
-            if (name.equals(ATTR_LAYOUT_HEIGHT)) {
-                return 40;
-            }
-
-            return 50;
-        }
-
-        // "color" sorts to the end
-        if (ATTR_COLOR.equals(name)) {
-            return 100;
-        }
-
-        return 60;
+        return XmlAttributeSortOrder.compareAttributes(mDescriptor.getXmlLocalName(),
+                o.mDescriptor.getXmlLocalName());
     }
 }
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/uimodel/UiElementNode.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/uimodel/UiElementNode.java
index f905c73..ed447c6 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/uimodel/UiElementNode.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/uimodel/UiElementNode.java
@@ -26,6 +26,7 @@
 import com.android.annotations.VisibleForTesting;
 import com.android.ide.common.api.IAttributeInfo.Format;
 import com.android.ide.common.resources.platform.AttributeInfo;
+import com.android.ide.common.xml.XmlAttributeSortOrder;
 import com.android.ide.eclipse.adt.AdtPlugin;
 import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor;
 import com.android.ide.eclipse.adt.internal.editors.descriptors.AttributeDescriptor;
@@ -1663,7 +1664,7 @@
             List<Attr> move = new ArrayList<Attr>();
             for (int i = 0, n = attributes.getLength(); i < n; i++) {
                 Attr attribute = (Attr) attributes.item(i);
-                if (UiAttributeNode.compareAttributes(
+                if (XmlAttributeSortOrder.compareAttributes(
                         attribute.getPrefix(), attribute.getLocalName(),
                         firstNamePrefix, firstName) > 0) {
                     move.add(attribute);
@@ -1699,7 +1700,7 @@
 
                         String domAttributeName = domAttribute.getLocalName();
                         String uiAttributeName = uiAttribute.getDescriptor().getXmlLocalName();
-                        compare = UiAttributeNode.compareAttributes(domAttributeName,
+                        compare = XmlAttributeSortOrder.compareAttributes(domAttributeName,
                                 uiAttributeName);
                     } else {
                         compare = 1;
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/preferences/AdtPrefs.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/preferences/AdtPrefs.java
index 800828c..aed4bd4 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/preferences/AdtPrefs.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/preferences/AdtPrefs.java
@@ -18,9 +18,9 @@
 
 
 import com.android.annotations.NonNull;
+import com.android.ide.common.xml.XmlAttributeSortOrder;
 import com.android.ide.eclipse.adt.AdtPlugin;
 import com.android.ide.eclipse.adt.internal.editors.AndroidXmlEditor;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatStyle;
 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.RenderPreviewMode;
 import com.android.prefs.AndroidLocation.AndroidLocationException;
 import com.android.sdklib.internal.build.DebugKeyProvider;
@@ -104,7 +104,7 @@
     private boolean mFormatOnSave;
     private boolean mLintOnSave;
     private boolean mLintOnExport;
-    private AttributeSortOrder mAttributeSort;
+    private XmlAttributeSortOrder mAttributeSort;
     private boolean mSharedLayoutEditor;
     private boolean mAutoPickTarget;
     private RenderPreviewMode mPreviewMode = RenderPreviewMode.NONE;
@@ -236,11 +236,11 @@
 
         if (property == null || PREFS_ATTRIBUTE_SORT.equals(property)) {
             String order = mStore.getString(PREFS_ATTRIBUTE_SORT);
-            mAttributeSort = AttributeSortOrder.LOGICAL;
-            if (AttributeSortOrder.ALPHABETICAL.key.equals(order)) {
-                mAttributeSort = AttributeSortOrder.ALPHABETICAL;
-            } else if (AttributeSortOrder.NO_SORTING.key.equals(order)) {
-                mAttributeSort = AttributeSortOrder.NO_SORTING;
+            mAttributeSort = XmlAttributeSortOrder.LOGICAL;
+            if (XmlAttributeSortOrder.ALPHABETICAL.key.equals(order)) {
+                mAttributeSort = XmlAttributeSortOrder.ALPHABETICAL;
+            } else if (XmlAttributeSortOrder.NO_SORTING.key.equals(order)) {
+                mAttributeSort = XmlAttributeSortOrder.NO_SORTING;
             }
         }
 
@@ -359,13 +359,13 @@
 
     /**
      * Returns the sort order to be applied to the attributes (one of which can
-     * be {@link AttributeSortOrder#NO_SORTING}).
+     * be {@link com.android.ide.common.xml.XmlAttributeSortOrder#NO_SORTING}).
      *
      * @return the sort order to apply to the attributes
      */
-    public AttributeSortOrder getAttributeSort() {
+    public XmlAttributeSortOrder getAttributeSort() {
         if (mAttributeSort == null) {
-            return AttributeSortOrder.LOGICAL;
+            return XmlAttributeSortOrder.LOGICAL;
         }
         return mAttributeSort;
     }
@@ -373,7 +373,7 @@
     /**
      * Returns whether a space should be inserted before the closing {@code >}
      * character in open tags and before the closing {@code />} characters in
-     * empty tag. Note that the {@link XmlFormatStyle#RESOURCE} style overrides
+     * empty tag. Note that the {@link com.android.ide.common.xml.XmlFormatStyle#RESOURCE} style overrides
      * this setting to make it more compact for the {@code <item>} elements.
      *
      * @return true if an empty space should be inserted before {@code >} or
@@ -517,7 +517,7 @@
         store.setDefault(PREFS_AUTO_PICK_TARGET, true);
 
         // Defaults already handled; no need to write into map:
-        //store.setDefault(PREFS_ATTRIBUTE_SORT, AttributeSortOrder.LOGICAL.key);
+        //store.setDefault(PREFS_ATTRIBUTE_SORT, XmlAttributeSortOrder.LOGICAL.key);
         //store.setDefault(PREFS_USE_ECLIPSE_INDENT, false);
         //store.setDefault(PREVS_REMOVE_EMPTY_LINES, false);
         //store.setDefault(PREFS_FORMAT_ON_SAVE, false);
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/preferences/AttributeSortOrder.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/preferences/AttributeSortOrder.java
deleted file mode 100644
index b743014..0000000
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/preferences/AttributeSortOrder.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright (C) 2011 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.preferences;
-
-import static com.android.SdkConstants.XMLNS;
-
-import com.android.ide.eclipse.adt.internal.editors.uimodel.UiAttributeNode;
-
-import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
-import org.w3c.dom.Attr;
-
-import java.util.Comparator;
-
-/** Order to use when sorting attributes */
-@SuppressWarnings("restriction") // IndexedRegion
-public enum AttributeSortOrder {
-    NO_SORTING("none"),     //$NON-NLS-1$
-    ALPHABETICAL("alpha"),  //$NON-NLS-1$
-    LOGICAL("logical");     //$NON-NLS-1$
-
-    AttributeSortOrder(String key) {
-        this.key = key;
-    }
-
-    public final String key;
-
-    /**
-     * @return a comparator for use by this attribute sort order
-     */
-    public Comparator<Attr> getAttributeComparator() {
-        switch (this) {
-            case ALPHABETICAL:
-                return ALPHABETICAL_COMPARATOR;
-            case NO_SORTING:
-                return EXISTING_ORDER_COMPARATOR;
-            case LOGICAL:
-            default:
-                return SORTED_ORDER_COMPARATOR;
-        }
-    }
-
-    /** Comparator which can be used to sort attributes in the coding style priority order */
-    private static final Comparator<Attr> SORTED_ORDER_COMPARATOR = new Comparator<Attr>() {
-        @Override
-        public int compare(Attr attr1, Attr attr2) {
-            // Namespace declarations should always go first
-            if (XMLNS.equals(attr1.getPrefix())) {
-                if (XMLNS.equals(attr2.getPrefix())) {
-                    return 0;
-                }
-                return -1;
-            } else if (XMLNS.equals(attr2.getPrefix())) {
-                return 1;
-            }
-
-            // Sort by preferred attribute order
-            return UiAttributeNode.compareAttributes(
-                    attr1.getPrefix(), attr1.getLocalName(),
-                    attr2.getPrefix(), attr2.getLocalName());
-        }
-    };
-
-    /**
-     * Comparator which can be used to "sort" attributes into their existing source order
-     * (which is not the same as the node map iteration order in the DOM model)
-     */
-    private static final Comparator<Attr> EXISTING_ORDER_COMPARATOR = new Comparator<Attr>() {
-        @Override
-        public int compare(Attr attr1, Attr attr2) {
-            IndexedRegion region1 = (IndexedRegion) attr1;
-            IndexedRegion region2 = (IndexedRegion) attr2;
-
-            return region1.getStartOffset() - region2.getStartOffset();
-        }
-    };
-
-    /**
-     * Comparator which can be used to sort attributes into alphabetical order (but xmlns
-     * is always first)
-     */
-    private static final Comparator<Attr> ALPHABETICAL_COMPARATOR = new Comparator<Attr>() {
-        @Override
-        public int compare(Attr attr1, Attr attr2) {
-            // Namespace declarations should always go first
-            if (XMLNS.equals(attr1.getPrefix())) {
-                if (XMLNS.equals(attr2.getPrefix())) {
-                    return 0;
-                }
-                return -1;
-            } else if (XMLNS.equals(attr2.getPrefix())) {
-                return 1;
-            }
-
-            // Sort by name rather than localname to ensure we sort by namespaces first,
-            // then by names.
-            return attr1.getName().compareTo(attr2.getName());
-        }
-    };
-}
\ No newline at end of file
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/preferences/EditorsPage.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/preferences/EditorsPage.java
index 0fcbaa0..d33b49f 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/preferences/EditorsPage.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/preferences/EditorsPage.java
@@ -16,9 +16,9 @@
 
 package com.android.ide.eclipse.adt.internal.preferences;
 
-import static com.android.ide.eclipse.adt.internal.preferences.AttributeSortOrder.ALPHABETICAL;
-import static com.android.ide.eclipse.adt.internal.preferences.AttributeSortOrder.LOGICAL;
-import static com.android.ide.eclipse.adt.internal.preferences.AttributeSortOrder.NO_SORTING;
+import static com.android.ide.common.xml.XmlAttributeSortOrder.ALPHABETICAL;
+import static com.android.ide.common.xml.XmlAttributeSortOrder.LOGICAL;
+import static com.android.ide.common.xml.XmlAttributeSortOrder.NO_SORTING;
 
 import com.android.ide.eclipse.adt.AdtPlugin;
 import com.android.sdkuilib.internal.widgets.ResolutionChooserDialog;
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/wizards/newproject/NewProjectCreator.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/wizards/newproject/NewProjectCreator.java
index 19a7101..eea9d36 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/wizards/newproject/NewProjectCreator.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/wizards/newproject/NewProjectCreator.java
@@ -25,12 +25,12 @@
 import com.android.annotations.Nullable;
 import com.android.ide.common.resources.ValueResourceParser;
 import com.android.ide.common.xml.ManifestData;
+import com.android.ide.common.xml.XmlFormatStyle;
 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.formatting.XmlFormatPreferences;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatStyle;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlPrettyPrinter;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlFormatPreferences;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlPrettyPrinter;
 import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs;
 import com.android.ide.eclipse.adt.internal.project.AndroidNature;
 import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper;
@@ -1088,8 +1088,8 @@
     /** Reformats the given contents with the current formatting settings */
     private String reformat(XmlFormatStyle style, String contents) {
         if (AdtPrefs.getPrefs().getUseCustomXmlFormatter()) {
-            XmlFormatPreferences formatPrefs = XmlFormatPreferences.create();
-            return XmlPrettyPrinter.prettyPrint(contents, formatPrefs, style,
+            EclipseXmlFormatPreferences formatPrefs = EclipseXmlFormatPreferences.create();
+            return EclipseXmlPrettyPrinter.prettyPrint(contents, formatPrefs, style,
                     null /*lineSeparator*/);
         } else {
             return contents;
@@ -1404,7 +1404,8 @@
 
         if (reformat) {
             // Guess the formatting style based on the file location
-            XmlFormatStyle style = XmlFormatStyle.getForFile(destFile.getProjectRelativePath());
+            XmlFormatStyle style = EclipseXmlPrettyPrinter
+                    .getForFile(destFile.getProjectRelativePath());
             if (style != null) {
                 template = reformat(style, template);
             }
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/wizards/newxmlfile/NewXmlFileWizard.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/wizards/newxmlfile/NewXmlFileWizard.java
index 33b22b4..16cd7b3 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/wizards/newxmlfile/NewXmlFileWizard.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/wizards/newxmlfile/NewXmlFileWizard.java
@@ -21,13 +21,13 @@
 
 import com.android.SdkConstants;
 import com.android.ide.common.resources.configuration.FolderConfiguration;
+import com.android.ide.common.xml.XmlFormatStyle;
 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.IconFactory;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatPreferences;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatStyle;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlPrettyPrinter;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlFormatPreferences;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlPrettyPrinter;
 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.RenderPreviewManager;
 import com.android.ide.eclipse.adt.internal.editors.manifest.ManifestInfo;
 import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs;
@@ -250,14 +250,14 @@
 
         sb.append("</").append(root).append(">\n");  //$NON-NLS-1$ //$NON-NLS-2$
 
-        XmlFormatPreferences formatPrefs = XmlFormatPreferences.create();
+        EclipseXmlFormatPreferences formatPrefs = EclipseXmlFormatPreferences.create();
         String fileContents;
         if (!autoFormat) {
             fileContents = sb.toString();
         } else {
-            XmlFormatStyle style = XmlFormatStyle.getForFolderType(folderType);
-            fileContents = XmlPrettyPrinter.prettyPrint(sb.toString(), formatPrefs,
-                                style, null /*lineSeparator*/);
+            XmlFormatStyle style = EclipseXmlPrettyPrinter.getForFolderType(folderType);
+            fileContents = EclipseXmlPrettyPrinter.prettyPrint(sb.toString(), formatPrefs,
+                    style, null /*lineSeparator*/);
         }
 
         // Remove marker tokens and replace them with whitespace
diff --git a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/wizards/templates/TemplateHandler.java b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/wizards/templates/TemplateHandler.java
index 8c310ec..eb3d94a 100644
--- a/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/wizards/templates/TemplateHandler.java
+++ b/eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/wizards/templates/TemplateHandler.java
@@ -33,12 +33,12 @@
 import com.android.annotations.NonNull;
 import com.android.annotations.Nullable;
 import com.android.annotations.VisibleForTesting;
+import com.android.ide.common.xml.XmlFormatStyle;
 import com.android.ide.eclipse.adt.AdtPlugin;
 import com.android.ide.eclipse.adt.AdtUtils;
 import com.android.ide.eclipse.adt.internal.actions.AddSupportJarAction;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatPreferences;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatStyle;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlPrettyPrinter;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlFormatPreferences;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlPrettyPrinter;
 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.DomUtilities;
 import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper;
 import com.android.ide.eclipse.adt.internal.sdk.AdtManifestMergeCallback;
@@ -692,7 +692,7 @@
             String parentFolderName = to.getParent().getName();
             ResourceFolderType folderType = ResourceFolderType.getFolderType(parentFolderName);
             if (folderType != null) {
-                formatStyle = XmlFormatStyle.getForFile(toPath);
+                formatStyle = EclipseXmlPrettyPrinter.getForFile(toPath);
             } else {
                 formatStyle = XmlFormatStyle.FILE;
             }
@@ -705,8 +705,8 @@
         String contents = null;
         if (ok) {
             if (modified) {
-                contents = XmlPrettyPrinter.prettyPrint(currentDocument,
-                        XmlFormatPreferences.create(), formatStyle, null);
+                contents = EclipseXmlPrettyPrinter.prettyPrint(currentDocument,
+                        EclipseXmlFormatPreferences.create(), formatStyle, null);
             }
         } else {
             // Just insert into file along with comment, using the "standard" conflict
@@ -914,9 +914,9 @@
     private static String format(IProject project, String contents, IPath to) {
         String name = to.lastSegment();
         if (name.endsWith(DOT_XML)) {
-            XmlFormatStyle formatStyle = XmlFormatStyle.getForFile(to);
-            XmlFormatPreferences prefs = XmlFormatPreferences.create();
-            return XmlPrettyPrinter.prettyPrint(contents, prefs, formatStyle, null);
+            XmlFormatStyle formatStyle = EclipseXmlPrettyPrinter.getForFile(to);
+            EclipseXmlFormatPreferences prefs = EclipseXmlFormatPreferences.create();
+            return EclipseXmlPrettyPrinter.prettyPrint(contents, prefs, formatStyle, null);
         } else if (name.endsWith(DOT_JAVA)) {
             Map<?, ?> options = null;
             if (project != null && project.isAccessible()) {
diff --git a/eclipse/plugins/com.android.ide.eclipse.tests/src/com/android/ide/eclipse/adt/internal/editors/formatting/XmlPrettyPrinterTest.java b/eclipse/plugins/com.android.ide.eclipse.tests/src/com/android/ide/eclipse/adt/internal/editors/formatting/EclipseXmlPrettyPrinterTest.java
similarity index 95%
rename from eclipse/plugins/com.android.ide.eclipse.tests/src/com/android/ide/eclipse/adt/internal/editors/formatting/XmlPrettyPrinterTest.java
rename to eclipse/plugins/com.android.ide.eclipse.tests/src/com/android/ide/eclipse/adt/internal/editors/formatting/EclipseXmlPrettyPrinterTest.java
index 731621c..0e86736 100644
--- a/eclipse/plugins/com.android.ide.eclipse.tests/src/com/android/ide/eclipse/adt/internal/editors/formatting/XmlPrettyPrinterTest.java
+++ b/eclipse/plugins/com.android.ide.eclipse.tests/src/com/android/ide/eclipse/adt/internal/editors/formatting/EclipseXmlPrettyPrinterTest.java
@@ -15,6 +15,7 @@
  */
 package com.android.ide.eclipse.adt.internal.editors.formatting;
 
+import com.android.ide.common.xml.XmlFormatStyle;
 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.DomUtilities;
 import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs;
 
@@ -28,9 +29,9 @@
 import junit.framework.TestCase;
 
 @SuppressWarnings({
-    "javadoc", "restriction"
+        "javadoc", "restriction"
 })
-public class XmlPrettyPrinterTest extends TestCase {
+public class EclipseXmlPrettyPrinterTest extends TestCase {
     @Override
     protected void setUp() throws Exception {
         super.setUp();
@@ -39,11 +40,11 @@
         AdtPrefs prefs = AdtPrefs.getPrefs();
         prefs.initializeStoreWithDefaults(store);
         prefs.loadValues(null);
-        XmlFormatPreferences formatPrefs = XmlFormatPreferences.create();
+        EclipseXmlFormatPreferences formatPrefs = EclipseXmlFormatPreferences.create();
         assertTrue(formatPrefs.oneAttributeOnFirstLine);
     }
 
-    private void checkFormat(XmlFormatPreferences prefs, String baseLocation,
+    private void checkFormat(EclipseXmlFormatPreferences prefs, String baseLocation,
             String xml,
             String expected, String delimiter, String startNodeName,
             boolean openTagOnly, String endNodeName) throws Exception {
@@ -61,7 +62,7 @@
         }
         XmlFormatStyle style = AndroidXmlFormattingStrategy.guessStyle(model, document);
 
-        XmlPrettyPrinter printer = new XmlPrettyPrinter(prefs, style, delimiter);
+        EclipseXmlPrettyPrinter printer = new EclipseXmlPrettyPrinter(prefs, style, delimiter);
 
         StringBuilder sb = new StringBuilder(1000);
         Node startNode = document;
@@ -110,18 +111,18 @@
         return caretContextIndex + caretDelta;
     }
 
-    private void checkFormat(XmlFormatPreferences prefs, String baseLocation, String xml,
+    private void checkFormat(EclipseXmlFormatPreferences prefs, String baseLocation, String xml,
             String expected, String delimiter) throws Exception {
         checkFormat(prefs, baseLocation, xml, expected, delimiter, null, false, null);
     }
 
-    private void checkFormat(XmlFormatPreferences prefs, String baseLocation, String xml,
+    private void checkFormat(EclipseXmlFormatPreferences prefs, String baseLocation, String xml,
             String expected) throws Exception {
         checkFormat(prefs, baseLocation, xml, expected, "\n"); //$NON-NLS-1$
     }
     private void checkFormat(String baseLocation, String xml, String expected)
             throws Exception {
-        XmlFormatPreferences prefs = XmlFormatPreferences.create();
+        EclipseXmlFormatPreferences prefs = EclipseXmlFormatPreferences.create();
         checkFormat(prefs, baseLocation, xml, expected);
     }
 
@@ -152,7 +153,7 @@
     }
 
     public void testLayout3() throws Exception {
-        XmlFormatPreferences prefs = XmlFormatPreferences.create();
+        EclipseXmlFormatPreferences prefs = EclipseXmlFormatPreferences.create();
         prefs.oneAttributeOnFirstLine = true;
         checkFormat(
                 prefs, "res/layout-land/layout3.xml",
@@ -252,7 +253,7 @@
 
     public void testWindowsDelimiters() throws Exception {
         checkFormat(
-                XmlFormatPreferences.create(), "res/layout-xlarge/layout.xml",
+                EclipseXmlFormatPreferences.create(), "res/layout-xlarge/layout.xml",
                 "<LinearLayout><Button foo=\"bar\"></Button></LinearLayout>",
 
                 "<LinearLayout>\r\n" +
@@ -265,7 +266,7 @@
     }
 
     public void testRemoveBlanklines() throws Exception {
-        XmlFormatPreferences prefs = XmlFormatPreferences.create();
+        EclipseXmlFormatPreferences prefs = EclipseXmlFormatPreferences.create();
         prefs.removeEmptyLines = true;
         checkFormat(
                 prefs, "res/layout-xlarge/layout.xml",
@@ -289,7 +290,7 @@
 
     public void testRange() throws Exception {
         checkFormat(
-                XmlFormatPreferences.create(), "res/layout-xlarge/layout.xml",
+                EclipseXmlFormatPreferences.create(), "res/layout-xlarge/layout.xml",
                 "<LinearLayout><Button foo=\"bar\"></Button><CheckBox/></LinearLayout>",
                 "\n" +
                 "    <Button foo=\"bar\" >\n" +
@@ -302,7 +303,7 @@
 
     public void testOpenTagOnly() throws Exception {
         checkFormat(
-                XmlFormatPreferences.create(), "res/layout-xlarge/layout.xml",
+                EclipseXmlFormatPreferences.create(), "res/layout-xlarge/layout.xml",
                 "<LinearLayout><Button foo=\"bar\"></Button><CheckBox/></LinearLayout>",
                 "\n" +
                 "    <Button foo=\"bar\" >\n" +
@@ -313,7 +314,7 @@
     }
 
     public void testRange2() throws Exception {
-        XmlFormatPreferences prefs = XmlFormatPreferences.create();
+        EclipseXmlFormatPreferences prefs = EclipseXmlFormatPreferences.create();
         prefs.removeEmptyLines = true;
         checkFormat(
                 prefs, "res/layout-xlarge/layout.xml",
@@ -329,7 +330,6 @@
                 "    <bar3>\n" +
                 "        <baz12>\n" +
                 "        </baz12>\n",
-
                 "\n",
                 "baz1", false, "baz12");
     }
@@ -480,6 +480,7 @@
                 "    <dimen name=\"text_size_large\">22sp</dimen>\n" +
                 "\n" +
                 "</resources>",
+
                 "<resources>\n" +
                 "\n" +
                 "    <dimen name=\"colorstrip_height\">6dip</dimen>\n" +
@@ -499,7 +500,7 @@
 
     public void testCommentHandling() throws Exception {
         checkFormat(
-                XmlFormatPreferences.create(), "res/layout/layout1.xml",
+                EclipseXmlFormatPreferences.create(), "res/layout/layout1.xml",
                 "<foo >\n" +
                 "\n" +
                 "    <!-- abc\n" +
@@ -543,7 +544,7 @@
 
     public void testCommentHandling2() throws Exception {
         checkFormat(
-                XmlFormatPreferences.create(), "res/layout-xlarge/layout.xml",
+                EclipseXmlFormatPreferences.create(), "res/layout-xlarge/layout.xml",
                 "<foo >\n" +
                 "    <!-- multi -->\n" +
                 "\n" +
@@ -561,7 +562,7 @@
 
     public void testMenus1() throws Exception {
         checkFormat(
-                XmlFormatPreferences.create(), "res/menu/menu1.xml",
+                EclipseXmlFormatPreferences.create(), "res/menu/menu1.xml",
                 // http://code.google.com/p/android/issues/detail?id=21383
                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" +
                 "<menu xmlns:android=\"http://schemas.android.com/apk/res/android\" >\n" +
@@ -614,7 +615,7 @@
     }
 
     public void testMenus2() throws Exception {
-        XmlFormatPreferences prefs = XmlFormatPreferences.create();
+        EclipseXmlFormatPreferences prefs = EclipseXmlFormatPreferences.create();
         prefs.removeEmptyLines = true;
         checkFormat(
                 prefs, "res/drawable-hdpi/layerlist.xml",
@@ -640,6 +641,7 @@
                 "    </shape>\n" +
                 "  </item>\n" +
                 "</layer-list>",
+
                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" +
                 "<layer-list xmlns:android=\"http://schemas.android.com/apk/res/android\" >\n" +
                 "    <item>\n" +
@@ -665,7 +667,7 @@
 
     public void testMenus3() throws Exception {
         checkFormat(
-                XmlFormatPreferences.create(), "res/menu/menu1.xml",
+                EclipseXmlFormatPreferences.create(), "res/menu/menu1.xml",
                 // http://code.google.com/p/android/issues/detail?id=21227
                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" +
                 "<menu xmlns:android=\"http://schemas.android.com/apk/res/android\" >\n" +
@@ -703,7 +705,7 @@
 
     public void testColors1() throws Exception {
         checkFormat(
-                XmlFormatPreferences.create(), "res/values/colors.xml",
+                EclipseXmlFormatPreferences.create(), "res/values/colors.xml",
                 "<resources>\n" +
                 "  <color name=\"enrollment_error\">#99e21f14</color>\n" +
                 "\n" +
@@ -719,7 +721,7 @@
     }
 
     public void testEclipseFormatStyle1() throws Exception {
-        XmlFormatPreferences prefs = new XmlFormatPreferences() {
+        EclipseXmlFormatPreferences prefs = new EclipseXmlFormatPreferences() {
             @Override
             public String getOneIndentUnit() {
                 return "\t";
@@ -747,7 +749,7 @@
     }
 
     public void testEclipseFormatStyle2() throws Exception {
-        XmlFormatPreferences prefs = new XmlFormatPreferences() {
+        EclipseXmlFormatPreferences prefs = new EclipseXmlFormatPreferences() {
             @Override
             public String getOneIndentUnit() {
                 return "  ";
@@ -936,5 +938,4 @@
                 "\n" +
                 "</resources>");
     }
-
 }
diff --git a/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/layout/TestAttribute.java b/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/layout/TestAttribute.java
index 76840b1..752d61c 100644
--- a/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/layout/TestAttribute.java
+++ b/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/layout/TestAttribute.java
@@ -18,7 +18,7 @@
 import com.android.annotations.NonNull;
 import com.android.ide.common.api.IDragElement.IDragAttribute;
 import com.android.ide.common.api.INode.IAttribute;
-import com.android.ide.eclipse.adt.internal.editors.uimodel.UiAttributeNode;
+import com.android.ide.common.xml.XmlAttributeSortOrder;
 
 /** Test/mock implementation of {@link IAttribute} and {@link IDragAttribute} */
 public class TestAttribute implements IAttribute, IDragAttribute {
@@ -56,6 +56,6 @@
     }
 
     public int compareTo(IDragAttribute o) {
-        return UiAttributeNode.compareAttributes(mName, o.getName());
+        return XmlAttributeSortOrder.compareAttributes(mName, o.getName());
     }
 }
\ No newline at end of file
diff --git a/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/layout/TestNode.java b/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/layout/TestNode.java
index f5c9d4d..30886e4 100644
--- a/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/layout/TestNode.java
+++ b/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/common/layout/TestNode.java
@@ -15,13 +15,13 @@
  */
 package com.android.ide.common.layout;
 
+import static com.android.SdkConstants.ANDROID_URI;
 import static com.android.SdkConstants.ANDROID_WIDGET_PREFIX;
 import static com.android.SdkConstants.ATTR_ID;
-import static com.android.SdkConstants.ANDROID_URI;
 import static junit.framework.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static junit.framework.Assert.assertNotNull;
+import static junit.framework.Assert.assertTrue;
+import static junit.framework.Assert.fail;
 
 import com.android.annotations.NonNull;
 import com.android.annotations.Nullable;
@@ -30,9 +30,10 @@
 import com.android.ide.common.api.INodeHandler;
 import com.android.ide.common.api.Margins;
 import com.android.ide.common.api.Rect;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatPreferences;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlFormatStyle;
-import com.android.ide.eclipse.adt.internal.editors.formatting.XmlPrettyPrinter;
+import com.android.ide.common.xml.XmlFormatStyle;
+import com.android.ide.common.xml.XmlPrettyPrinter;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlFormatPreferences;
+import com.android.ide.eclipse.adt.internal.editors.formatting.EclipseXmlPrettyPrinter;
 import com.android.ide.eclipse.adt.internal.editors.layout.gle2.DomUtilities;
 import com.google.common.base.Splitter;
 
@@ -52,8 +53,6 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import junit.framework.Assert;
-
 /** Test/mock implementation of {@link INode} */
 @SuppressWarnings("javadoc")
 public class TestNode implements INode {
@@ -257,7 +256,7 @@
         String xml = dumpDocument(document);
         document = DomUtilities.parseDocument(xml, false);
 
-        XmlPrettyPrinter printer = new XmlPrettyPrinter(XmlFormatPreferences.create(),
+        XmlPrettyPrinter printer = new EclipseXmlPrettyPrinter(EclipseXmlFormatPreferences.create(),
                 XmlFormatStyle.LAYOUT, "\n");
         StringBuilder sb = new StringBuilder(1000);
         sb.append("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
@@ -466,7 +465,7 @@
             int bottom = Integer.parseInt(bounds[3]);
             mBounds = new Rect(left, top, right - left, bottom - top);
         } catch (NumberFormatException nufe) {
-            Assert.fail(nufe.getLocalizedMessage());
+            fail(nufe.getLocalizedMessage());
         }
         String tag = matcher.group(3);
 
diff --git a/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/eclipse/adt/internal/editors/formatting/AndroidXmlFormattingStrategyTest.java b/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/eclipse/adt/internal/editors/formatting/AndroidXmlFormattingStrategyTest.java
index 4fe2a7f..9c7e25d 100644
--- a/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/eclipse/adt/internal/editors/formatting/AndroidXmlFormattingStrategyTest.java
+++ b/eclipse/plugins/com.android.ide.eclipse.tests/unittests/com/android/ide/eclipse/adt/internal/editors/formatting/AndroidXmlFormattingStrategyTest.java
@@ -15,6 +15,8 @@
  */
 package com.android.ide.eclipse.adt.internal.editors.formatting;
 
+import com.android.ide.common.xml.XmlFormatPreferences;
+
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.Document;
 import org.eclipse.text.edits.MalformedTreeException;
@@ -61,7 +63,9 @@
 
     // In the given before document, replace the range indicated by [ and ] with the given
     // formatted string, and assert that it's identical to the given after string
-    private void check(String before, String insert, String expected, XmlFormatPreferences prefs)
+    private void check(
+            String before, String insert, String expected,
+            XmlFormatPreferences prefs)
             throws MalformedTreeException, BadLocationException {
         int replaceStart = before.indexOf('[');
         assertTrue(replaceStart != -1);