* Copyright (c) 2007, 2011 IBM Corporation and others.

* All rights reserved. This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*     IBM Corporation - initial API and implementation

*     David Carver (STAR) - bug 297006 - String Comparison

*******************************************************************************/

  /**

   * Just a small container class that holds a DOMNode & documentRegion that

   * should represent each other.

   */

  protected class DOMRegion {

    public IDOMNode domNode;

    public IStructuredDocumentRegion documentRegion;

  }

  static private final String PRESERVE = "preserve";//$NON-NLS-1$

  static private final String COLLAPSE = "collapse";//$NON-NLS-1$

  static private final String REPLACE = "replace";//$NON-NLS-1$

  static private final String PRESERVE_QUOTED = "\"preserve\"";//$NON-NLS-1$

  static private final String XML_SPACE = "xml:space";//$NON-NLS-1$

  static private final String XSL_NAMESPACE = "http://www.w3.org/1999/XSL/Transform"; //$NON-NLS-1$

  static private final String XSL_ATTRIBUTE = "attribute"; //$NON-NLS-1$

  static private final String XSL_TEXT = "text"; //$NON-NLS-1$

  static private final String SPACE = " "; //$NON-NLS-1$

  static private final String EMPTY = ""; //$NON-NLS-1$

  static private final String PROPERTY_WHITESPACE_FACET = "org.eclipse.wst.xsd.cm.properties/whitespace"; //$NON-NLS-1$

  private XMLFormattingPreferences fPreferences = null;

  private IProgressMonitor fProgressMonitor;

  private int replaceSpaces(TextEdit textEdit, int spaceStartOffset, int availableLineWidth, String whitespaceRun) {

    StringBuffer buff = new StringBuffer(whitespaceRun);

    for(int i = 0; i < buff.length(); i++) {

      buff.setCharAt(i, ' '); //$NON-NLS-1$

    }

    String replacementString = buff.toString();

    if (!replacementString.equals(whitespaceRun)) {

      ReplaceEdit replaceEdit = new ReplaceEdit(spaceStartOffset, whitespaceRun.length(), replacementString);

      textEdit.addChild(replaceEdit);

    }

    return availableLineWidth;

  }

 

  private int collapseSpaces(TextEdit textEdit, int spaceStartOffset, int availableLineWidth, String whitespaceRun) {

    // prefer to use use existing whitespace

    int existingWhitespaceOffset = whitespaceRun.indexOf(' ');

    if (existingWhitespaceOffset > -1) {

      // delete whitespaces before and after existing whitespace

      if (existingWhitespaceOffset > 0) {

        DeleteEdit deleteEdit = new DeleteEdit(spaceStartOffset, existingWhitespaceOffset);

        textEdit.addChild(deleteEdit);

      }

      if (existingWhitespaceOffset < whitespaceRun.length() - 1) {

        int nextOffset = existingWhitespaceOffset + 1;

        DeleteEdit deleteEdit = new DeleteEdit(spaceStartOffset + nextOffset, whitespaceRun.length() - nextOffset);

        textEdit.addChild(deleteEdit);

      }

    }

    else {

      // delete all whitespace and insert new one

      // collapse whitespace by deleting whitespace

      DeleteEdit deleteEdit = new DeleteEdit(spaceStartOffset, whitespaceRun.length());

      textEdit.addChild(deleteEdit);

      // then insert one space

      InsertEdit insertEdit = new InsertEdit(spaceStartOffset, SPACE);

      textEdit.addChild(insertEdit);

    }

    // remember to account for space added

    --availableLineWidth;

    return availableLineWidth;

  }

 

  private int collapseAndIndent(TextEdit textEdit, int spaceStartOffset, int availableLineWidth, int indentLevel, String whitespaceRun, IStructuredDocumentRegion currentRegion) {

    // Need to keep blank lines, but still collapse the whitespace

    String lineDelimiters = null;

    if (!getFormattingPreferences().getClearAllBlankLines()) {

      lineDelimiters = extractLineDelimiters(whitespaceRun, currentRegion);

      String formattedLine = lineDelimiters + getIndentString(indentLevel);

      if(lineDelimiters.length() > 0 && !formattedLine.equals(whitespaceRun)) {

        textEdit.addChild(new ReplaceEdit(spaceStartOffset, whitespaceRun.length(), formattedLine));

        availableLineWidth = getFormattingPreferences().getMaxLineWidth() - indentLevel;

      }

    }

    if (lineDelimiters == null || lineDelimiters.length() == 0) {

      availableLineWidth = collapseSpaces(textEdit, spaceStartOffset, availableLineWidth, whitespaceRun);

    }

    return availableLineWidth;

  }

  private void deleteTrailingSpaces(TextEdit textEdit, ITextRegion currentTextRegion, IStructuredDocumentRegion currentDocumentRegion) {

    int textEnd = currentTextRegion.getTextEnd();

    int textEndOffset = currentDocumentRegion.getStartOffset() + textEnd;

    int difference = currentTextRegion.getEnd() - textEnd;

    DeleteEdit deleteEdit = new DeleteEdit(textEndOffset, difference);

    textEdit.addChild(deleteEdit);

  }

  public TextEdit format(IDocument document, int start, int length) {

    return format(document, start, length, new XMLFormattingPreferences());

  }

  public TextEdit format(IDocument document, int start, int length, XMLFormattingPreferences preferences) {

    TextEdit edit = null;

    if (document instanceof IStructuredDocument) {

      IStructuredModel model = StructuredModelManager.getModelManager().getModelForEdit((IStructuredDocument) document);

      if (model != null) {

        try {

          edit = format(model, start, length, preferences);

        }

        finally {

          model.releaseFromEdit();

        }

      }

    }

    return edit;

  }

  public TextEdit format(IStructuredModel model, int start, int length) {

    return format(model, start, length, new XMLFormattingPreferences());

  }

  public TextEdit format(IStructuredModel model, int start, int length, XMLFormattingPreferences preferences) {

    setFormattingPreferences(preferences);

    TextEdit edit = new MultiTextEdit();

    IStructuredDocument document = model.getStructuredDocument();

    // get initial document region

    IStructuredDocumentRegion currentRegion = document.getRegionAtCharacterOffset(start);

    if (currentRegion != null) {

      int startOffset = currentRegion.getStartOffset();

      // get initial dom node

      IndexedRegion currentIndexedRegion = model.getIndexedRegion(startOffset);

      if (currentIndexedRegion instanceof IDOMNode) {

        // set up domRegion which will contain current region to be

        // formatted

        IDOMNode currentDOMNode = (IDOMNode) currentIndexedRegion;

        DOMRegion domRegion = new DOMRegion();

        domRegion.documentRegion = currentRegion;

        domRegion.domNode = currentDOMNode;

       

        XMLFormattingConstraints parentConstraints = getRegionConstraints(currentDOMNode);

       

        /* if the whitespace strategy is declared as default, get it from the preferences */

        if(XMLFormattingConstraints.DEFAULT.equals(parentConstraints.getWhitespaceStrategy()))

          parentConstraints.setWhitespaceStrategy(preferences.getElementWhitespaceStrategy());

       

        // TODO: initialize indentLevel

        // initialize available line width

        int lineWidth = getFormattingPreferences().getMaxLineWidth();

        try {

          IRegion lineInfo = document.getLineInformationOfOffset(startOffset);

          lineWidth = lineWidth - (startOffset - lineInfo.getOffset());

        }

        catch (BadLocationException e) {

          Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);

        }

        parentConstraints.setAvailableLineWidth(lineWidth);

        // format all siblings (and their children) as long they

        // overlap with start/length

        Position formatRange = new Position(start, length);

        formatSiblings(edit, domRegion, parentConstraints, formatRange);

      }

    }

    return edit;

  }

  /**

   * Determines the formatting constraints for a specified node based on

   * its ancestors' formatting. In particular, if any ancestor node either

   * explicitly defines whitespace preservation or ignorance, that

   * whitespace strategy should be used for <code>currentNode</code> and

   * all of its descendants.

   *

   * @param currentNode the node to investigate the ancestry of to determine

   * formatting constraints

   *

   * @return formatting constraints defined by an ancestor

   */

  private XMLFormattingConstraints getRegionConstraints(IDOMNode currentNode) {

    IDOMNode iterator = currentNode;

    XMLFormattingConstraints result = new XMLFormattingConstraints();

    DOMRegion region = new DOMRegion();

    XMLFormattingConstraints parentConstraints = new XMLFormattingConstraints();

    boolean parent = true;

   

    /* Iterate through the ancestry to find if any explicit whitespace strategy has

     * been defined

     */

    while(iterator != null && iterator.getNodeType() != Node.DOCUMENT_NODE) {

      iterator = (IDOMNode) iterator.getParentNode();

      region.domNode = iterator;

      region.documentRegion = iterator.getFirstStructuredDocumentRegion();

     

      updateFormattingConstraints(null, null, result, region);

     

      /* If this is the parent of the current node, keep the constraints

       * in case no other constraints are identified

       */

      if(parent) {

        parentConstraints.copyConstraints(result);

        parent = false;

      }

     

      /* A parent who has defined a specific whitespace strategy was found */

      if(XMLFormattingConstraints.PRESERVE.equals(result.getWhitespaceStrategy()) || XMLFormattingConstraints.DEFAULT.equals(result.getWhitespaceStrategy()))

        return result;

    }

   

    return parentConstraints;

  }

//    IDOMNode iterator = (IDOMNode) currentNode.getParentNode();

//    XMLFormattingConstraints result = new XMLFormattingConstraints();

//    DOMRegion region = new DOMRegion();

//   

//    /* Iterate through the ancestry to find if any explicit whitespace strategy has

//     * been defined

//     */

//    while(iterator != null && iterator.getNodeType() != Node.DOCUMENT_NODE) {

//      region.domNode = iterator;

//      region.documentRegion = iterator.getFirstStructuredDocumentRegion();

//     

//      updateFormattingConstraints(null, null, result, region);

//     

//      /* A parent who has defined a specific whitespace strategy was found */

//      if(XMLFormattingConstraints.PRESERVE == result.getWhitespaceStrategy() || XMLFormattingConstraints.DEFAULT == result.getWhitespaceStrategy())

//        return result;

//     

//      iterator = (IDOMNode) iterator.getParentNode();

//    }

//   

//    return null;

//  }

 

  /**

   * Formats the given xml content region

   *

   * @param textEdit

   * @param formatRange

   * @param parentConstraints

   * @param currentDOMRegion

   * @param previousRegion

   */

  private void formatContent(TextEdit textEdit, Position formatRange, XMLFormattingConstraints parentConstraints, DOMRegion currentDOMRegion, IStructuredDocumentRegion previousRegion) {

    IStructuredDocumentRegion currentRegion = currentDOMRegion.documentRegion;

    String fullText = currentDOMRegion.domNode.getSource();

    // check if in preserve space mode, if so, don't touch anything but

    // make sure to update available line width

    String whitespaceMode = parentConstraints.getWhitespaceStrategy();

    if (XMLFormattingConstraints.PRESERVE.equals(whitespaceMode)) {

      int availableLineWidth = parentConstraints.getAvailableLineWidth();

      availableLineWidth = updateLineWidthWithLastLine(fullText, availableLineWidth);

      // update available line width in constraints

      parentConstraints.setAvailableLineWidth(availableLineWidth);

      // A text node can contain multiple structured document regions - sync the documentRegion

      // with the last region of the node since the text from all regions was formatted

      currentDOMRegion.documentRegion = currentDOMRegion.domNode.getLastStructuredDocumentRegion();

      return;

    }

    // if content is just whitespace and there's something after it

    // just skip over this region because region will take care of it

    boolean isAllWhitespace = ((IDOMText) currentDOMRegion.domNode).isElementContentWhitespace();

    IStructuredDocumentRegion nextDocumentRegion = null;

    if (isAllWhitespace) {

      parentConstraints.setAvailableLineWidth(fPreferences.getMaxLineWidth());

      nextDocumentRegion = currentRegion.getNext();

      if (nextDocumentRegion != null)

        return;

    }

    // special handling if text follows an entity or cdata region

    if (!XMLFormattingConstraints.COLLAPSE.equals(whitespaceMode) && previousRegion != null) {

      String previouRegionType = previousRegion.getType();

      if (DOMRegionContext.XML_ENTITY_REFERENCE.equals(previouRegionType) || DOMRegionContext.XML_CDATA_TEXT.equals(previouRegionType))

        whitespaceMode = XMLFormattingConstraints.COLLAPSE;

    }

    // also, special handling if text is before an entity or cdata region

    if (!XMLFormattingConstraints.COLLAPSE.equals(whitespaceMode)) {

      // get next document region if dont already have it

      if (nextDocumentRegion == null)

        nextDocumentRegion = currentRegion.getNext();

      if (nextDocumentRegion != null) {

        String nextRegionType = nextDocumentRegion.getType();

        if (DOMRegionContext.XML_ENTITY_REFERENCE.equals(nextRegionType) || DOMRegionContext.XML_CDATA_TEXT.equals(nextRegionType))

          whitespaceMode = XMLFormattingConstraints.COLLAPSE;

      }

    }

    final IStructuredDocumentRegion lastRegion = currentDOMRegion.domNode.getLastStructuredDocumentRegion();

    formatTextInContent(textEdit, parentConstraints, currentRegion, lastRegion != null ? lastRegion.getNext(): null, fullText, whitespaceMode);

    // A text node can contain multiple structured document regions - sync the documentRegion

    // with the last region of the node since the text from all regions was formatted

    currentDOMRegion.documentRegion = lastRegion;

  }

  private void formatEmptyStartTagWithNoAttr(TextEdit textEdit, XMLFormattingConstraints constraints, IStructuredDocumentRegion currentDocumentRegion, IStructuredDocumentRegion previousDocumentRegion, int availableLineWidth, String indentStrategy, String whitespaceStrategy, ITextRegion currentTextRegion) {

    // get preference if there should be a space or not between tag

    // name and empty tag close

    // <tagName />

    boolean oneSpaceInTagName = getFormattingPreferences().getSpaceBeforeEmptyCloseTag();

    // calculate available line width

    int tagNameLineWidth = currentTextRegion.getTextLength() + 3;

    if (oneSpaceInTagName) {

      // add one more to account for space before empty tag close

      ++tagNameLineWidth;

    }

    availableLineWidth -= tagNameLineWidth;

    if (XMLFormattingConstraints.INLINE.equals(indentStrategy)) {

      // if was inlining, need to check if out of available line

      // width

      if (availableLineWidth < 0) {

        // need to indent if possible

        int lineWidth = indentIfPossible(textEdit, constraints, currentDocumentRegion, previousDocumentRegion, whitespaceStrategy, indentStrategy, true);

        // update available line width

        if (lineWidth > 0)

          availableLineWidth = lineWidth - tagNameLineWidth;

        else

          availableLineWidth -= tagNameLineWidth;

      }

      else {

        // no need to indent

        // just make sure to delete previous whitespace if

        // needed

        if ((DOMRegionContext.XML_CONTENT.equals(previousDocumentRegion.getType())) && (previousDocumentRegion.getFullText().trim().length() == 0)) {

          availableLineWidth = collapseSpaces(textEdit, previousDocumentRegion.getStartOffset(), availableLineWidth, previousDocumentRegion.getFullText());

        }

      }

    }

    // delete any trail spaces after tag name

    int textLength = currentTextRegion.getTextLength();

    int regionLength = currentTextRegion.getLength();

    boolean thereAreSpaces = textLength < regionLength;

    if (!oneSpaceInTagName && thereAreSpaces) {

      deleteTrailingSpaces(textEdit, currentTextRegion, currentDocumentRegion);

    }

    else if(oneSpaceInTagName) {

      insertSpaceAndCollapse(textEdit, currentDocumentRegion, availableLineWidth, currentTextRegion);

    }

    constraints.setAvailableLineWidth(availableLineWidth);

  }

  /**

   * Formats an end tag

   *

   * @param textEdit

   * @param currentRegion

   * @param textRegions

   */

  private void formatEndTag(TextEdit textEdit, Position formatRange, XMLFormattingConstraints constraints, DOMRegion currentDOMRegion, IStructuredDocumentRegion previousDocumentRegion) {

    IStructuredDocumentRegion currentDocumentRegion = currentDOMRegion.documentRegion;

    String whitespaceStrategy = constraints.getWhitespaceStrategy();

    String indentStrategy = constraints.getIndentStrategy();

    // do not format space before start tag if preserving spaces

    if (whitespaceStrategy != XMLFormattingConstraints.PRESERVE) {

      // format like indent strategy says

      if (XMLFormattingConstraints.INDENT.equals(indentStrategy) || XMLFormattingConstraints.NEW_LINE.equals(indentStrategy)) {

        int availableLineWidth = indentIfPossible(textEdit, constraints, currentDocumentRegion, previousDocumentRegion, whitespaceStrategy, indentStrategy, false);

        constraints.setAvailableLineWidth(availableLineWidth);

      }

      else if ( XMLFormattingConstraints.INLINE.equals(indentStrategy)){

        IStructuredDocument doc = currentDocumentRegion.getParentDocument();

        int currentLine = doc.getLineOfOffset(currentDocumentRegion.getStartOffset());

        int prevLine = doc.getLineOfOffset(previousDocumentRegion.getStartOffset());

        if ( currentLine != prevLine){

          int availableLineWidth = indentIfPossible(textEdit, constraints, currentDocumentRegion, previousDocumentRegion, whitespaceStrategy, indentStrategy, false);

          constraints.setAvailableLineWidth(availableLineWidth);

        }

      }

    }

    // format the end tag itself

    formatWithinEndTag(textEdit, constraints, currentDocumentRegion, previousDocumentRegion);

  }

  /**

   * Formats the given region (and all its children) contained in domRegion.

   *

   * @param edit

   *            edits required to format

   * @param formatRange

   *            document range to format (only format content within this

   *            range)

   * @param parentConstraints

   * @param domRegion

   *            assumes dom node & region are not null

   * @param previousRegion

   *            could be null

   * @return Returns the last region formatted

   */

  private DOMRegion formatRegion(TextEdit edit, Position formatRange, XMLFormattingConstraints parentConstraints, DOMRegion domRegion, IStructuredDocumentRegion previousRegion) {

    IStructuredDocumentRegion currentRegion = domRegion.documentRegion;

    String regionType = currentRegion.getType();

    if (DOMRegionContext.XML_TAG_NAME.equals(regionType)) {

      ITextRegion textRegion = currentRegion.getFirstRegion();

      String textRegionType = textRegion.getType();

      if (DOMRegionContext.XML_TAG_OPEN.equals(textRegionType)) {

        domRegion = formatStartTag(edit, formatRange, parentConstraints, domRegion, previousRegion);

      }

      else if (DOMRegionContext.XML_END_TAG_OPEN.equals(textRegionType)) {

        formatEndTag(edit, formatRange, parentConstraints, domRegion, previousRegion);

      }

    }

    else if (DOMRegionContext.XML_CONTENT.equals(regionType) || domRegion.domNode.getNodeType() == Node.TEXT_NODE) {

      formatContent(edit, formatRange, parentConstraints, domRegion, previousRegion);

    }

    else if (DOMRegionContext.XML_COMMENT_TEXT.equals(regionType)) {

      formatComment(edit, formatRange, parentConstraints, domRegion, previousRegion);

    }

    else {

      // unknown, so just leave alone for now but make sure to update

      // available line width

      String fullText = currentRegion.getFullText();

      int width = updateLineWidthWithLastLine(fullText, parentConstraints.getAvailableLineWidth());

      parentConstraints.setAvailableLineWidth(width);

    }

    return domRegion;

  }

  /**

   * Formats the domRegion and all of its children and siblings

   *

   * @param edit

   * @param domRegion

   * @param parentConstraints

   * @param formatRange

   */

  private void formatSiblings(TextEdit edit, DOMRegion domRegion, XMLFormattingConstraints parentConstraints, Position formatRange) {

    IStructuredDocumentRegion previousRegion = null;

    IStructuredDocumentRegion currentRegion = domRegion.documentRegion;

    IDOMNode currentDOMNode = domRegion.domNode;

    while (currentDOMNode != null && currentRegion != null && formatRange.overlapsWith(currentRegion.getStartOffset(), currentRegion.getLength()) && (fProgressMonitor == null || !fProgressMonitor.isCanceled())) {

      domRegion.documentRegion = currentRegion;

      domRegion.domNode = currentDOMNode;

      // need to make sure current document region and current

      // dom node match up

      if (currentDOMNode.getFirstStructuredDocumentRegion().equals(currentRegion)) {

        // format this document region/node, formatRegion will

        // return the last node/region formatted

        domRegion = formatRegion(edit, formatRange, parentConstraints, domRegion, previousRegion);

      }

      else {

        // TODO: need to figure out what to do if they don't

        // match up

      }

      previousRegion = domRegion.documentRegion;

      // get the next sibling information

      if (domRegion.domNode != null)

        currentDOMNode = (IDOMNode) domRegion.domNode.getNextSibling();

      else

        currentDOMNode = null;

      currentRegion = previousRegion.getNext();

    }

  }

  /**

   * Formats a start tag

   *

   * @param textEdit

   * @param currentRegion

   * @param textRegions

   */

  private DOMRegion formatStartTag(TextEdit textEdit, Position formatRange, XMLFormattingConstraints parentConstraints, DOMRegion currentDOMRegion, IStructuredDocumentRegion previousDocumentRegion) {

    // determine proper indent by referring to parent constraints,

    // previous node, and current node

    IStructuredDocumentRegion currentDocumentRegion = currentDOMRegion.documentRegion;

    IDOMNode currentDOMNode = currentDOMRegion.domNode;

    // create a constraint for this tag

    XMLFormattingConstraints thisConstraints = new XMLFormattingConstraints();

    XMLFormattingConstraints childrenConstraints = new XMLFormattingConstraints();

    updateFormattingConstraints(parentConstraints, thisConstraints, childrenConstraints, currentDOMRegion);

    if(XMLFormattingConstraints.DEFAULT.equals(childrenConstraints.getWhitespaceStrategy()))

      childrenConstraints.setWhitespaceStrategy((new XMLFormattingPreferences()).getElementWhitespaceStrategy());

     

    String whitespaceStrategy = thisConstraints.getWhitespaceStrategy();

    String indentStrategy = thisConstraints.getIndentStrategy();

    int availableLineWidth = thisConstraints.getAvailableLineWidth();

    // format space before start tag

    // do not format space before start tag if preserving spaces

    if (!XMLFormattingConstraints.PRESERVE.equals(whitespaceStrategy)) {

      // format like indent strategy says

      if (XMLFormattingConstraints.INDENT.equals(indentStrategy) || XMLFormattingConstraints.NEW_LINE.equals(indentStrategy)) {

        availableLineWidth = indentIfPossible(textEdit, thisConstraints, currentDocumentRegion, previousDocumentRegion, whitespaceStrategy, indentStrategy, true, true);

        if (availableLineWidth > 0)

          thisConstraints.setAvailableLineWidth(availableLineWidth);

      }

    }

    // format the start tag itself

    boolean tagEnded = formatWithinTag(textEdit, thisConstraints, currentDocumentRegion, previousDocumentRegion);

    // format children

    if (!tagEnded) {

      // update childConstraints with thisConstraint's indentLevel &

      // availableLineWidth

      childrenConstraints.setIndentLevel(thisConstraints.getIndentLevel());

      childrenConstraints.setAvailableLineWidth(thisConstraints.getAvailableLineWidth());

      previousDocumentRegion = currentDocumentRegion;

      IDOMNode childDOMNode = (IDOMNode) currentDOMNode.getFirstChild();

      IStructuredDocumentRegion nextRegion = currentDocumentRegion.getNext();

      boolean passedFormatRange = false;

      // as long as there is one child

      if (childDOMNode != null && nextRegion != null) {

        while (childDOMNode != null && nextRegion != null && !passedFormatRange && (fProgressMonitor == null || !fProgressMonitor.isCanceled())) {

          DOMRegion childDOMRegion = new DOMRegion();

          childDOMRegion.documentRegion = nextRegion;

          childDOMRegion.domNode = childDOMNode;

          if (nextRegion.equals(childDOMNode.getFirstStructuredDocumentRegion())) {

            // format children. pass in child constraints

            childDOMRegion = formatRegion(textEdit, formatRange, childrenConstraints, childDOMRegion, previousDocumentRegion);

          }

          else {

            // TODO: what happens if they dont match up?

          }

          // update childDOMRegion with next dom/region node

          if (childDOMRegion.domNode != null) {

            childDOMNode = (IDOMNode) childDOMRegion.domNode.getNextSibling();

          }

          else {

            childDOMNode = null;

          }

          previousDocumentRegion = childDOMRegion.documentRegion;

          nextRegion = previousDocumentRegion.getNext();

          if (nextRegion != null)

            passedFormatRange = !formatRange.overlapsWith(nextRegion.getStartOffset(), nextRegion.getLength());

        }

      }

      else {

        // there were no children, so keep end tag inlined

        childrenConstraints.setWhitespaceStrategy(XMLFormattingConstraints.COLLAPSE);

        childrenConstraints.setIndentStrategy(XMLFormattingConstraints.INLINE);

      }

      if (!passedFormatRange) {

        // update the dom region with the last formatted region/dom

        // node should be end tag and this tag's DOMNode

        currentDOMRegion.documentRegion = nextRegion;

        currentDOMRegion.domNode = currentDOMNode;

        // end tag's indent level should be same as start tag's

        childrenConstraints.setIndentLevel(thisConstraints.getIndentLevel());

        // format end tag

        boolean formatEndTag = false;

        if (nextRegion != null && currentDOMNode != null) {

          ITextRegionList rs = nextRegion.getRegions();

          if (rs.size() > 1) {

            ITextRegion r = rs.get(0);

            if (r != null && DOMRegionContext.XML_END_TAG_OPEN.equals(r.getType())) {

              r = rs.get(1);

              if (r != null && DOMRegionContext.XML_TAG_NAME.equals(r.getType())) {

                String tagName = nextRegion.getText(r);

                if (tagName != null && tagName.equals(currentDOMNode.getNodeName()))

                  formatEndTag = true;

              }

            }

          }

        }

        if (formatEndTag)

          formatEndTag(textEdit, formatRange, childrenConstraints, currentDOMRegion, previousDocumentRegion);

        else {

          // missing end tag so return last formatted document

          // region

          currentDOMRegion.documentRegion = previousDocumentRegion;

        }

      }

      else {

        // passed format range before could finish, so update dom

        // region to last known formatted region

        currentDOMRegion.documentRegion = nextRegion;

        currentDOMRegion.domNode = childDOMNode;

      }

      // update parent constraint since this is what is passed back

      parentConstraints.setAvailableLineWidth(childrenConstraints.getAvailableLineWidth());

    }

    else {

      // update available line width

      parentConstraints.setAvailableLineWidth(thisConstraints.getAvailableLineWidth());

    }

    return currentDOMRegion;

  }

  private void formatStartTagWithNoAttr(TextEdit textEdit, XMLFormattingConstraints constraints, IStructuredDocumentRegion currentDocumentRegion, IStructuredDocumentRegion previousDocumentRegion, int availableLineWidth, String indentStrategy, String whitespaceStrategy, ITextRegion currentTextRegion) {

    // calculate available line width

    int tagNameLineWidth = currentTextRegion.getTextLength() + 2;

    availableLineWidth -= tagNameLineWidth;

    if (XMLFormattingConstraints.INLINE.equals(indentStrategy)) {

      // if was inlining, need to check if out of available line

      // width

      if (availableLineWidth < 0) {

        // need to indent if possible

        int lineWidth = indentIfPossible(textEdit, constraints, currentDocumentRegion, previousDocumentRegion, whitespaceStrategy, indentStrategy, true);

        // update available line width

        if (lineWidth > 0)

          availableLineWidth = lineWidth - tagNameLineWidth;

        else

          availableLineWidth -= tagNameLineWidth;

      }

      else {

        // no need to indent

        // just make sure to delete previous whitespace if

        // needed

        if (previousDocumentRegion != null) {

          if (DOMRegionContext.XML_CONTENT.equals(previousDocumentRegion.getType())) {

            String previousDocumentRegionText = previousDocumentRegion.getFullText();

            if (previousDocumentRegionText.trim().length() == 0) {

              availableLineWidth = collapseSpaces(textEdit, previousDocumentRegion.getStartOffset(), availableLineWidth, previousDocumentRegionText);

            }

          }

        }

      }

    }

    // delete any trail spaces after tag name

    if (currentTextRegion.getTextLength() < currentTextRegion.getLength()) {

      deleteTrailingSpaces(textEdit, currentTextRegion, currentDocumentRegion);

    }

    constraints.setAvailableLineWidth(availableLineWidth);

  }

  /**

   * Format the text in xml content

   *

   * @param textEdit

   * @param parentConstraints

   * @param currentRegion

   * @param fullText

   * @param whitespaceMode

   */

  private void formatTextInContent(TextEdit textEdit, XMLFormattingConstraints parentConstraints, IStructuredDocumentRegion currentRegion, IStructuredDocumentRegion nextRegion, String fullText, String whitespaceMode) {

    int availableLineWidth = parentConstraints.getAvailableLineWidth();

    // determine indentation

    boolean forceInitialIndent = false;

    int indentLevel = parentConstraints.getIndentLevel() + 1;

    String indentMode = parentConstraints.getIndentStrategy();

    if (XMLFormattingConstraints.INDENT.equals(indentMode)) {

      forceInitialIndent = true;

    }

    if (XMLFormattingConstraints.NEW_LINE.equals(indentMode)) {

      indentLevel = parentConstraints.getIndentLevel();

      forceInitialIndent = true;

    }

    int fullTextOffset = 0;

    char[] fullTextArray = fullText.toCharArray();

    while (fullTextOffset < fullTextArray.length) {

      // gather all whitespaces

      String whitespaceRun = getCharacterRun(fullTextArray, fullTextOffset, true);

      if (whitespaceRun.length() > 0) {

        // offset where whitespace starts

        int whitespaceStart = fullTextOffset;

        // update current offset in fullText

        fullTextOffset += whitespaceRun.length();

        // gather following word

        String characterRun = getCharacterRun(fullTextArray, fullTextOffset, false);

        int characterRunLength = characterRun.length();

        if (characterRunLength > 0) {

          // indent if word is too long or forcing initial

          // indent

          availableLineWidth -= characterRunLength;

          // offset where indent/collapse will happen

          int startOffset = currentRegion.getStartOffset() + whitespaceStart;

          if (forceInitialIndent || (availableLineWidth <= 0)) {

            // indent if not already indented

            availableLineWidth = indentIfNotAlreadyIndented(textEdit, currentRegion, indentLevel, startOffset, whitespaceRun);

            // remember to subtract word length

            availableLineWidth -= characterRunLength;

            forceInitialIndent = false; // initial indent done

          }

          else {

            // just collapse spaces, but adjust for any indenting that may result from preserving line delimiters

            if (whitespaceStart == 0 && XMLFormattingConstraints.IGNOREANDTRIM.equals(whitespaceMode)) {

              // if ignore, trim

              DeleteEdit deleteTrailing = new DeleteEdit(startOffset, whitespaceRun.length());

              textEdit.addChild(deleteTrailing);

            }

            else if(XMLFormattingConstraints.REPLACE.equals(whitespaceMode))

              availableLineWidth = replaceSpaces(textEdit, startOffset, availableLineWidth, whitespaceRun);

            else

              availableLineWidth = collapseAndIndent(textEdit, startOffset, availableLineWidth, indentLevel, whitespaceRun, currentRegion);

          }

          fullTextOffset += characterRunLength;

        }

        else {

          // handle trailing whitespace

          int whitespaceOffset = currentRegion.getStartOffset() + whitespaceStart;

          if (XMLFormattingConstraints.REPLACE.equals(whitespaceMode))

            availableLineWidth = replaceSpaces(textEdit, whitespaceOffset, availableLineWidth, whitespaceRun);

          else if (XMLFormattingConstraints.IGNOREANDTRIM.equals(whitespaceMode)) {

            // always trim

            DeleteEdit deleteTrailing = new DeleteEdit(whitespaceOffset, whitespaceRun.length());

            textEdit.addChild(deleteTrailing);

          }

          else if(getFormattingPreferences().getClearAllBlankLines()) {

            if (!nextRegionHandlesTrailingWhitespace(nextRegion)) {

              if (XMLFormattingConstraints.IGNORE.equals(whitespaceMode)) {

                // if ignore, trim

                DeleteEdit deleteTrailing = new DeleteEdit(whitespaceOffset, whitespaceRun.length());

                textEdit.addChild(deleteTrailing);

              }

              else {

                // if collapse, leave a space. but what if end up

                // wanting to add indent? then need to delete space

                // added and add indent instead

                availableLineWidth = collapseSpaces(textEdit, whitespaceOffset, availableLineWidth, whitespaceRun);

              }

            }

          }

        }

      }

      else {

        // gather word

        String characterRun = getCharacterRun(fullTextArray, fullTextOffset, false);

        int characterRunLength = characterRun.length();

        if (characterRunLength > 0) {

          // indent if word is too long or forcing initial

          // indent

          // [243091] - characterRunLength should only be subtracted once or text formatting wraps prematurely

          // availableLineWidth = availableLineWidth - characterRunLength;

          if ((XMLFormattingConstraints.IGNORE.equals(whitespaceMode) || XMLFormattingConstraints.IGNOREANDTRIM.equals(whitespaceMode)) && (forceInitialIndent || (availableLineWidth <= 0))) {

            // indent if not already indented

            availableLineWidth = indentIfNotAlreadyIndented(textEdit, currentRegion, indentLevel, currentRegion.getStartOffset(), whitespaceRun);

            // remember to subtract word length

            availableLineWidth -= characterRunLength;

            forceInitialIndent = false; // initial indent done

          }

          else {

            // just collapse spaces

            availableLineWidth -= characterRunLength;

          }

          fullTextOffset += characterRunLength;

        }

      }

    }

    // update available line width

    parentConstraints.setAvailableLineWidth(availableLineWidth);

  }

  private boolean nextRegionHandlesTrailingWhitespace(IStructuredDocumentRegion region) {

    if (region == null)

      return false;

    final String type = region.getType();

    if (type.equals(DOMRegionContext.XML_TAG_NAME)) {

      return DOMRegionContext.XML_TAG_OPEN.equals(region.getFirstRegion().getType());

    }

    return DOMRegionContext.XML_COMMENT_TEXT.equals(type);

  }

  private void formatWithinEndTag(TextEdit textEdit, XMLFormattingConstraints constraints, IStructuredDocumentRegion currentDocumentRegion, IStructuredDocumentRegion previousDocumentRegion) {

    String indentStrategy = constraints.getIndentStrategy();

    String whitespaceStrategy = constraints.getWhitespaceStrategy();

    int availableLineWidth = constraints.getAvailableLineWidth();

    ITextRegionList textRegions = currentDocumentRegion.getRegions();

    int currentNumberOfRegions = currentDocumentRegion.getNumberOfRegions();

    int currentTextRegionIndex = 1;

    ITextRegion currentTextRegion = textRegions.get(currentTextRegionIndex);

    String currentType = currentTextRegion.getType();

    // tag name should always be the first text region

    if (DOMRegionContext.XML_TAG_NAME.equals(currentType) && currentTextRegionIndex < currentNumberOfRegions - 1) {

      ITextRegion nextTextRegion = textRegions.get(currentTextRegionIndex + 1);

      // Bug 221279 - Some non well-formed documents will not contribute a next region

      if (nextTextRegion != null && DOMRegionContext.XML_TAG_CLOSE.equals(nextTextRegion.getType())) {

        // calculate available line width

        int tagNameLineWidth = currentTextRegion.getTextLength() + 3;

        availableLineWidth -= tagNameLineWidth;

        if (XMLFormattingConstraints.INLINE.equals(indentStrategy)) {

          // if was inlining, need to check if out of available line

          // width - Whitespace may have been corrected in the text content

          if (availableLineWidth < 0 && XMLFormattingConstraints.IGNORE.equals(whitespaceStrategy)) {

            // need to deindent if possible

            int lineWidth = indentIfPossible(textEdit, constraints, currentDocumentRegion, previousDocumentRegion, whitespaceStrategy, indentStrategy, false);

            // update available line width

            if (lineWidth > 0)

              availableLineWidth = lineWidth - tagNameLineWidth;

          }

          else {

            // no need to indent

            // just make sure to delete previous whitespace if

            // needed

            if (previousDocumentRegion != null) {

              if (DOMRegionContext.XML_CONTENT.equals(previousDocumentRegion.getType())) {

                String previousDocumentRegionText = previousDocumentRegion.getFullText();

                if (previousDocumentRegionText.trim().length() == 0) {

                  availableLineWidth = collapseSpaces(textEdit, previousDocumentRegion.getStartOffset(), availableLineWidth, previousDocumentRegionText);

                }

              }

            }

          }

        }

        // delete any trail spaces after tag name

        if (currentTextRegion.getTextLength() < currentTextRegion.getLength()) {

          deleteTrailingSpaces(textEdit, currentTextRegion, currentDocumentRegion);

        }

      }

    }

    else {

      // end tag has unexpected stuff, so just leave it alone

    }

    constraints.setAvailableLineWidth(availableLineWidth);

  }

  /**

   * Formats the contents within a tag like tag name and attributes

   *

   * @param textEdit

   * @param currentDocumentRegion

   * @param textRegions

   *            contains at least 3 regions

   * @return true if tag was ended, false otherwise

   */

  private boolean formatWithinTag(TextEdit textEdit, XMLFormattingConstraints constraints, IStructuredDocumentRegion currentDocumentRegion, IStructuredDocumentRegion previousDocumentRegion) {

    int availableLineWidth = constraints.getAvailableLineWidth();

    String indentStrategy = constraints.getIndentStrategy();

    String whitespaceStrategy = constraints.getWhitespaceStrategy();

    int indentLevel = constraints.getIndentLevel();

    ITextRegionList textRegions = currentDocumentRegion.getRegions();

    int currentTextRegionIndex = 1;

    ITextRegion currentTextRegion = textRegions.get(currentTextRegionIndex);

    String currentType = currentTextRegion.getType();

    // tag name should always be the first text region

    if (DOMRegionContext.XML_TAG_NAME.equals(currentType)) {

      ITextRegion nextTextRegion = textRegions.get(currentTextRegionIndex + 1);

      String nextType = (nextTextRegion != null) ? nextTextRegion.getType() : null;

      if (DOMRegionContext.XML_TAG_CLOSE.equals(nextType)) {

        // already at tag close

        formatStartTagWithNoAttr(textEdit, constraints, currentDocumentRegion, previousDocumentRegion, availableLineWidth, indentStrategy, whitespaceStrategy, currentTextRegion);

        return false;

      }

      else if (DOMRegionContext.XML_EMPTY_TAG_CLOSE.equals(nextType)) {

        // already at empty tag close

        formatEmptyStartTagWithNoAttr(textEdit, constraints, currentDocumentRegion, previousDocumentRegion, availableLineWidth, indentStrategy, whitespaceStrategy, currentTextRegion);

        return true;

      }

      else {

        availableLineWidth -= (currentTextRegion.getTextLength() + 2);

        boolean alignFinalBracket = getFormattingPreferences().getAlignFinalBracket();

        boolean oneSpaceInTagName = getFormattingPreferences().getSpaceBeforeEmptyCloseTag();

        boolean indentMultipleAttribute = getFormattingPreferences().getIndentMultipleAttributes();

        // indicates if tag spanned more than one line

        boolean spanMoreThan1Line = false;

        // indicates if all attributes should be indented

        boolean indentAllAttributes = false;

        if (indentMultipleAttribute) {

          int attributesCount = 0;

          int i = 2;

          final int size = textRegions.size();

          while (i < size && attributesCount < 2) {

            if (DOMRegionContext.XML_TAG_ATTRIBUTE_NAME.equals(textRegions.get(i).getType())) {

              ++attributesCount;

            }

            i++;

          }

          indentAllAttributes = (attributesCount > 1);

        }

        while ((currentTextRegionIndex + 1) < textRegions.size()) {

          nextTextRegion = textRegions.get(currentTextRegionIndex + 1);

          nextType = nextTextRegion.getType();

          if (DOMRegionContext.XML_TAG_ATTRIBUTE_NAME.equals(nextType)) {

            boolean indentAttribute = indentAllAttributes;

            if (!indentAttribute)

              indentAttribute = shouldIndentBeforeAttribute(constraints, textRegions, availableLineWidth, currentTextRegionIndex, currentTextRegion, nextTextRegion);

            if (indentAttribute) {

              availableLineWidth = indentIfNotAlreadyIndented(textEdit, indentLevel + 1, currentDocumentRegion, currentTextRegion);

              spanMoreThan1Line = true;

            }

            else {

              // otherwise, insertSpaceAndCollapse

              insertSpaceAndCollapse(textEdit, currentDocumentRegion, availableLineWidth, currentTextRegion);

              // update available line width

              availableLineWidth -= (currentTextRegion.getTextLength() + 1);

            }

          }

          else if (DOMRegionContext.XML_TAG_CLOSE.equals(nextType)) {

            // if need to align bracket on next line, indent

            if (alignFinalBracket && spanMoreThan1Line) {

              availableLineWidth = indentIfNotAlreadyIndented(textEdit, indentLevel, currentDocumentRegion, currentTextRegion);

              --availableLineWidth; // for tag close itself

            }

            else {

              // otherwise, just delete space before tag close

              if (currentTextRegion.getTextLength() < currentTextRegion.getLength()) {

                deleteTrailingSpaces(textEdit, currentTextRegion, currentDocumentRegion);

                availableLineWidth -= (currentTextRegion.getTextLength() + 1);

              }

            }

            // update line width

            constraints.setAvailableLineWidth(availableLineWidth);

            return false;

          }

          else if (DOMRegionContext.XML_EMPTY_TAG_CLOSE.equals(nextType)) {

            int textLength = currentTextRegion.getTextLength();

            int regionLength = currentTextRegion.getLength();

            boolean thereAreSpaces = textLength < regionLength;

            if (!oneSpaceInTagName && thereAreSpaces) {

              // delete any trail spaces after tag name

              deleteTrailingSpaces(textEdit, currentTextRegion, currentDocumentRegion);

              availableLineWidth -= (currentTextRegion.getTextLength() + 2);

            }

            // insert a space and collapse ONLY IF it's specified

            else if (oneSpaceInTagName) {

              insertSpaceAndCollapse(textEdit, currentDocumentRegion, availableLineWidth, currentTextRegion);

              availableLineWidth -= (currentTextRegion.getTextLength() + 3);

            }

            // update line width

            constraints.setAvailableLineWidth(availableLineWidth);

            return true;

          }

          else {

            if (DOMRegionContext.XML_TAG_ATTRIBUTE_NAME.equals(currentType) && DOMRegionContext.XML_TAG_ATTRIBUTE_EQUALS.equals(nextType)) {

              if (currentTextRegion.getTextLength() < currentTextRegion.getLength()) {

                deleteTrailingSpaces(textEdit, currentTextRegion, currentDocumentRegion);

              }

              // update available width

              availableLineWidth -= currentTextRegion.getTextLength();

            }

            else if (DOMRegionContext.XML_TAG_ATTRIBUTE_EQUALS.equals(currentType) && DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE.equals(nextType)) {

              if (currentTextRegion.getTextLength() < currentTextRegion.getLength()) {

                deleteTrailingSpaces(textEdit, currentTextRegion, currentDocumentRegion);

              }

              // update available width

              availableLineWidth -= currentTextRegion.getTextLength();

            }

            else {

              // otherwise, insertSpaceAndCollapse

              insertSpaceAndCollapse(textEdit, currentDocumentRegion, availableLineWidth, currentTextRegion);

              // update available line width

              availableLineWidth -= (currentTextRegion.getTextLength() + 1);

            }

          }

          currentTextRegion = nextTextRegion;

          currentType = nextType;

          ++currentTextRegionIndex;

        }

      }

    }

    // update line width

    constraints.setAvailableLineWidth(availableLineWidth);

    return false;

  }

 

  /**

   * Format an XML comment structured document region.

   */

  private void formatComment(TextEdit textEdit, Position formatRange, XMLFormattingConstraints parentConstraints, DOMRegion currentDOMRegion, IStructuredDocumentRegion previousRegion) {

    IStructuredDocumentRegion currentRegion = currentDOMRegion.documentRegion;

    int lineWidth = parentConstraints.getAvailableLineWidth() - currentRegion.getFullText().length();

    // Don't format if we're not exceeding the available line width, or if the whitespace

    // strategy is to preserve whitespace - But update line width.

    if(currentRegion == null ||  XMLFormattingConstraints.PRESERVE.equals(parentConstraints.getWhitespaceStrategy()) || !fPreferences.getFormatCommentText()) {

      parentConstraints.setAvailableLineWidth(lineWidth);

      return;

    }

    Iterator it = currentRegion.getRegions().iterator();

    ITextRegion previous = null;

    if (previousRegion == null)

      previousRegion = currentRegion.getPrevious();

    // Iterate over each text region of the comment

    Node parent = currentDOMRegion.domNode.getParentNode();

    while(it.hasNext()) {

      ITextRegion text = (ITextRegion) it.next();

      String type = text.getType();

      if (type == DOMRegionContext.XML_COMMENT_OPEN) {

        int indentLevel = (parent != null && parent.getNodeType() == Node.DOCUMENT_NODE) ? 0 : 1;

        int width = formatCommentStart(textEdit, parentConstraints, indentLevel, currentRegion, previousRegion, text);

        parentConstraints.setAvailableLineWidth(width);

      }

      else if (type == DOMRegionContext.XML_COMMENT_TEXT) {

        int indentLevel = (parent != null && parent.getNodeType() == Node.DOCUMENT_NODE) ? -1 : parentConstraints.getIndentLevel();

        formatCommentContent(textEdit, parentConstraints, indentLevel, currentRegion, previous, text);

      }

      previous = text;

    }

  }

  private void formatCommentContent(TextEdit textEdit, XMLFormattingConstraints parentConstraints, int indentLevel, IStructuredDocumentRegion currentRegion, ITextRegion previous, ITextRegion region) {

    int lineWidth = parentConstraints.getAvailableLineWidth() - currentRegion.getFullText(previous).length();

    // If there's more text than line width available, format

    String text = currentRegion.getFullText(region);

    compressContent(textEdit, currentRegion, currentRegion.getStartOffset(region), indentLevel + 1, lineWidth, text);

  }

  private void compressContent(TextEdit textEdit, IStructuredDocumentRegion region, int startOffset, int indentLevel, int lineWidth, String text) {

    int length = text.length();

    int start = 0, end = 0;

    char c = 0;

    int resultLength = 0;

    boolean joinLines = fPreferences.getJoinCommentLines();

    boolean onOwnLine = false;

    String indent = getIndentString(indentLevel + 1);

    for (int i = 0; i < length; i++) {

      c = text.charAt(i);

      // Compress whitespace unless its a line delimiter and formatting does not permit joining lines

      if (Character.isWhitespace(c)) {

        if ((c != '\r' && c!= '\n') || joinLines) {

          // Just came off of a word

          if (start == end) {

            start = end = i;

          }

          end++;

          resultLength++;

        }

        else {

          // correct the indent of this line

          lineWidth = fPreferences.getMaxLineWidth();

          resultLength = 0;

          onOwnLine = true;

          // Compress any whitespace before the line delimiter

          if (start != end) {

            int replaceLength = end - start;

            textEdit.addChild(new ReplaceEdit(start + startOffset, replaceLength, EMPTY));

            start = end = i;

          }

        }

      }

      else {

        // Transitioned to a new word

        if (start != end) {

          int replaceLength = end - start;

          if (onOwnLine) {

            // If content is on its own line, replace leading whitespace with proper indent

            textEdit.addChild(new ReplaceEdit(start + startOffset, replaceLength, indent));

            resultLength -= (replaceLength - indent.length());

            onOwnLine = false;

          }

          else if (!(replaceLength == 1 && text.charAt(start) == ' ')) {

            textEdit.addChild(new ReplaceEdit(start + startOffset, replaceLength, SPACE));

            resultLength -= (replaceLength - 1);

          }

          start = end = i;

          // Make sure the word starts on a new line

          if (resultLength > lineWidth) {

            lineWidth = fPreferences.getMaxLineWidth();

            resultLength = 0;

            textEdit.addChild(new InsertEdit(start + startOffset, getLineDelimiter(region) + indent));

          }

        }

        // Word is immediately after line delimiters, indent appropriately

        if (onOwnLine) {

          textEdit.addChild(new InsertEdit(i + startOffset, indent));

          onOwnLine = false;

        }

        resultLength++;

      }

    }

    // Clean up any dangling whitespace

    int replaceLength = end - start;

    indent = getIndentString(indentLevel);

    if (replaceLength == 0) { // No trailing whitespace

      textEdit.addChild(new InsertEdit(length + startOffset, (onOwnLine) ? indent : SPACE));

    }

    else {

      String whitespace = text.substring(start);

      String replacement = (onOwnLine) ? indent : SPACE;

      if (!whitespace.equals(replacement)) {

        textEdit.addChild(new ReplaceEdit(start + startOffset, replaceLength, replacement));

      }

    }

  }

  private int formatCommentStart(TextEdit textEdit, XMLFormattingConstraints parentConstraints, int indentLevel, IStructuredDocumentRegion currentRegion, IStructuredDocumentRegion previousRegion, ITextRegion region) {

    int lineWidth = parentConstraints.getAvailableLineWidth();

    if (previousRegion!=null&&(DOMRegionContext.XML_CONTENT.equals(previousRegion.getType()))) {

      String previousText = previousRegion.getFullText();

      String trailingWhitespace = getTrailingWhitespace(previousText);

      String delimiters = extractLineDelimiters(trailingWhitespace, previousRegion);

      if (delimiters != null && delimiters.length() > 0){// && previousText.length() == trailingWhitespace.length()) {

        // Format the comment if it's on a new line

        int offset = previousRegion.getEnd() - trailingWhitespace.length();

        lineWidth = indentIfNotAlreadyIndented(textEdit, currentRegion, parentConstraints.getIndentLevel() + indentLevel, offset, trailingWhitespace);

      }

    }

    return lineWidth;

  }

  /**

   * Returns either a String of whitespace or characters depending on

   * forWhitespace

   *

   * @param fullTextArray

   *            the text array to look in

   * @param textOffset

   *            the start offset to start searching

   * @param forWhitespace

   *            true if should return whitespaces, false otherwise

   * @return a String of either all whitespace or all characters. Never

   *         returns null

   */

  private String getCharacterRun(char[] fullTextArray, int textOffset, boolean forWhitespace) {

    StringBuffer characterRun = new StringBuffer();

    boolean nonCharacterFound = false;

    while (textOffset < fullTextArray.length && !nonCharacterFound) {

      char c = fullTextArray[textOffset];

      boolean isWhitespace = Character.isWhitespace(c);

      if ((forWhitespace && isWhitespace) || (!forWhitespace && !isWhitespace))

        characterRun.append(c);

      else

        nonCharacterFound = true;

      ++textOffset;

    }

    return characterRun.toString();

  }

 

  private String getTrailingWhitespace(String text) {

    StringBuffer whitespaceRun = new StringBuffer();

    int index = text.length() - 1;

    while(index >= 0) {

      char c = text.charAt(index--);

      if (Character.isWhitespace(c))

        whitespaceRun.insert(0, c);

      else

        break;

    }

    return whitespaceRun.toString();

  }

  private String getIndentString(int indentLevel) {

    StringBuffer indentString = new StringBuffer();

    String indent = getFormattingPreferences().getOneIndent();

    for (int i = 0; i < indentLevel; ++i) {

      indentString.append(indent);

    }

    return indentString.toString();

  }

  protected XMLFormattingPreferences getFormattingPreferences() {

    if (fPreferences == null)

      fPreferences = new XMLFormattingPreferences();

    return fPreferences;

  }

  protected void setFormattingPreferences(XMLFormattingPreferences preferences) {

    fPreferences = preferences;

  }

  /**

   * Indent if whitespaceRun does not already contain an indent

   *

   * @param textEdit

   * @param indentLevel

   * @param indentStartOffset